Implemented CecilLoader.ReadEvent

ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj

@@ -164,6 +164,7 @@
     <Compile Include="TypeSystem\Implementation\AbstractTypeReference.cs" />
     <Compile Include="TypeSystem\Implementation\BitVector16.cs" />
     <Compile Include="TypeSystem\Implementation\DefaultAttribute.cs" />
+    <Compile Include="TypeSystem\Implementation\DefaultEvent.cs" />
     <Compile Include="TypeSystem\Implementation\DefaultExplicitInterfaceImplementation.cs" />
     <Compile Include="TypeSystem\Implementation\DefaultMethod.cs" />
     <Compile Include="TypeSystem\Implementation\DefaultParameter.cs" />

ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs

@@ -755,7 +755,30 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		#region Read Event
 		public IEvent ReadEvent(EventDefinition ev, ITypeDefinition parentType)
 		{
-			throw new NotImplementedException();
+			if (ev == null)
+				throw new ArgumentNullException("ev");
+			if (parentType == null)
+				throw new ArgumentNullException("parentType");
+			
+			DefaultEvent e = new DefaultEvent(parentType, ev.Name);
+			TranslateModifiers(ev.AddMethod, e);
+			e.ReturnType = ReadTypeReference(ev.EventType, typeAttributes: ev, entity: e);
+			
+			e.CanAdd = ev.AddMethod != null && IsVisible(ev.AddMethod.Attributes);
+			e.CanRemove = ev.RemoveMethod != null && IsVisible(ev.RemoveMethod.Attributes);
+			e.CanInvoke = ev.InvokeMethod != null && IsVisible(ev.InvokeMethod.Attributes);
+			
+			if (e.CanAdd)
+				e.AddAccessibility = GetAccessibility(ev.AddMethod.Attributes);
+			if (e.CanRemove)
+				e.RemoveAccessibility = GetAccessibility(ev.RemoveMethod.Attributes);
+			if (e.CanInvoke)
+				e.InvokeAccessibility = GetAccessibility(ev.InvokeMethod.Attributes);
+			
+			if (ev.HasCustomAttributes)
+				AddAttributes(ev, e.Attributes);
+			
+			return e;
 		}
 		#endregion
 	}

ICSharpCode.NRefactory/TypeSystem/IEvent.cs

@@ -6,38 +6,14 @@ using System.Diagnostics.Contracts;
 
 namespace ICSharpCode.NRefactory.TypeSystem
 {
-	[ContractClass(typeof(IEventContract))]
 	public interface IEvent : IMember
 	{
-		/// <summary>
-		/// Gets the add method.
-		/// </summary>
-		IMethod AddMethod { get; }
+		bool CanAdd { get; }
+		bool CanRemove { get; }
+		bool CanInvoke { get; }
 		
-		/// <summary>
-		/// Gets the remove method.
-		/// </summary>
-		IMethod RemoveMethod { get; }
-		
-		/// <summary>
-		/// Gets the raise method.
-		/// </summary>
-		IMethod RaiseMethod { get; }
-	}
-	
-	[ContractClassFor(typeof(IEvent))]
-	abstract class IEventContract : IMemberContract, IEvent
-	{
-		IMethod IEvent.AddMethod {
-			get { return null; }
-		}
-		
-		IMethod IEvent.RemoveMethod {
-			get { return null; }
-		}
-		
-		IMethod IEvent.RaiseMethod {
-			get { return null; }
-		}
+		Accessibility AddAccessibility { get; }
+		Accessibility RemoveAccessibility { get; }
+		Accessibility InvokeAccessibility { get; }
 	}
 }

ICSharpCode.NRefactory/TypeSystem/IProperty.cs

@@ -16,9 +16,6 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		Accessibility GetterAccessibility { get; }
 		Accessibility SetterAccessibility { get; }
 		
-		//IMethod GetMethod { get; }
-		//IMethod SetMethod { get; }
-		
 		bool IsIndexer { get; }
 	}
 }

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultEvent.cs

@@ -0,0 +1,72 @@
+
+using System;
+
+namespace ICSharpCode.NRefactory.TypeSystem.Implementation
+{
+	/// <summary>
+	/// Default implementation of <see cref="IEvent"/>.
+	/// </summary>
+	public class DefaultEvent : AbstractMember, IEvent
+	{
+		Accessibility addAccessibility;
+		Accessibility removeAccessibility;
+		Accessibility invokeAccessibility;
+		
+		const ushort FlagCanAdd    = 0x1000;
+		const ushort FlagCanRemove = 0x2000;
+		const ushort FlagCanInvoke  = 0x4000;
+		
+		public DefaultEvent(ITypeDefinition declaringTypeDefinition, string name)
+			: base(declaringTypeDefinition, name, EntityType.Event)
+		{
+		}
+		
+		public bool CanAdd {
+			get { return flags[FlagCanAdd]; }
+			set {
+				CheckBeforeMutation();
+				flags[FlagCanAdd] = value;
+			}
+		}
+		
+		public bool CanRemove {
+			get { return flags[FlagCanRemove]; }
+			set {
+				CheckBeforeMutation();
+				flags[FlagCanRemove] = value;
+			}
+		}
+		
+		public bool CanInvoke {
+			get { return flags[FlagCanInvoke]; }
+			set {
+				CheckBeforeMutation();
+				flags[FlagCanInvoke] = value;
+			}
+		}
+		
+		public Accessibility AddAccessibility {
+			get { return addAccessibility; }
+			set {
+				CheckBeforeMutation();
+				addAccessibility = value;
+			}
+		}
+		
+		public Accessibility RemoveAccessibility {
+			get { return removeAccessibility; }
+			set {
+				CheckBeforeMutation();
+				removeAccessibility = value;
+			}
+		}
+		
+		public Accessibility InvokeAccessibility {
+			get { return invokeAccessibility; }
+			set {
+				CheckBeforeMutation();
+				invokeAccessibility = value;
+			}
+		}
+	}
+}