private void AddAbcAttribute(IMutableInfo customAttributeTarget, string value)
        {
            var ctor      = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(""));
            var attribute = new CustomAttributeDeclaration(ctor, new object[] { value });

            customAttributeTarget.AddCustomAttribute(attribute);
        }
Example #2
0
        public void Initialization()
        {
            var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainAttribute((ValueType)null));
            var property    = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainAttribute obj) => obj.Property);
            var field       = NormalizingMemberInfoFromExpressionUtility.GetField((DomainAttribute obj) => obj.Field);

            var declaration = new CustomAttributeDeclaration(
                constructor,
                new object[] { 7 },
                new NamedArgumentDeclaration(property, 7),
                new NamedArgumentDeclaration(field, "value"));

            Assert.That(declaration.Type, Is.SameAs(typeof(DomainAttribute)));
            Assert.That(declaration.Constructor, Is.SameAs(constructor));
            Assert.That(declaration.ConstructorArguments, Is.EqualTo(new[] { 7 }));
            var actualNamedArguments   = declaration.NamedArguments.Select(na => new { na.MemberInfo, na.Value });
            var expectedNamedArguments =
                new[]
            {
                new { MemberInfo = (MemberInfo)property, Value = (object)7 },
                new { MemberInfo = (MemberInfo)field, Value = (object)"value" }
            };

            Assert.That(actualNamedArguments, Is.EqualTo(expectedNamedArguments));
        }
Example #3
0
        public void OverrideExisting_AddCustomAttribute()
        {
            var type = AssembleType <DomainType> (
                proxyType =>
            {
                var existingProperty = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.ExistingProperty);
                var getMethod        = proxyType.GetOrAddOverride(existingProperty.GetGetMethod());
                var setMethod        = proxyType.GetOrAddOverride(existingProperty.GetSetMethod());
                var property         = proxyType.AddProperty(existingProperty.Name, PropertyAttributes.None, getMethod, setMethod);

                var attributeCtor    = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(""));
                var customAttributes = new CustomAttributeDeclaration(attributeCtor, new object[] { "derived" });
                property.AddCustomAttribute(customAttributes);
            });

            var newProperty = type.GetProperty("ExistingProperty");
            var instance    = (DomainType)Activator.CreateInstance(type);

            Assert.That(instance.ExistingProperty, Is.Null);
            Assert.That(newProperty.GetValue(instance, null), Is.Null);
            newProperty.SetValue(instance, "Test", null);
            Assert.That(instance.ExistingProperty, Is.EqualTo("Test"));
            Assert.That(newProperty.GetValue(instance, null), Is.EqualTo("Test"));

            var attributeArgs = Attribute.GetCustomAttributes(newProperty, inherit: true).Cast <AbcAttribute>().Select(a => a.Arg);

            Assert.That(attributeArgs, Is.EquivalentTo(new[] { "base", "derived" }));
        }
Example #4
0
        public override void Participate(object id, IProxyTypeAssemblyContext proxyTypeAssemblyContext)
        {
            var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new ModifiedAssembledTypeAttribute());
            var attribute   = new CustomAttributeDeclaration(constructor, new object[0]);

            proxyTypeAssemblyContext.ProxyType.AddCustomAttribute(attribute);
        }
