linux-packaging-mono-tools/gui-compare/MasterMetadata.cs

//
// MasterMetadata.cs
//
// (C) 2007 - 2008 Novell, Inc. (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.Collections.Generic;
using System.Text;

namespace GuiCompare {

	static class MasterUtils {
		public static void PopulateMethodList (XMLMethods methods, List<CompNamed> method_list)
		{
			foreach (object key in methods.keys.Keys) {
				XMLMethods.SignatureFlags signatureFlags = (methods.signatureFlags != null &&
				                                            methods.signatureFlags.ContainsKey (key) ?
				                                            (XMLMethods.SignatureFlags) methods.signatureFlags [key] :
				                                            XMLMethods.SignatureFlags.None);

				XMLParameters parameters = (methods.parameters == null ? null
				                            : (XMLParameters)methods.parameters[key]);
				XMLGenericParameters genericParameters = (methods.genericParameters == null ? null
				                                                  : (XMLGenericParameters)methods.genericParameters[key]);
				XMLAttributes attributes = (methods.attributeMap == null ? null
				                            : (XMLAttributes)methods.attributeMap[key]);
				string returnType = (methods.returnTypes == null ? null
				                     : (string)methods.returnTypes[key]);
				method_list.Add (new MasterMethod ((string)methods.keys[key],
				                                   signatureFlags,
				                                   returnType,
				                                   parameters,
				                                   genericParameters,
				                                   methods.ConvertToString (Int32.Parse ((string)methods.access[key])),
				                                   attributes));
			}
		}
		                                       
		public static void PopulateMemberLists (XMLClass xml_cls,
		                                        List<CompNamed> interface_list,
		                                        List<CompNamed> constructor_list,
		                                        List<CompNamed> method_list,
		                                        List<CompNamed> property_list,
		                                        List<CompNamed> field_list,
		                                        List<CompNamed> event_list)
		{
			if (interface_list != null && xml_cls.interfaces != null) {
				foreach (object i in xml_cls.interfaces.keys.Keys) {
					interface_list.Add (new MasterInterface ((string)xml_cls.interfaces.keys[i]));
				}
			}
			
			if (constructor_list != null && xml_cls.constructors != null) {
				PopulateMethodList (xml_cls.constructors, constructor_list);
			}
			
			if (method_list != null && xml_cls.methods != null) {
				PopulateMethodList (xml_cls.methods, method_list);
			}
			
			if (property_list != null && xml_cls.properties != null) {
				foreach (object key in xml_cls.properties.keys.Keys) {
					XMLAttributes attributes = (xml_cls.properties.attributeMap == null ? null
					                            : (XMLAttributes)xml_cls.properties.attributeMap[key]);

					property_list.Add (new MasterProperty ((string)key,
					                                       xml_cls.properties.ConvertToString (Int32.Parse ((string)xml_cls.properties.access[key])),
					                                       (XMLMethods)xml_cls.properties.nameToMethod[key],
					                                       attributes));
				}
			}
			
			if (field_list != null && xml_cls.fields != null) {
				foreach (object key in xml_cls.fields.keys.Keys) {
					string type = (xml_cls.fields.fieldTypes == null || !xml_cls.fields.fieldTypes.ContainsKey(key)) ? null : (string)xml_cls.fields.fieldTypes[key];
					string fvalue = (xml_cls.fields.fieldValues == null || !xml_cls.fields.fieldValues.ContainsKey(key)) ? null : (string)xml_cls.fields.fieldValues[key];
					XMLAttributes attributes = (xml_cls.fields.attributeMap == null ? null
					                            : (XMLAttributes)xml_cls.fields.attributeMap[key]);

					field_list.Add (new MasterField ((string)xml_cls.fields.keys[key],
					                                 type, fvalue,
					                                 xml_cls.fields.ConvertToString(Int32.Parse ((string)xml_cls.fields.access[key])),
					                                 attributes));
				}
			}
			
			if (event_list != null && xml_cls.events != null) {
				foreach (object key in xml_cls.events.keys.Keys) {
					XMLAttributes attributes = (xml_cls.events.attributeMap == null ? null
					                            : (XMLAttributes)xml_cls.events.attributeMap[key]);
					event_list.Add (new MasterEvent ((string)xml_cls.events.keys[key],
					                                 (string)xml_cls.events.eventTypes[key],
					                                 xml_cls.events.ConvertToString (Int32.Parse ((string)xml_cls.events.access[key])),
					                                 attributes));
				}
			}
		}
		

