public void AddDebuggerBrowsableAttribute(IMutableMember member, DebuggerBrowsableState debuggerBrowsableState)
{
ArgumentUtility.CheckNotNull("member", member);
var attribute = new CustomAttributeDeclaration(s_debuggerBrowsableAttributeConstructor, new object[] { debuggerBrowsableState });
member.AddCustomAttribute(attribute);
}
public void ReplicateAttributes(IAttributableDefinition source, IMutableMember destination)
{
ArgumentUtility.CheckNotNull("source", source);
ArgumentUtility.CheckNotNull("destination", destination);
foreach (var attribute in source.CustomAttributes)
{
AddAttribute(destination, attribute.Data);
}
}
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);
}
private void CheckAttributeInheritanceAllowMultiple(IMutableMember mutableInfo)
{
mutableInfo.AddCustomAttribute(CreateAttribute <InheritableAllowMultipleAttribute> (new object[] { "derived1" }));
mutableInfo.AddCustomAttribute(CreateAttribute <NonInheritableAllowMultipleAttribute> (new object[] { "derived2" }));
var filterType = typeof(AllowMultipleBaseAttribute);
var actualAttributes = (AllowMultipleBaseAttribute[])mutableInfo.GetCustomAttributes(filterType, true);
Assert.That(actualAttributes.Select(a => a.CtorArg), Is.EquivalentTo(new[] { "derived1", "derived2", "base1" }));
}
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 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);
}
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);
}
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);
}
/// <summary>
/// Retrieves the generated <see cref="MemberInfo"/> for the specified <see cref="IMutableMember"/>.
/// </summary>
/// <param name="mutableMember">The mutable member.</param>
/// <returns>The generated member.</returns>
public MemberInfo GetGeneratedMember(IMutableMember mutableMember)
{
ArgumentUtility.CheckNotNull("mutableMember", mutableMember);
MemberInfo generatedMember;
if (_mapping.TryGetValue(mutableMember, out generatedMember))
{
return(generatedMember);
}
BuildMapping(mutableMember.MutableDeclaringType);
return(_mapping[mutableMember]);
}
private void ImplementAttributes(
IMutableMember member, IAttributeIntroductionTarget targetConfiguration, TargetClassDefinition targetClassDefinition)
{
foreach (var attribute in targetConfiguration.CustomAttributes)
{
if (_attributeGenerator.ShouldBeReplicated(attribute, targetConfiguration, targetClassDefinition))
{
_attributeGenerator.AddAttribute(member, attribute.Data);
}
}
foreach (var introducedAttribute in targetConfiguration.ReceivedAttributes)
{
_attributeGenerator.AddAttribute(member, introducedAttribute.Attribute.Data);
}
}
private void BuildMapping(MutableType mutableType)
{
var generatedType = (Type)_mapping[mutableType];
var generatedMembers = generatedType.GetMembers(c_allDeclared);
var generatedMembersByNameAndSig = generatedMembers.ToDictionary(m => Tuple.Create(m.Name, MemberSignatureProvider.GetMemberSignature(m)));
var addedMembers =
new IMutableMember[] { mutableType.MutableTypeInitializer }.Where(m => m != null)
.Concat(mutableType.AddedNestedTypes.Cast <IMutableMember>())
.Concat(mutableType.AddedFields.Cast <IMutableMember>())
.Concat(mutableType.AddedConstructors.Cast <IMutableMember>())
.Concat(mutableType.AddedMethods.Cast <IMutableMember>())
.Concat(mutableType.AddedProperties.Cast <IMutableMember>())
.Concat(mutableType.AddedEvents.Cast <IMutableMember>());
foreach (var addedMember in addedMembers)
{
var member = (MemberInfo)addedMember;
var nameAndSig = Tuple.Create(member.Name, MemberSignatureProvider.GetMemberSignature(member));
var generatedMember = generatedMembersByNameAndSig[nameAndSig];
_mapping.Add(addedMember, generatedMember);
}
}