Example #5
0
        public void WithCustomAttribute()
        {
            var type = AssembleType <OriginalType> (
                proxyType =>
            {
                var mutableFieldInfo = proxyType.AddField("_fieldWithCustomAttributes", FieldAttributes.Private, typeof(int));

                var attributeCtor = typeof(AddedAttribute).GetConstructor(new[] { typeof(string) });
                var namedProperty = typeof(AddedAttribute).GetProperty("NamedPropertyArg");
                var namedField    = typeof(AddedAttribute).GetField("NamedFieldArg");
                var customAttributeDeclaration = new CustomAttributeDeclaration(
                    attributeCtor,
                    new object[] { "ctorArg" },
                    new NamedArgumentDeclaration(namedProperty, 7),
                    new NamedArgumentDeclaration(namedField, new[] { MyEnum.Other, MyEnum.Default }));
                mutableFieldInfo.AddCustomAttribute(customAttributeDeclaration);
            });

            var field            = type.GetField("_fieldWithCustomAttributes", BindingFlags.Instance | BindingFlags.NonPublic);
            var customAttributes = field.GetCustomAttributes(false);

            Assert.That(customAttributes, Has.Length.EqualTo(1));

            var customAttribute = (AddedAttribute)customAttributes.Single();

            Assert.That(customAttribute.CtorArg, Is.EqualTo("ctorArg"));
            Assert.That(customAttribute.NamedPropertyArg, Is.EqualTo(7));
            Assert.That(customAttribute.NamedFieldArg, Is.EqualTo(new[] { MyEnum.Other, MyEnum.Default }));
        }
        public void SetCustomAttribute()
        {
            var attributeCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(null));
            var property      = NormalizingMemberInfoFromExpressionUtility.GetProperty((AbcAttribute obj) => obj.StringProperty);
            var field         = NormalizingMemberInfoFromExpressionUtility.GetField((AbcAttribute obj) => obj.IntField);

            var wasCalled = false;
            Action <CustomAttributeBuilder> setCustomAttributeMethod = customAttributeBuilder =>
            {
                wasCalled = true;
                Assert.That(customAttributeBuilder, Is.Not.Null);

                CheckCustomAttributeBuilder(
                    customAttributeBuilder,
                    attributeCtor,
                    new object[] { typeof(int) },
                    new[] { property },
                    new object[] { "def" },
                    new[] { field },
                    new object[] { 8 });
            };
            var adapterBasePartialMock = MockRepository.GeneratePartialMock <BuilderAdapterBase> (setCustomAttributeMethod);
            var declaration            = new CustomAttributeDeclaration(
                attributeCtor, new object[] { typeof(int) }, new NamedArgumentDeclaration(property, "def"), new NamedArgumentDeclaration(field, 8));

            adapterBasePartialMock.SetCustomAttribute(declaration);

            Assert.That(wasCalled, Is.True);
        }
Example #7
0
        public override void SetUp()
        {
            base.SetUp();

            _signedType   = typeof(int);
            _unsignedType = CreateUnsignedType(TypeAttributes.Class, typeof(object));

            _signedInterfaceType   = typeof(IMarkerInterface);
            _unsignedInterfaceType = CreateUnsignedType(TypeAttributes.Interface | TypeAttributes.Abstract, baseType: null);

            _signedDelegateType   = typeof(Action);
            _unsignedDelegateType = typeof(Action <>).MakeGenericType(_unsignedType);

            var attributeCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(null));

            _signedAttribute   = new CustomAttributeDeclaration(attributeCtor, new object[] { _signedType });
            _unsignedAttribute = new CustomAttributeDeclaration(attributeCtor, new object[] { _unsignedType });

            _signedField   = NormalizingMemberInfoFromExpressionUtility.GetField(() => DomainType.Field);
            _unsignedField = _unsignedType.GetField("field");

            _signedCtor   = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainType());
            _unsignedCtor = _unsignedType.GetConstructors().Single();

            _signedMethod   = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => DomainType.Method());
            _unsignedMethod = _unsignedType.GetMethod("method");

            _signedVarArgsMethod   = typeof(DomainType).GetMethod("VarArgsMethod");
            _unsignedVarArgsMethod = _unsignedType.GetMethod("varargs");
        }
Example #8
0
        public void CreateInstance_NamedArgument()
        {
            var declaration = new CustomAttributeDeclaration(_defaultCtor, new object[0], new NamedArgumentDeclaration(_property, 4711));

            var instance = (AbcAttribute)declaration.CreateInstance();

            Assert.That(instance.Property, Is.EqualTo(4711));
        }
Example #9
0
        public void CreateInstance_CtorArgument()
        {
            ICustomAttributeData declaration = new CustomAttributeDeclaration(_ctorWithArgs, new object[] { 7 });

            var instance = (AbcAttribute)declaration.CreateInstance();

            Assert.That(instance.CtorArg, Is.EqualTo(7));
        }
Example #10
0
        public void CreateInstance_NoArguments()
        {
            ICustomAttributeData declaration = new CustomAttributeDeclaration(_defaultCtor, new object[0]);

            var instance = CustomAttributeDataExtensions.CreateInstance(declaration);

            Assert.That(instance, Is.TypeOf <AbcAttribute>());
        }
        public CustomAttributeTreeNode( CustomAttributeDeclaration customAttribute )
            : base( customAttribute, TreeViewImage.CustomAttribute )
        {
            StringBuilder name = new StringBuilder( 256 );
            name.Append( CustomAttributeHelper.Render( customAttribute ) );

            this.Text = name.ToString();
        }
        public void AddDebuggerBrowsableAttribute(IMutableMember member, DebuggerBrowsableState debuggerBrowsableState)
        {
            ArgumentUtility.CheckNotNull("member", member);

            var attribute = new CustomAttributeDeclaration(s_debuggerBrowsableAttributeConstructor, new object[] { debuggerBrowsableState });

            member.AddCustomAttribute(attribute);
        }