		public static void PopulateTypeLists (XMLClass fromDef,
		                                      List<CompNamed> class_list,
		                                      List<CompNamed> enum_list,
		                                      List<CompNamed> delegate_list,
		                                      List<CompNamed> interface_list,
		                                      List<CompNamed> struct_list)
		{
			if (fromDef.nested == null)
				return;
			
			foreach (XMLClass cls in fromDef.nested) {
				if (cls.type == "class")
					class_list.Add (new MasterClass (cls, CompType.Class));
				else if (cls.type == "enum")
					enum_list.Add (new MasterEnum (cls));
				else if (cls.type == "delegate")
					delegate_list.Add (new MasterDelegate (cls));
				else if (cls.type == "interface")
					interface_list.Add (new MasterInterface (cls));
				else if (cls.type == "struct")
					struct_list.Add (new MasterClass (cls, CompType.Struct));
			}
		}
		
		public static bool IsImplementationSpecificAttribute (string name)
		{
			if (name.IndexOf (';') > 0) {
				if (name.StartsWith ("System.Runtime.CompilerServices.InternalsVisibleToAttribute"))
					return true;
			}
		
			switch (name) {
				case "System.Diagnostics.CodeAnalysis.SuppressMessageAttribute":
				case "System.NonSerializedAttribute":
				case "System.Runtime.CompilerServices.CompilerGeneratedAttribute":
				case "System.Security.SecuritySafeCriticalAttribute":
				case "System.Security.SecurityCriticalAttribute":
				case "System.Diagnostics.DebuggerHiddenAttribute":
				case "System.Diagnostics.DebuggerStepThroughAttribute":
				case "System.Runtime.CompilerServices.InternalsVisibleToAttribute":
				case "System.Runtime.TargetedPatchingOptOutAttribute":
				case "System.Runtime.InteropServices.ComVisibleAttribute":
				case "System.Runtime.AssemblyTargetedPatchBandAttribute":
				case "System.Diagnostics.DebuggableAttribute":
				return true;
			}
				
			return false;
		}
		
		public static List<CompNamed> GetAttributes (XMLAttributes attributes)
		{
			List<CompNamed> rv = new List<CompNamed>();
			if (attributes != null) {
				XMLAttributeProperties properties;
				
				foreach (string key in attributes.keys.Keys) {
					if (IsImplementationSpecificAttribute (key))
						continue;

					if (!attributes.Properties.TryGetValue (key, out properties))
						properties = null;
					rv.Add (new MasterAttribute ((string)attributes.keys[key], properties));
				}
			}
			return rv;
		}

		public static List<CompGenericParameter> GetTypeParameters (XMLGenericParameters gparams)
		{
			if (gparams == null)
				return null;

			var list = new List<CompGenericParameter> ();
			foreach (string key in gparams.keys.Keys) {
				XMLAttributes attributes = gparams.attributeMap == null ?
					null : (XMLAttributes) gparams.attributeMap [key];
					
				var constraints = gparams.constraints [key];
				
				list.Add (new MasterGenericTypeParameter (key, constraints, attributes));
			}
			
			return list;
		}
		
		public static List<CompParameter> GetParameters (XMLParameters parameters)
		{
			var list = new List<CompParameter> ();
			foreach (XMLParameter key in parameters.keys.Values) {
				list.Add (new MasterParameter (key.Name, key.type, key.isOptional, key.attributes));
			}
			
			return list;
		}		
	}
	
	public class MasterAssembly : CompAssembly {
		public MasterAssembly (string path)
			: base (path)
		{
			masterinfo = XMLAssembly.CreateFromFile (path);
			if (masterinfo == null)
				throw new ArgumentException ("Error loading masterinfo from " + path);
			attributes = MasterUtils.GetAttributes (masterinfo.attributes);
		}

