public bool SuppressUsageInspectionsOnElement(IDeclaredElement element, out ImplicitUseKindFlags flags)
 {
     flags = 0;
     var suppress = element.IsAnyUnitTestElement();
     if (suppress)
         flags = ImplicitUseKindFlags.Default;
     return suppress;
 }

        public bool SuppressUsageInspectionsOnElement(IDeclaredElement element, out ImplicitUseKindFlags flags)
        {
            // TODO: Only do any work if the element belongs to a project that references Unity.Engine

            var cls = element as IClass;
            if (cls != null)
            {
                if(MonoBehaviourUtil.IsMonoBehaviourType(cls, cls.Module))
                {
                    flags = ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature;
                    return true;
                }
            }

            var method = element as IMethod;
            if (method != null && MonoBehaviourUtil.IsEventHandler(method.ShortName))
            {
                var containingType = method.GetContainingType();
                if (containingType != null && MonoBehaviourUtil.IsMonoBehaviourType(containingType, method.Module))
                {
                    flags = ImplicitUseKindFlags.Access;
                    return true;
                }
            }

            var field = element as IField;
            if (field != null && field.GetAccessRights() == AccessRights.PUBLIC)
            {
                var containingType = field.GetContainingType();
                if (containingType != null && MonoBehaviourUtil.IsMonoBehaviourType(containingType, field.Module))
                {
                    // Public fields gets exposed to the Unity Editor and assigned from the UI. But it still should be checked if the field is ever accessed from the code.
                    flags = ImplicitUseKindFlags.Assign;
                    return true;
                }
            }

            flags = ImplicitUseKindFlags.Default;
            return false;
        }

        public bool SuppressUsageInspectionsOnElement(IDeclaredElement element, out ImplicitUseKindFlags flags)
        {
            flags = ImplicitUseKindFlags.Default;
            ITypeElement typeElement = element as ITypeElement;
            if (typeElement == null)
                return false;

            var patternManager = typeElement.GetSolution().GetComponent<IPatternManager>();
            IPsiSourceFile file = typeElement.GetSingleOrDefaultSourceFile();
            if (file == null)
                return false;

            IEnumerable<RegistrationInfo> registrations = patternManager.GetRegistrationsForFile(file);

            if (registrations.Any(info => info.Registration.IsSatisfiedBy(typeElement)))
            {
                flags = ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature;
                return true;
            }

            return false;
        }

        public bool SuppressUsageInspectionsOnElement(IDeclaredElement element, out ImplicitUseKindFlags flags)
        {
            flags = ImplicitUseKindFlags.Default;

            if (!element.IsFromUnityProject()) return false;

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

            var cls = element as IClass;
            if (cls != null)
            {
                if(unityApi.IsUnityType(cls))
                {
                    flags = ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature;
                    return true;
                }
            }

            var method = element as IMethod;
            if (method != null && unityApi.IsEventFunction(method))
            {
                flags = ImplicitUseKindFlags.Access;
                return true;
            }

            var field = element as IField;
            if (field != null && unityApi.IsUnityField(field))
            {
                // Public fields gets exposed to the Unity Editor and assigned from the UI. But it still should be checked if the field is ever accessed from the code.
                flags = ImplicitUseKindFlags.Assign;
                return true;
            }

            flags = ImplicitUseKindFlags.Default;   // Value not used if we return false
            return false;
        }

 public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
 {
   UseKindFlags = useKindFlags;
   TargetFlags = targetFlags;
 }

 public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
 {
   UseKindFlags = useKindFlags;
   TargetFlags = targetFlags;
 }

 public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags = ImplicitUseTargetFlags.Default)
 {
     this.UseKindFlags = useKindFlags;
     this.TargetFlags = targetFlags;
 }

 // Bah humbug typos fixed between versions
 public bool SupressUsageInspectionsOnElement(IDeclaredElement element, out ImplicitUseKindFlags flags)
 {
     return SuppressUsageInspectionsOnElement(element, out flags);
 }

 public bool SupressUsageInspectionsOnElement(IDeclaredElement element, out ImplicitUseKindFlags flags)
 {
     flags = ImplicitUseKindFlags.Default;
     return UnitTestElementPsiIdentifier.IsAnyUnitTestElement(element);
 }