Example #13
0
        public void Initialization_WithNullArgument()
        {
            var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainAttribute((ValueType)null));

            var declaration = new CustomAttributeDeclaration(constructor, new object[] { null });

            Assert.That(declaration.ConstructorArguments[0], Is.Null);
        }
        public CustomAttributeTreeNode(CustomAttributeDeclaration customAttribute)
            : base(customAttribute, TreeViewImage.CustomAttribute)
        {
            StringBuilder name = new StringBuilder(256);

            name.Append(CustomAttributeHelper.Render(customAttribute));

            this.Text = name.ToString();
        }
        public void AddConcreteMixinTypeAttribute(IMutableMember member, ConcreteMixinTypeIdentifier concreteMixinTypeIdentifier)
        {
            ArgumentUtility.CheckNotNull("member", member);
            ArgumentUtility.CheckNotNull("concreteMixinTypeIdentifier", concreteMixinTypeIdentifier);

            var attributeData = ConcreteMixinTypeAttribute.Create(concreteMixinTypeIdentifier).ConcreteMixinTypeIdentifierData;
            var attribute     = new CustomAttributeDeclaration(s_concreteMixinTypeAttributeConstructor, new object[] { attributeData });

            member.AddCustomAttribute(attribute);
        }
Example #16
0
        public void CreateInstance_NullArguments()
        {
            var ctorArg     = new object[] { "x", null };
            var declaration = new CustomAttributeDeclaration(
                _ctorWithArgs, new object[] { ctorArg }, new NamedArgumentDeclaration(_property, null));

            var instance = (AbcAttribute)declaration.CreateInstance();

            Assert.That(instance.CtorArg, Is.EqualTo(ctorArg));
            Assert.That(instance.Property, Is.Null);
        }
        public void SetCustomAttribute(CustomAttributeDeclaration customAttributeDeclaration)
        {
            ArgumentUtility.CheckNotNull("customAttributeDeclaration", customAttributeDeclaration);

            var emittableConstructorArguments = customAttributeDeclaration.ConstructorArguments.Select(MakeAttributeArgumentEmittable).ToArray();
            var emittableNamedArguments       = customAttributeDeclaration.NamedArguments.Select(MakeEmittable).ToArray();
            var emittableDeclaration          = new CustomAttributeDeclaration(
                customAttributeDeclaration.Constructor, emittableConstructorArguments, emittableNamedArguments);

            _customAttributeTargetBuilder.SetCustomAttribute(emittableDeclaration);
        }
        public void AddGeneratedMethodWrapperAttribute(IMutableMember member, MethodInfo methodToBeWrapped)
        {
            ArgumentUtility.CheckNotNull("member", member);
            ArgumentUtility.CheckNotNull("methodToBeWrapped", methodToBeWrapped);

            var attribute = new CustomAttributeDeclaration(
                s_generatedMethodWrapperAttributeConstructor,
                new object[] { methodToBeWrapped.DeclaringType, methodToBeWrapped.Name, methodToBeWrapped.ToString() });

            member.AddCustomAttribute(attribute);
        }
        public void AddOverrideInterfaceMappingAttribute(IMutableMember member, MethodInfo overriddenMethod)
        {
            ArgumentUtility.CheckNotNull("member", member);
            ArgumentUtility.CheckNotNull("overriddenMethod", overriddenMethod);

            var attribute = new CustomAttributeDeclaration(
                s_overrideInterfaceMappingAttributeConstructor,
                new object[] { overriddenMethod.DeclaringType, overriddenMethod.Name, overriddenMethod.ToString() });

            member.AddCustomAttribute(attribute);
        }
        public void AddCustomAttribute(CustomAttributeDeclaration customAttribute)
        {
            ArgumentUtility.CheckNotNull("customAttribute", customAttribute);

            if (_addedCustomAttributes.Any(a => a.Type == customAttribute.Type && !AttributeUtility.IsAttributeAllowMultiple(a.Type)))
            {
                var message = string.Format("Attribute of type '{0}' (with AllowMultiple = false) is already present.", customAttribute.Type.Name);
                throw new InvalidOperationException(message);
            }

            _addedCustomAttributes.Add(customAttribute);
        }
        public void AddIntroducedMemberAttribute(IMutableMember member, MemberInfo interfaceMember, MemberDefinitionBase implementingMember)
        {
            ArgumentUtility.CheckNotNull("member", member);
            ArgumentUtility.CheckNotNull("interfaceMember", interfaceMember);
            ArgumentUtility.CheckNotNull("implementingMember", implementingMember);

            var attribute = new CustomAttributeDeclaration(
                s_introducedMemberAttributeConstructor,
                new object[] { implementingMember.DeclaringClass.Type, implementingMember.Name, interfaceMember.DeclaringType, interfaceMember.Name });

            member.AddCustomAttribute(attribute);
        }
        public void AddAttribute(IMutableMember member, ICustomAttributeData attributeData)
        {
            ArgumentUtility.CheckNotNull("member", member);
            ArgumentUtility.CheckNotNull("attributeData", attributeData);

            var attribute = new CustomAttributeDeclaration(
                attributeData.Constructor,
                attributeData.ConstructorArguments.ToArray(),
                attributeData.NamedArguments.Select(CreateNamedArgumentDeclaration).ToArray());

            member.AddCustomAttribute(attribute);
        }