		public override List<CompNamed> GetNamespaces ()
		{
			List<CompNamed> namespaces = new List<CompNamed>();
			if (masterinfo != null && masterinfo.namespaces != null) {
				foreach (XMLNamespace ns in masterinfo.namespaces)
					namespaces.Add (new MasterNamespace (ns));
			}

			return namespaces;
		}

		public override List<CompNamed> GetAttributes ()
		{
			return attributes;
		}

		XMLAssembly masterinfo;
		List<CompNamed> attributes;
	}

	public class MasterNamespace : CompNamespace {
		public MasterNamespace (XMLNamespace ns)
			: base (ns.name)
		{
			this.ns = ns;

			delegate_list = new List<CompNamed>();
			enum_list = new List<CompNamed>();
			class_list = new List<CompNamed>();
			struct_list = new List<CompNamed>();
			interface_list = new List<CompNamed>();

			foreach (XMLClass cls in ns.types) {
				if (cls.type == "class")
					class_list.Add (new MasterClass (cls, CompType.Class));
				else if (cls.type == "enum")
					enum_list.Add (new MasterEnum (cls));
				else if (cls.type == "delegate")
					delegate_list.Add (new MasterDelegate (cls));
				else if (cls.type == "interface")
					interface_list.Add (new MasterInterface (cls));
				else if (cls.type == "struct")
					struct_list.Add (new MasterClass (cls, CompType.Struct));
			}
		}

		public override List<CompNamed> GetNestedClasses ()
		{
			return class_list;
		}

		public override List<CompNamed> GetNestedInterfaces ()
		{
			return interface_list;
		}

		public override List<CompNamed> GetNestedStructs ()
		{
			return struct_list;
		}

		public override List<CompNamed> GetNestedEnums ()
		{
			return enum_list;
		}

		public override List<CompNamed> GetNestedDelegates ()
		{
			return delegate_list;
		}

		XMLNamespace ns;
		List<CompNamed> delegate_list;
		List<CompNamed> enum_list;
		List<CompNamed> class_list;
		List<CompNamed> struct_list;
		List<CompNamed> interface_list;
	}

	public class MasterInterface : CompInterface {
		public MasterInterface (XMLClass xml_cls)
			: base (FormatName (xml_cls))
		{
			this.xml_cls = xml_cls;
			
			interfaces = new List<CompNamed>();
			constructors = new List<CompNamed>();
			methods = new List<CompNamed>();
			properties = new List<CompNamed>();
			fields = new List<CompNamed>();
			events = new List<CompNamed>();
			
			MasterUtils.PopulateMemberLists (xml_cls,
			                                 interfaces,
			                                 constructors,
			                                 methods,
			                                 properties,
			                                 fields,
			                                 events);
			
			attributes = MasterUtils.GetAttributes (xml_cls.attributes);
		}
		
		public MasterInterface (string name)
			: base (name)
		{
			interfaces = new List<CompNamed>();
			constructors = new List<CompNamed>();
			methods = new List<CompNamed>();
			properties = new List<CompNamed>();
			fields = new List<CompNamed>();
			events = new List<CompNamed>();
			attributes = new List<CompNamed>();
		}
		
		static string FormatName (XMLClass iface)
		{
			string name = iface.name;
			return name;
		}

		public override string GetBaseType()
		{
			return xml_cls == null ? null : xml_cls.baseName;
		}
		
		public override List<CompNamed> GetInterfaces ()
		{
			return interfaces;
		}

		public override List<CompNamed> GetMethods ()
		{
			return methods;
		}

		public override List<CompNamed> GetConstructors ()
		{
			return constructors;
		}

 		public override List<CompNamed> GetProperties()
		{
			return properties;
		}

 		public override List<CompNamed> GetFields()
		{
			return fields;
		}

 		public override List<CompNamed> GetEvents()
		{
			return events;
		}

		public override List<CompNamed> GetAttributes ()
		{
			return attributes;
		}
		
		public override List<CompGenericParameter> GetTypeParameters ()
		{
			return xml_cls.GetTypeParameters ();
		}
		
