protected virtual void InitializeAssembly (AssemblyDefinition assembly)
{
MarkAssembly (assembly);
- foreach (TypeDefinition type in assembly.MainModule.Types) {
- if (!Annotations.IsMarked (type))
- continue;
+ foreach (TypeDefinition type in assembly.MainModule.Types)
InitializeType (type);
- }
}
void InitializeType (TypeDefinition type)
{
+ if (type.HasNestedTypes) {
+ foreach (var nested in type.NestedTypes)
+ InitializeType (nested);
+ }
+
+ if (!Annotations.IsMarked (type))
+ return;
+
MarkType (type);
if (type.HasFields)
InitializeFields (type);
if (type.HasMethods)
InitializeMethods (type.Methods);
-
- if (type.HasNestedTypes) {
- foreach (var nested in type.NestedTypes) {
- if (Annotations.IsMarked (nested))
- InitializeType (nested);
- }
- }
}
void InitializeFields (TypeDefinition type)
void ProcessVirtualMethods ()
{
- foreach (MethodDefinition method in _virtual_methods)
+ foreach (MethodDefinition method in _virtual_methods) {
+ Annotations.Push (method);
ProcessVirtualMethod (method);
+ Annotations.Pop ();
+ }
}
void ProcessVirtualMethod (MethodDefinition method)
protected virtual void MarkCustomAttribute (CustomAttribute ca)
{
+ Annotations.Push (ca);
MarkMethod (ca.Constructor);
MarkCustomAttributeArguments (ca);
TypeReference constructor_type = ca.Constructor.DeclaringType;
TypeDefinition type = constructor_type.Resolve ();
- if (type == null)
+ if (type == null) {
+ Annotations.Pop ();
throw new ResolutionException (constructor_type);
+ }
MarkCustomAttributeProperties (ca, type);
MarkCustomAttributeFields (ca, type);
+ Annotations.Pop ();
}
protected void MarkSecurityDeclarations (ISecurityDeclarationProvider provider)
protected void MarkCustomAttributeProperty (CustomAttributeNamedArgument namedArgument, TypeDefinition attribute)
{
PropertyDefinition property = GetProperty (attribute, namedArgument.Name);
+ Annotations.Push (property);
if (property != null)
MarkMethod (property.SetMethod);
MarkIfType (namedArgument.Argument);
+ Annotations.Pop ();
}
PropertyDefinition GetProperty (TypeDefinition type, string propertyname)
return;
MarkType (et);
+ if (argument.Value == null)
+ return;
+
foreach (var cac in (CustomAttributeArgument[]) argument.Value)
MarkWithResolvedScope ((TypeReference) cac.Value);
} else if (at.Namespace == "System" && at.Name == "Type") {
if ((git != null) && git.HasGenericArguments) {
foreach (var ga in git.GenericArguments)
MarkWithResolvedScope (ga);
- return;
}
// we cannot set the Scope of a TypeSpecification but it's element type can be set
// e.g. System.String[] -> System.String
MarkFields (type, type.IsEnum);
if (type.HasInterfaces) {
- foreach (TypeReference iface in type.Interfaces)
- MarkType (iface);
+ foreach (var iface in type.Interfaces)
+ MarkType (iface.InterfaceType);
}
if (type.HasMethods) {
MarkMethodsIf (type.Methods, IsVirtualAndHasPreservedParent);
MarkMethodsIf (type.Methods, IsStaticConstructorPredicate);
+ MarkMethodsIf (type.Methods, HasSerializationAttribute);
}
DoAdditionalTypeProcessing (type);
if (property.Name != property_name)
continue;
+ Annotations.Push (property);
MarkMethod (property.GetMethod);
MarkMethod (property.SetMethod);
+ Annotations.Pop ();
}
}
void MarkMethodsIf (ICollection methods, MethodPredicate predicate)
{
foreach (MethodDefinition method in methods)
- if (predicate (method))
+ if (predicate (method)) {
+ Annotations.Push (predicate);
MarkMethod (method);
+ Annotations.Pop ();
+ }
}
static MethodPredicate IsDefaultConstructorPredicate = new MethodPredicate (IsDefaultConstructor);
return method.IsConstructor && method.IsStatic;
}
+ static bool HasSerializationAttribute (MethodDefinition method)
+ {
+ if (!method.HasCustomAttributes)
+ return false;
+ foreach (var ca in method.CustomAttributes) {
+ var cat = ca.AttributeType;
+ if (cat.Namespace != "System.Runtime.Serialization")
+ continue;
+ switch (cat.Name) {
+ case "OnDeserializedAttribute":
+ case "OnDeserializingAttribute":
+ case "OnSerializedAttribute":
+ case "OnSerializingAttribute":
+ return true;
+ }
+ }
+ return false;
+ }
+
static bool IsSerializable (TypeDefinition td)
{
return (td.Attributes & TypeAttributes.Serializable) != 0;
EnqueueMethod (method);
Annotations.Pop ();
+ Annotations.AddDependency (method);
return method;
}
if (CheckProcessed (method))
return;
+ Annotations.Push (method);
MarkType (method.DeclaringType);
MarkCustomAttributes (method);
MarkSecurityDeclarations (method);
Annotations.Mark (method);
ApplyPreserveMethods (method);
+ Annotations.Pop ();
}
// Allow subclassers to mark additional things when marking a method