Example #23
0
        public void CreateInstance_ComplexArguments()
        {
            var ctorArg     = new object[] { "x", 7, typeof(int), new[] { MyEnum.C, MyEnum.A } };
            var namedArg    = new object[] { "z", 8, new[] { 1, 2, 3 }, new[] { typeof(double), typeof(string) }, MyEnum.B };
            var declaration = new CustomAttributeDeclaration(
                _ctorWithArgs, new object[] { ctorArg }, new NamedArgumentDeclaration(_property, namedArg));

            var instance = (AbcAttribute)declaration.CreateInstance();

            Assert.That(instance.CtorArg, Is.EqualTo(ctorArg));
            Assert.That(instance.Property, Is.EqualTo(namedArg));
        }
        public void AddConcreteMixedTypeAttribute(IMutableMember member, ClassContext classContext, IEnumerable <Type> orderedMixinTypes)
        {
            ArgumentUtility.CheckNotNull("member", member);
            ArgumentUtility.CheckNotNull("classContext", classContext);
            ArgumentUtility.CheckNotNull("orderedMixinTypes", orderedMixinTypes);

            var attributeData = ConcreteMixedTypeAttribute.FromClassContext(classContext, orderedMixinTypes.ToArray());
            var attribute     = new CustomAttributeDeclaration(
                s_concreteMixedTypeAttributeConstructor, new object[] { attributeData.ClassContextData, attributeData.OrderedMixinTypes });

            member.AddCustomAttribute(attribute);
        }
Example #25
0
        public IModuleBuilder CreateModuleBuilder(string assemblyName, string assemblyDirectoryOrNull, bool strongNamed, string keyFilePathOrNull)
        {
            ArgumentUtility.CheckNotNullOrEmpty("assemblyName", assemblyName);

            var moduleBuilder = _moduleBuilderFactory.CreateModuleBuilder(assemblyName, assemblyDirectoryOrNull, strongNamed, keyFilePathOrNull);

            var attribute = new CustomAttributeDeclaration(s_nonApplicationAssemblyAttributeConstructor, new object[0]);

            moduleBuilder.AssemblyBuilder.SetCustomAttribute(attribute);

            return(moduleBuilder);
        }
        public void AddDebuggerDisplayAttribute(IMutableMember member, string debuggerDisplayString, string debuggerDisplayNameStringOrNull)
        {
            ArgumentUtility.CheckNotNull("member", member);
            ArgumentUtility.CheckNotNullOrEmpty("debuggerDisplayString", debuggerDisplayString);
            // Debugger display name may be null.

            var attribute = new CustomAttributeDeclaration(
                s_debuggerDisplayAttributeConstructor,
                new object[] { debuggerDisplayString },
                new NamedArgumentDeclaration(s_debuggerDisplayAttributeNameProperty, debuggerDisplayNameStringOrNull));

            member.AddCustomAttribute(attribute);
        }