		XMLClass xml_cls;
		List<CompNamed> interfaces;
		List<CompNamed> constructors;
		List<CompNamed> methods;
		List<CompNamed> properties;
		List<CompNamed> fields;
		List<CompNamed> events;
		List<CompNamed> attributes;
	}

	public class MasterDelegate : CompDelegate {
		public MasterDelegate (XMLClass cls)
			: base (cls.name)
		{
			xml_cls = cls;
		}
		
		public override List<CompNamed> GetAttributes ()
		{
			return MasterUtils.GetAttributes (xml_cls.attributes);
		}
		
		public override List<CompNamed> GetConstructors ()
		{
			List<CompNamed> ctor_list = new List<CompNamed> ();
			MasterUtils.PopulateMethodList (xml_cls.constructors, ctor_list);
			return ctor_list;
		}
		
		public override List<CompNamed> GetMethods ()
		{
			List<CompNamed> method_list = new List<CompNamed> ();
			MasterUtils.PopulateMethodList (xml_cls.methods, method_list);
			return method_list;
		}

		public override string GetBaseType ()
		{
			return xml_cls.baseName;
		}
		
		public override List<CompGenericParameter> GetTypeParameters ()
		{
			return xml_cls.GetTypeParameters ();
		}
		
		XMLClass xml_cls;
	}

	public class MasterEnum : CompEnum {
		public MasterEnum (XMLClass cls)
			: base (cls.name)
		{
			xml_cls = cls;
			
			fields = new List<CompNamed>();

			MasterUtils.PopulateMemberLists (xml_cls,
			                                 null,
			                                 null,
			                                 null,
			                                 null,
			                                 fields,
			                                 null);

			if (fields == null || fields.Count == 0)
				return;

			List <MasterField> masterFields = new List<MasterField> ();
			foreach (CompNamed f in fields) {
				MasterField field = f as MasterField;
				if (field == null)
					continue;

				masterFields.Add (field);
			}

			if (masterFields.Count == 0)
				return;

			masterFields.Sort ((MasterField left, MasterField right) => {
				if (left == null && right == null)
					return 0;

				if (left == null)
					return 1;

				if (right == null)
					return -1;

				return String.Compare (left.GetLiteralValue (), right.GetLiteralValue (), StringComparison.Ordinal);
			});

			StringBuilder sb = new StringBuilder ();
			sb.Append ("<b>Members:</b>\n");
			foreach(MasterField field in masterFields)
				sb.AppendFormat ("\t\t<i>{0}</i> = {1}\n", field.Name, field.GetLiteralValue ());
			ExtraInfo = sb.ToString ();
		}

		public override string GetBaseType()
		{
			return xml_cls.baseName;
		}
		
 		public override List<CompNamed> GetFields()
		{
			return fields;
		}

		public override List<CompNamed> GetAttributes ()
		{
			return MasterUtils.GetAttributes (xml_cls.attributes);
		}

		List<CompNamed> fields;
		XMLClass xml_cls;
	}

	public class MasterClass : CompClass {
		public MasterClass (XMLClass cls, CompType type)
			: base (cls.name, type)
		{
			xml_cls = cls;

			interfaces = new List<CompNamed>();
			constructors = new List<CompNamed>();
			methods = new List<CompNamed>();
			properties = new List<CompNamed>();
			fields = new List<CompNamed>();
			events = new List<CompNamed>();

			MasterUtils.PopulateMemberLists (xml_cls,
			                                 interfaces,
			                                 constructors,
			                                 methods,
			                                 properties,
			                                 fields,
			                                 events);
			
			delegate_list = new List<CompNamed>();
			enum_list = new List<CompNamed>();
			class_list = new List<CompNamed>();
			struct_list = new List<CompNamed>();
			interface_list = new List<CompNamed>();

			MasterUtils.PopulateTypeLists (xml_cls,
			                               class_list,
			                               enum_list,
			                               delegate_list,
			                               interface_list,
			                               struct_list);
		}

		public override string GetBaseType ()
		{
			return xml_cls.baseName;
		}
		
		public override bool IsSealed { get { return xml_cls.isSealed; } }
		public override bool IsAbstract { get { return xml_cls.isAbstract; } }		
		
		public override List<CompNamed> GetInterfaces ()
		{
			return interfaces;
		}

