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;
        }
Exemplo n.º 5
0
 public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
 {
   UseKindFlags = useKindFlags;
   TargetFlags = targetFlags;
 }
Exemplo n.º 6
0
 public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags)
   : this(useKindFlags, ImplicitUseTargetFlags.Default) { }
Exemplo n.º 7
0
 public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
 {
   UseKindFlags = useKindFlags;
   TargetFlags = targetFlags;
 }
Exemplo n.º 8
0
 public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags)
   : this(useKindFlags, ImplicitUseTargetFlags.Default) { }
Exemplo n.º 9
0
 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);
 }
Exemplo n.º 12
0
 public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags)
     : this(useKindFlags, ImplicitUseTargetFlags.Default)
 {
 }
Exemplo n.º 13
0
 public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
 {
     UseKindFlags = useKindFlags;
     TargetFlags  = targetFlags;
 }
Exemplo n.º 14
0
 public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags)
     : this(useKindFlags, ImplicitUseTargetFlags.Default)
 {
 }
Exemplo n.º 15
0
 public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
 {
     UseKindFlags = useKindFlags;
     TargetFlags  = targetFlags;
 }
Exemplo n.º 16
0
 /// <summary>
 /// Initializes a new instance of the <see cref="MeansImplicitUseAttribute" /> class.
 /// </summary>
 /// <param name="useKindFlags">The use kind flags.</param>
 /// <param name="targetFlags">The target flags.</param>
 public MeansImplicitUseAttribute(
     ImplicitUseKindFlags useKindFlags, ImplicitUseTarget targetFlags)
 {
     this.UseKindFlags = useKindFlags;
     this.TargetFlags  = targetFlags;
 }