Example #27
0
        private static Action <object, IProxyTypeAssemblyContext> CreateModifyingAction(Action <object, IProxyTypeAssemblyContext> participateAction)
        {
            return((id, ctx) =>
            {
                participateAction(id, ctx);

                if (ctx.ProxyType.AddedCustomAttributes.Count == 0)
                {
                    var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new TypeAssembledByIntegrationTestAttribute());
                    var attribute = new CustomAttributeDeclaration(constructor, new object[0]);

                    ctx.ProxyType.AddCustomAttribute(attribute);
                }
            });
        }
        public void RecordType_PropertiesAttributes()
        {
            var expectedAttributeValue = "bing://foo";
            var customAttribute        = new CustomAttributeDeclaration(typeof(FooAttribute), new List <object> {
                expectedAttributeValue
            }.AsReadOnly());
            var props = new[] { new StructuralFieldDeclaration("Foo", typeof(int), new List <CustomAttributeDeclaration> {
                    customAttribute
                }.AsReadOnly()) };
            var type            = RuntimeCompiler.CreateRecordType(props, valueEquality: true);
            var property        = type.GetProperty("Foo");
            var actualAttribute = property.GetCustomAttribute <FooAttribute>(inherit: false);

            Assert.IsNotNull(actualAttribute);
            Assert.AreEqual(expectedAttributeValue, actualAttribute.Uri);
        }
        public override bool Execute()
        {
            var enumerator = _annotationRepositoryService.GetAnnotationsOfType(typeof(ExporterAttribute), false, false);

            while (enumerator.MoveNext())
            {
                var serializedType = enumerator.Current !.Value.ConstructorArguments[0].Value;

                var exportedType = serializedType.Value.GetTypeDefinition();

                if (exportedType.CustomAttributes.Any(a =>
                                                      a.Constructor.Parent.GetTypeDefinition().Name == typeof(InheritedExportAttribute).FullName &&
                                                      a.ConstructorArguments.Count == 0))
                {
                    continue;
                }

                var module = Project.Module;

                var exportAttributeType = (INamedType)module.FindType(typeof(ExportAttribute));

                var exportAttributeCtor = module.FindMethod(exportAttributeType, ".ctor", c =>
                                                            c.Parameters.Count == 1 &&
                                                            c.Parameters[0].ParameterType.GetReflectionName() == "System.Type");

                var types = module.Types
                            .OfType <TypeDefDeclaration>()
                            .Where(t =>
                                   t.IsClass() &&
                                   !t.IsAbstract() &&
                                   !t.ExportsType(exportedType) &&
                                   (t.ImplementsInterface(exportedType) ||
                                    t.InheritsBase(exportedType)));

                foreach (var type in types)
                {
                    var export = new CustomAttributeDeclaration(exportAttributeCtor);
                    export.ConstructorArguments.Add(new MemberValuePair(
                                                        MemberKind.Parameter, 0, "contractType", serializedType));

                    type.CustomAttributes.Add(export);
                }
            }

            return(true);
        }
Example #30
0
        public void SetCustomAttribute(CustomAttributeDeclaration customAttributeDeclaration)
        {
            ArgumentUtility.CheckNotNull("customAttributeDeclaration", customAttributeDeclaration);

            var propertyArguments = customAttributeDeclaration.NamedArguments.Where(na => na.MemberInfo.MemberType == MemberTypes.Property).ToArray();
            var fieldArguments    = customAttributeDeclaration.NamedArguments.Where(na => na.MemberInfo.MemberType == MemberTypes.Field).ToArray();

            var customAttributeBuilder = new CustomAttributeBuilder(
                customAttributeDeclaration.Constructor,
                customAttributeDeclaration.ConstructorArguments.ToArray(),
                propertyArguments.Select(namedArg => (PropertyInfo)namedArg.MemberInfo).ToArray(),
                propertyArguments.Select(namedArg => namedArg.Value).ToArray(),
                fieldArguments.Select(namedArg => (FieldInfo)namedArg.MemberInfo).ToArray(),
                fieldArguments.Select(namedArg => namedArg.Value).ToArray());

            _setCustomAttributeMethod(customAttributeBuilder);
        }