		public override List<CompNamed> GetMethods()
		{
			return methods;
		}

		public override List<CompNamed> GetConstructors()
		{
			return constructors;
		}

 		public override List<CompNamed> GetProperties()
		{
			return properties;
		}

 		public override List<CompNamed> GetFields()
		{
			return fields;
		}

 		public override List<CompNamed> GetEvents()
		{
			return events;
		}

		public override List<CompNamed> GetAttributes ()
		{
			return MasterUtils.GetAttributes (xml_cls.attributes);
		}

		public override List<CompNamed> GetNestedClasses()
		{
			return class_list;
		}

		public override List<CompNamed> GetNestedInterfaces ()
		{
			return interface_list;
		}

		public override List<CompNamed> GetNestedStructs ()
		{
			return struct_list;
		}

		public override List<CompNamed> GetNestedEnums ()
		{
			return enum_list;
		}

		public override List<CompNamed> GetNestedDelegates ()
		{
			return delegate_list;
		}
		
		public override List<CompGenericParameter> GetTypeParameters ()
		{
			return xml_cls.GetTypeParameters ();
		}

		XMLClass xml_cls;

		List<CompNamed> interfaces;
		List<CompNamed> constructors;
		List<CompNamed> methods;
		List<CompNamed> properties;
		List<CompNamed> fields;
		List<CompNamed> events;
		
		List<CompNamed> delegate_list;
		List<CompNamed> enum_list;
		List<CompNamed> class_list;
		List<CompNamed> struct_list;
		List<CompNamed> interface_list;
}

	public class MasterEvent : CompEvent {
		public MasterEvent (string name,
		                    string eventType,
		                    string eventAccess,
		                    XMLAttributes attributes)
			: base (name)
		{
			this.eventType = eventType;
			this.eventAccess = eventAccess;
			this.attributes = attributes;
		}

		public override string GetMemberType ()
		{
			return eventType;
		}

		public override string GetMemberAccess ()
		{
			return eventAccess;
		}
		
		public override List<CompNamed> GetAttributes ()
		{
			return MasterUtils.GetAttributes (attributes);
		}
		
		string eventType;
		string eventAccess;
		XMLAttributes attributes;
	}
	

	public class MasterField : CompField {
		public MasterField (string name,
		                    string fieldType,
		                    string fieldValue,
		                    string fieldAccess,
		                    XMLAttributes attributes)
			: base (name)
		{
			this.fieldType = fieldType;
			this.fieldValue = fieldValue;
			// we don't care about the Assembly (internal) part
			this.fieldAccess = fieldAccess.Replace ("FamORAssem", "Family");
			this.attributes = attributes;
		}

		public override string GetMemberType ()
		{
			return fieldType;
		}
		
		public override string GetMemberAccess ()
		{
			return fieldAccess;
		}
		
		public override List<CompNamed> GetAttributes ()
		{
			return MasterUtils.GetAttributes (attributes);
		}
		
		public override string GetLiteralValue ()
		{
			return fieldValue;
		}

		string fieldType;
		string fieldValue;
		string fieldAccess;
		XMLAttributes attributes;
	}
	
	public class MasterProperty : CompProperty {
		public MasterProperty (string key, string propertyAccess, XMLMethods xml_methods, XMLAttributes attributes)
			: base (FormatName (key))
		{
			string[] keyparts = key.Split(new char[] {':'}, 3);
			
			this.propertyType = keyparts[1];
			this.propertyAccess = propertyAccess;
			
			methods = new List<CompNamed>();			
			
			MasterUtils.PopulateMethodList (xml_methods, methods);
			this.attributes = attributes;
		}

		public override List<CompNamed> GetAttributes ()
		{
			return MasterUtils.GetAttributes (attributes);
		}
		
		public override string GetMemberType()
		{
			return propertyType;
		}
		
		public override string GetMemberAccess()
		{
			return propertyAccess;
		}
		
		public override List<CompNamed> GetMethods()
		{
			return methods;
		}

