Esempio n. 1
0
        public static PackerAttribute Read(IAnnotationInstance annotation)
        {
            PackerAttribute           config         = new PackerAttribute();
            MemberValuePairCollection namedArguments = annotation.Value.NamedArguments;

            config.DisableCleanup            = namedArguments.GetSafeBool(nameof(PackerAttribute.DisableCleanup), false);
            config.DisableCompression        = namedArguments.GetSafeBool(nameof(PackerAttribute.DisableCompression), false);
            config.IncludeDebugSymbols       = namedArguments.GetSafeBool(nameof(PackerAttribute.IncludeDebugSymbols), true);
            config.LoadAtModuleInit          = namedArguments.GetSafeBool(nameof(PackerAttribute.LoadAtModuleInit), true);
            config.CreateTemporaryAssemblies = namedArguments.GetSafeBool(nameof(PackerAttribute.CreateTemporaryAssemblies), false);
            config.IgnoreSatelliteAssemblies = namedArguments.GetSafeBool(nameof(PackerAttribute.IgnoreSatelliteAssemblies), false);

            config.IncludeAssemblies     = namedArguments.GetSafeStringArray(nameof(PackerAttribute.IncludeAssemblies));
            config.ExcludeAssemblies     = namedArguments.GetSafeStringArray(nameof(PackerAttribute.ExcludeAssemblies));
            config.PreloadOrder          = namedArguments.GetSafeStringArray(nameof(PackerAttribute.PreloadOrder));
            config.Unmanaged32Assemblies = namedArguments.GetSafeStringArray(nameof(PackerAttribute.Unmanaged32Assemblies));
            config.Unmanaged64Assemblies = namedArguments.GetSafeStringArray(nameof(PackerAttribute.Unmanaged64Assemblies));

            if (config.IncludeAssemblies != null && config.IncludeAssemblies.Length > 0 &&
                config.ExcludeAssemblies != null && config.ExcludeAssemblies.Length > 0)
            {
                Message.Write(annotation.TargetElement, SeverityType.Error, "JOE01", "Set IncludeAssemblies, or ExcludeAssemblies, but not both.");
            }
            return(config);
        }
        /// <summary>
        /// Gets the set of all fields that should not participate in Equals and GetHashCode generated because they're
        /// the target of [IgnoreDuringEquals].
        /// </summary>
        public static ISet <FieldDefDeclaration> GetIgnoredFields(IAnnotationRepositoryService annotations,
                                                                  ICompilerAdapterService compilerAdapterService)
        {
            HashSet <FieldDefDeclaration>     fields = new HashSet <FieldDefDeclaration>();
            IEnumerator <IAnnotationInstance> ignoredFieldsAnnotations =
                annotations.GetAnnotationsOfType(typeof(IgnoreDuringEqualsAttribute), false, false);

            while (ignoredFieldsAnnotations.MoveNext())
            {
                IAnnotationInstance annotationInstance = ignoredFieldsAnnotations.Current;
                MetadataDeclaration targetElement      = annotationInstance.TargetElement;
                if (targetElement is FieldDefDeclaration field)
                {
                    fields.Add(field);
                }
                else if (targetElement is PropertyDeclaration propertyDeclaration)
                {
                    FieldDefDeclaration backingField = compilerAdapterService.GetBackingField(propertyDeclaration);
                    if (backingField != null)
                    {
                        fields.Add(backingField);
                    }
                    else
                    {
                        // The property is not an automatic property.
                        // It's ignored, because there is no backing field and we make equality by fields.
                        // We could emit a warning but I don't think that's a great idea. Like, yeah, ignoring a
                        // non-automatic property has no effect but so what: it's ignored, just like the user wanted.
                    }
                }
            }

            return(fields);
        }
        public override bool Execute()
        {
            IEnumerator <IAnnotationInstance> annotations =
                annotationService.GetAnnotationsOfType(typeof(DeepSerializableAttribute), false, true);

            while (annotations.MoveNext())
            {
                IAnnotationInstance annotation = annotations.Current;
                MakeSerializableRecursively(annotation.TargetElement as TypeDefDeclaration);
            }

            return(base.Execute());
        }
        /// <summary>
        /// Gets types for which Equals or GetHashCode should be synthesized, in such an order that base classes come before
        /// derived classes. This way, when Equals for a derived class is being created, you can be already sure that
        /// the Equals for the base class was already created (if the base class was target of [StructuralEquality].
        /// </summary>
        private List <EqualsType> GetTypesToEnhance()
        {
            IEnumerator <IAnnotationInstance> annotationsOfType =
                annotationRepositoryService.GetAnnotationsOfType(typeof(StructuralEqualityAttribute), false, false);

            // TODO: Change the List into a StructuredDeclarationDictionary, because then Visit takes the order of inheritance into
            // account. But first we would need to make that public in PostSharp.Compiler.Engine.

            List <EqualsType> toEnhance = new List <EqualsType>();

            while (annotationsOfType.MoveNext())
            {
                IAnnotationInstance annotation = annotationsOfType.Current;
                if (annotation?.TargetElement is TypeDefDeclaration enhancedType)
                {
                    StructuralEqualityAttribute config = EqualityConfiguration.ExtractFrom(annotation.Value);
                    EqualsType newType = new EqualsType(enhancedType, config);
                    toEnhance.Add(newType);
                }
            }

            toEnhance.Sort((first, second) =>
            {
                if (first.EnhancedType.IsAssignableTo(second.EnhancedType))
                {
                    if (second.EnhancedType.IsAssignableTo(first.EnhancedType))
                    {
                        return(0);
                    }

                    return(1);
                }

                return(-1);
            });

            return(toEnhance);
        }
        protected override AdviceGroupingKey GetGroupingKey(IAnnotationInstance adviseAnnotation)
        {
            var key = base.GetGroupingKey(adviseAnnotation);

            return key;
        }
 public override bool ValidateAdvice(IAnnotationInstance adviseAnnotation)
 {
     if (adviseAnnotation.TargetElement.GetTokenType() != TokenType.TypeDef) return false;
     return base.ValidateAdvice(adviseAnnotation);
 }