Example #31
0
        private GeneratedTypesContext GenerateTypes(AssembledTypeID typeID, ProxyTypeAssemblyContext context, IMutableTypeBatchCodeGenerator codeGenerator)
        {
            // Add [AssembledType] attribute.
            var attribute = new CustomAttributeDeclaration(s_assembledTypeAttributeCtor, new object[0]);

            context.ProxyType.AddCustomAttribute(attribute);

            // Add '__typeID' and initialization code.
            _assembledTypeIdentifierProvider.AddTypeID(context.ProxyType, typeID);

            // Enable complex serialization.
            _complexSerializationEnabler.MakeSerializable(context.ProxyType, _participantConfigurationID, _assembledTypeIdentifierProvider, typeID);

            var mutableTypes = context.AdditionalTypes.Values.Concat(new[] { context.ProxyType });

            return(GenerateTypesWithDiagnostics(codeGenerator, mutableTypes, context.RequestedType.Name));
        }
        private static void ImplementSetter(
            PropertyDeclaration property,
            TypeDefDeclaration type,
            IField field,
            MethodAttributes methodAttributes,
            CustomAttributeDeclaration compilerGenerated)
        {
            // Implement setter
            var setter = new MethodDefDeclaration
            {
                Attributes = methodAttributes,
                Name = "set_" + property.Name,
                CallingConvention = CallingConvention.HasThis,
            };
            type.Methods.Add(setter);

            MarkCompilerGenerated(setter, compilerGenerated);
            setter.ReturnParameter = new ParameterDeclaration
            {
                ParameterType = type.Module.Cache.GetIntrinsic(IntrinsicType.Void),
                Attributes = ParameterAttributes.Retval
            };
            setter.Parameters.Add(new ParameterDeclaration(0, "value", property.PropertyType));

            var methodBody = new MethodBodyDeclaration();
            var sequence = methodBody.CreateInstructionSequence();
            var instructionBlock = methodBody.CreateInstructionBlock();
            instructionBlock.AddInstructionSequence(sequence, NodePosition.After, null);
            methodBody.RootInstructionBlock = instructionBlock;
            setter.MethodBody = methodBody;

            var writer = new InstructionWriter();
            writer.AttachInstructionSequence(sequence);
            writer.EmitInstruction(OpCodeNumber.Ldarg_0);
            writer.EmitInstruction(OpCodeNumber.Ldarg_1);
            writer.EmitInstructionField(OpCodeNumber.Stfld, field);
            writer.EmitInstruction(OpCodeNumber.Ret);
            writer.DetachInstructionSequence();

            property.Members.Add(new MethodSemanticDeclaration(MethodSemantics.Setter, setter));
        }
        private static IField CreateBackingField(
            TypeDefDeclaration type,
            string name,
            ITypeSignature fieldType,
            CustomAttributeDeclaration compilerGenerated)
        {
            var field = new FieldDefDeclaration
            {
                Attributes = FieldAttributes.Private,
                Name = string.Format("<{0}>k__BackingField", name),
                FieldType = fieldType
            };

            // Create a backing field
            type.Fields.Add(field);
            MarkCompilerGenerated(field, compilerGenerated);
            return GenericHelper.GetCanonicalGenericInstance(field);
        }
        public static void MarkCompilerGenerated(this IMetadataDeclaration supportsCustomAttributes, CustomAttributeDeclaration compilerGenerated)
        {
            if (compilerGenerated == null)
                return;

            supportsCustomAttributes.CustomAttributes.Add(compilerGenerated);
        }
        public static PropertyDeclaration ImplementPublicProperty(
            this TypeDefDeclaration type,
            string name,
            ITypeSignature propertyType,
            MethodAttributes extraAttributes,
            IEnumerable<CustomAttributeDeclaration> propertyAttributes,
            CustomAttributeDeclaration compilerGenerated)
        {
            var field = CreateBackingField(type, name, propertyType, compilerGenerated);

            var property = CreateProperty(type, name, propertyType, propertyAttributes);

            var methodAttributes = MethodAttributes.Public
                                    | MethodAttributes.HideBySig
                                    | MethodAttributes.SpecialName;

            methodAttributes |= extraAttributes;

            ImplementGetter(property, type, field, methodAttributes, compilerGenerated);
            ImplementSetter(property, type, field, methodAttributes, compilerGenerated);
            return property;
        }
 public static PropertyDeclaration ImplementPublicProperty(
     this TypeDefDeclaration type,
     string name,
     ITypeSignature propertyType,            
     CustomAttributeDeclaration compilerGenerated)
 {
     return ImplementPublicProperty(type, name, propertyType, 0, null, compilerGenerated);
 }
 public ParameterValidationAdvice(CustomAttributeDeclaration declaration, ParameterDeclaration parameterDeclaration, int parameterIndex)
 {
     this.declaration = declaration;
     this.parameterDeclaration = parameterDeclaration;
     this.parameterIndex = parameterIndex;
 }
 public MethodValidationAdvice(CustomAttributeDeclaration attributeDeclaration)
 {
     this.attributeDeclaration = attributeDeclaration;
 }