		static string FormatName (string key)
		{
			string[] keyparts = key.Split(new char[] {':'}, 3);

			StringBuilder sb = new StringBuilder ();
			sb.Append (keyparts[1]);
			sb.Append (" ");
			sb.Append (keyparts[0]);

			if (keyparts[2] != "")
				sb.AppendFormat ("[{0}]", keyparts[2]);

			return sb.ToString ();
		}
	
		List<CompNamed> methods;
		XMLAttributes attributes;
		string propertyType;
		string propertyAccess;
	}
	
	public class MasterMethod : CompMethod {
		public MasterMethod (string name,
		                     XMLMethods.SignatureFlags signatureFlags,
		                     string returnType,
		                     XMLParameters parameters,
		                     XMLGenericParameters genericParameters,
		                     string methodAccess,
		                     XMLAttributes attributes)
			: base (String.Format ("{0} {1}", returnType, name))
		{
			this.signatureFlags = signatureFlags;
			this.returnType = returnType;
			this.parameters = parameters;
			this.genericParameters = genericParameters;
			// we don't care about the Assembly (internal) part
			this.methodAccess = methodAccess.Replace ("FamORAssem", "Family");
			this.attributes = attributes;
		}

		public override string GetMemberType()
		{
			return returnType;
		}

		public override bool ThrowsNotImplementedException ()
		{
			return false;
		}
		
		public override string GetMemberAccess()
		{
			return methodAccess;
		}
		
		public override List<CompNamed> GetAttributes ()
		{
			return MasterUtils.GetAttributes (attributes);
		}
		
		public override List<CompGenericParameter> GetTypeParameters ()
		{
			return MasterUtils.GetTypeParameters (genericParameters);
		}
		
		public override List<CompParameter> GetParameters ()
		{
			return MasterUtils.GetParameters (parameters);
		}

		XMLMethods.SignatureFlags signatureFlags;
		string returnType;
		XMLParameters parameters;
		XMLGenericParameters genericParameters;
		string methodAccess;
		XMLAttributes attributes;
	}
			         
	public class MasterAttribute : CompAttribute
	{
		string FormatStringValue (string value)
		{
			if (value == null)
				return "null";

			return "\"" + value + "\"";
		}

		public MasterAttribute (string name, XMLAttributeProperties properties) : base(name)
		{
			var sb = new StringBuilder ();

			if (properties == null)
				return;

			IDictionary<string, string> props = properties.Properties;
			if (props.Count == 0)
				return;

			foreach (var entry in props)
				Properties.Add (entry.Key, entry.Value);

			if (name == "System.Runtime.CompilerServices.TypeForwardedToAttribute") {
				string dest;
				if (props.TryGetValue ("Destination", out dest) && !String.IsNullOrEmpty (dest))
					sb.AppendFormat ("[assembly: TypeForwardedToAttribute (typeof ({0}))]", dest);
			} else {
				sb.Append ("<b>Properties:</b>\n");
				foreach (var prop in props)
					sb.AppendFormat ("\t\t<i>{0}</i> == {1}\n", prop.Key, FormatStringValue (prop.Value));
				sb.Append ('\n');
			}

			ExtraInfo = sb.ToString ();
		}
	}
	
	public class MasterParameter : CompParameter
	{
		XMLAttributes attributes;		
		
		public MasterParameter (string name, string type, bool optional, XMLAttributes attributes)
			: base (name, type, optional)
		{
			this.attributes = attributes;
		}
		
		public override List<CompNamed> GetAttributes ()
		{
			return MasterUtils.GetAttributes (attributes);
		}
	}
	
	public class MasterGenericTypeParameter : CompGenericParameter {
		XMLGenericParameterConstraints constraints;
		XMLAttributes attributes;
		
		public MasterGenericTypeParameter (string name, XMLGenericParameterConstraints constraints, XMLAttributes attributes)
			: base (name, (Mono.Cecil.GenericParameterAttributes)Enum.Parse (typeof (Mono.Cecil.GenericParameterAttributes), constraints.attributes))
		{
			this.constraints = constraints;
			this.attributes = attributes;
		}
		
		public override bool HasConstraints {
			get {
				return constraints.keys != null;
			}
		}
		
		public override List<CompNamed> GetAttributes ()
		{
			return MasterUtils.GetAttributes (attributes);
		}
	}
}