TypeSystemConvertVisitor: add support for properties and events.

ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs

@@ -168,8 +168,8 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Assert.IsTrue(p.CanGet);
 			Assert.IsTrue(p.CanSet);
 			Assert.AreEqual(Accessibility.Public, p.Accessibility);
-			Assert.AreEqual(Accessibility.Public, p.GetterAccessibility);
-			Assert.AreEqual(Accessibility.Protected, p.SetterAccessibility);
+			Assert.AreEqual(Accessibility.Public, p.Getter.Accessibility);
+			Assert.AreEqual(Accessibility.Protected, p.Setter.Accessibility);
 		}
 		
 		[Test]
@@ -180,8 +180,8 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Assert.IsTrue(p.CanGet);
 			Assert.IsTrue(p.CanSet);
 			Assert.AreEqual(Accessibility.Public, p.Accessibility);
-			Assert.AreEqual(Accessibility.Public, p.GetterAccessibility);
-			Assert.AreEqual(Accessibility.Private, p.SetterAccessibility);
+			Assert.AreEqual(Accessibility.Public, p.Getter.Accessibility);
+			Assert.AreEqual(Accessibility.Private, p.Setter.Accessibility);
 		}
 		
 		[Test]
@@ -191,9 +191,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			IProperty p = testClass.Properties.Single(pr => pr.IsIndexer);
 			Assert.IsTrue(p.CanGet);
 			Assert.AreEqual(Accessibility.Public, p.Accessibility);
-			Assert.AreEqual(Accessibility.Public, p.GetterAccessibility);
+			Assert.AreEqual(Accessibility.Public, p.Getter.Accessibility);
 			Assert.IsFalse(p.CanSet);
-			Assert.AreEqual(Accessibility.None, p.SetterAccessibility);
+			Assert.AreEqual(Accessibility.None, p.Setter.Accessibility);
 		}
 		
 		[Test]

ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/OperatorDeclaration.cs

@@ -29,6 +29,8 @@ using System;
 namespace ICSharpCode.NRefactory.CSharp
 {
 	public enum OperatorType {
+		// Numeric values must match those in Mono.CSharp.Operator.OpType !!
+		
 		// Unary operators
 		LogicalNot,
 		OnesComplement,
@@ -87,5 +89,10 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			return visitor.VisitOperatorDeclaration (this, data);
 		}
+		
+		public static string GetName(OperatorType type) 
+		{
+			return Mono.CSharp.Operator.GetMetadataName((Mono.CSharp.Operator.OpType)type);
+		}
 	}
 }

ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/PropertyDeclaration.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // PropertyDeclaration.cs
 //  
 // Author:
@@ -30,7 +30,7 @@ using ICSharpCode.NRefactory.TypeSystem;
 namespace ICSharpCode.NRefactory.CSharp
 {
 	
-	public class Accessor : AbstractMember
+	public class Accessor : AbstractMemberBase
 	{
 		public DomLocation Location {
 			get;

ICSharpCode.NRefactory/CSharp/Parser/TypeSystemConvertVisitor.cs

@@ -280,7 +280,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		#region Operators
 		public override IEntity VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data)
 		{
-			DefaultMethod m = new DefaultMethod(currentTypeDefinition, operatorDeclaration.Name);
+			DefaultMethod m = new DefaultMethod(currentTypeDefinition, OperatorDeclaration.GetName(operatorDeclaration.OperatorType));
 			m.EntityType = EntityType.Operator;
 			m.Region = MakeRegion(operatorDeclaration);
 			m.BodyRegion = MakeRegion(operatorDeclaration.Body);
@@ -346,6 +346,73 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		#endregion
 		
+		#region Properties / Indexers
+		public override IEntity VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
+		{
+			DefaultProperty p = new DefaultProperty(currentTypeDefinition, propertyDeclaration.Name);
+			HandlePropertyOrIndexer(p, propertyDeclaration);
+			currentTypeDefinition.Properties.Add(p);
+			return p;
+		}
+		
+		void HandlePropertyOrIndexer(DefaultProperty p, PropertyDeclaration propertyDeclaration)
+		{
+			p.Region = MakeRegion(propertyDeclaration);
+			p.BodyRegion = MakeRegion(propertyDeclaration.LBrace.StartLocation, propertyDeclaration.RBrace.EndLocation);
+			ApplyModifiers(p, propertyDeclaration.Modifiers);
+			p.ReturnType = ConvertType(propertyDeclaration.ReturnType);
+			ConvertAttributes(p.Attributes, propertyDeclaration.Attributes);
+			if (propertyDeclaration.PrivateImplementationType != null) {
+				p.Accessibility = Accessibility.None;
+				p.InterfaceImplementations.Add(ConvertInterfaceImplementation(propertyDeclaration.PrivateImplementationType, p.Name));
+			}
+			p.Getter = ConvertAccessor(propertyDeclaration.GetAccessor, p.Accessibility);
+			p.Setter = ConvertAccessor(propertyDeclaration.SetAccessor, p.Accessibility);
+		}
+		
+		public override IEntity VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
+		{
+			DefaultProperty p = new DefaultProperty(currentTypeDefinition, "Items");
+			p.EntityType = EntityType.Indexer;
+			HandlePropertyOrIndexer(p, indexerDeclaration);
+			ConvertParameters(p.Parameters, indexerDeclaration.Parameters);
+			currentTypeDefinition.Properties.Add(p);
+			return p;
+		}
+		
+		IAccessor ConvertAccessor(Accessor accessor, Accessibility defaultAccessibility)
+		{
+			DefaultAccessor a = new DefaultAccessor();
+			a.Accessibility = GetAccessibility(accessor.Modifiers) ?? defaultAccessibility;
+			a.Region = MakeRegion(accessor);
+			ConvertAttributes(a.Attributes, accessor.Attributes);
+			return a;
+		}
+		#endregion
+		
+		#region Events
+		public override IEntity VisitEventDeclaration(EventDeclaration eventDeclaration, object data)
+		{
+			DefaultEvent e = new DefaultEvent(currentTypeDefinition, eventDeclaration.Name);
+			e.Region = MakeRegion(eventDeclaration);
+			e.BodyRegion = MakeRegion(eventDeclaration.LBrace.StartLocation, eventDeclaration.RBrace.EndLocation);
+			ApplyModifiers(e, eventDeclaration.Modifiers);
+			e.ReturnType = ConvertType(eventDeclaration.ReturnType);
+			ConvertAttributes(e.Attributes, eventDeclaration.Attributes);
+			
+			if (eventDeclaration.PrivateImplementationType != null) {
+				e.Accessibility = Accessibility.None;
+				e.InterfaceImplementations.Add(ConvertInterfaceImplementation(eventDeclaration.PrivateImplementationType, e.Name));
+			}
+			
+			e.AddAccessor = ConvertAccessor(eventDeclaration.AddAccessor, e.Accessibility);
+			e.RemoveAccessor = ConvertAccessor(eventDeclaration.RemoveAccessor, e.Accessibility);
+			
+			currentTypeDefinition.Events.Add(e);
+			return e;
+		}
+		#endregion
+		
 		#region Modifiers
 		static void ApplyModifiers(DefaultTypeDefinition td, Modifiers modifiers)
 		{

ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs

@@ -64,6 +64,110 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public UsingScope UsingScope { get; set; }
 		#endregion
 		
+		#region Local Variable Management
+		sealed class LocalVariable : IVariable
+		{
+			// We store the local variable in a linked list
+			// and provide a stack-like API.
+			// The beginning of a stack frame is marked by a dummy local variable
+			// with type==null and name==null.
+			
+			// This data structure is used to allow efficient cloning of the resolver with its local variable context.
+			
+			internal readonly LocalVariable prev;
+			internal readonly ITypeReference type;
+			internal readonly string name;
+			internal readonly IConstantValue constantValue;
+			
+			public LocalVariable(LocalVariable prev, ITypeReference type, string name, IConstantValue constantValue)
+			{
+				this.prev = prev;
+				this.type = type;
+				this.name = name;
+				this.constantValue = constantValue;
+			}
+			
+			public string Name {
+				get { return name; }
+			}
+			public ITypeReference Type {
+				get { return type; }
+			}
+			public bool IsConst {
+				get { return constantValue != null; }
+			}
+			public IConstantValue ConstantValue {
+				get { return constantValue; }
+			}
+			
+			public override string ToString()
+			{
+				if (name == null)
+					return "<Start of Block>";
+				else
+					return name + ":" + type;
+			}
+		}
+		
+		LocalVariable localVariableStack;
+		
+		/// <summary>
+		/// Opens a new scope for local variables.
+		/// </summary>
+		public void PushBlock()
+		{
+			localVariableStack = new LocalVariable(localVariableStack, null, null, null);
+		}
+		
+		/// <summary>
+		/// Closes the current scope for local variables; removing all variables in that scope.
+		/// </summary>
+		public void PopBlock()
+		{
+			LocalVariable removedVar;
+			do {
+				removedVar = localVariableStack;
+				if (removedVar == null)
+					throw new InvalidOperationException("Cannot execute PopBlock() without corresponding PushBlock()");
+				localVariableStack = removedVar.prev;
+			} while (removedVar.name != null);
+		}
+		
+		/// <summary>
+		/// Adds a new variable to the current block.
+		/// </summary>
+		public void AddVariable(ITypeReference type, string name, IConstantValue constantValue = null)
+		{
+			if (type == null)
+				throw new ArgumentNullException("type");
+			if (name == null)
+				throw new ArgumentNullException("name");
+			localVariableStack = new LocalVariable(localVariableStack, type, name, constantValue);
+		}
+		
+		/// <summary>
+		/// Gets all currently visible local variables.
+		/// </summary>
+		public IEnumerable<IVariable> LocalVariables {
+			get {
+				for (LocalVariable v = localVariableStack; v != null; v = v.prev) {
+					if (v.name != null)
+						yield return v;
+				}
+			}
+		}
+		#endregion
+		
+		#region Clone
+		/// <summary>
+		/// Creates a copy of this CSharp resolver.
+		/// </summary>
+		public CSharpResolver Clone()
+		{
+			return (CSharpResolver)MemberwiseClone();
+		}
+		#endregion
+		
 		#region class OperatorMethod
 		static OperatorMethod[] Lift(params OperatorMethod[] methods)
 		{
@@ -1383,17 +1487,23 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (typeArguments == null)
 				throw new ArgumentNullException("typeArguments");
 			
-			IParameterizedMember parameterizedMember = this.CurrentMember as IParameterizedMember;
-			if (parameterizedMember != null && typeArguments.Count == 0) {
-				foreach (IParameter p in parameterizedMember.Parameters) {
-					if (p.Name == identifier) {
-						return new VariableResolveResult(p, p.Type.Resolve(context));
+			if (typeArguments.Count == 0) {
+				foreach (IVariable v in this.LocalVariables) {
+					if (v.Name == identifier) {
+						object constantValue = v.IsConst ? v.ConstantValue.GetValue(context) : null;
+						return new VariableResolveResult(v, v.Type.Resolve(context), constantValue);
+					}
+				}
+				IParameterizedMember parameterizedMember = this.CurrentMember as IParameterizedMember;
+				if (parameterizedMember != null) {
+					foreach (IParameter p in parameterizedMember.Parameters) {
+						if (p.Name == identifier) {
+							return new VariableResolveResult(p, p.Type.Resolve(context));
+						}
 					}
 				}
 			}
 			
-			// TODO: lookup in local variables, etc.
-			
 			return LookupSimpleNameOrTypeName(identifier, typeArguments,
 			                                  isInvocationTarget ? SimpleNameLookupMode.InvocationTarget : SimpleNameLookupMode.Expression);
 		}

ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs

@@ -184,6 +184,43 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			return VisitMethodMember(destructorDeclaration, data);
 		}
+		
+		public override ResolveResult VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
+		{
+			try {
+				if (resolver.CurrentTypeDefinition != null) {
+					resolver.CurrentMember = resolver.CurrentTypeDefinition.Properties.FirstOrDefault(p => p.Region.IsInside(propertyDeclaration.StartLocation));
+				}
+				
+				if (FullyResolveSubExpressions) {
+					ResolveType(propertyDeclaration.ReturnType);
+					foreach (INode node in propertyDeclaration.GetChildrenByRole(IndexerDeclaration.Roles.Argument))
+						Resolve(node);
+					if (propertyDeclaration.GetAccessor != null)
+						VisitAccessorDeclaration(propertyDeclaration.GetAccessor, data);
+					if (propertyDeclaration.SetAccessor != null && resolver.CurrentMember != null) {
+						resolver.PushBlock();
+						try {
+							resolver.AddVariable(resolver.CurrentMember.ReturnType, "value");
+							VisitAccessorDeclaration(propertyDeclaration.SetAccessor, data);
+						} finally {
+							resolver.PopBlock();
+						}
+					}
+				}
+				if (resolver.CurrentMember != null)
+					return new MemberResolveResult(resolver.CurrentMember, resolver.CurrentMember.ReturnType.Resolve(resolver.Context));
+				else
+					return errorResult;
+			} finally {
+				resolver.CurrentMember = null;
+			}
+		}
+		
+		public override ResolveResult VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
+		{
+			return VisitPropertyDeclaration(indexerDeclaration, data);
+		}
 		#endregion
 		
 		#region Track CheckForOverflow
@@ -447,6 +484,16 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		}
 		#endregion
 		
+		public override ResolveResult VisitBlockStatement(BlockStatement blockStatement, object data)
+		{
+			resolver.PushBlock();
+			try {
+				return base.VisitBlockStatement(blockStatement, data);
+			} finally {
+				resolver.PopBlock();
+			}
+		}
+		
 		public override ResolveResult VisitParameterDeclaration(ParameterDeclaration parameterDeclaration, object data)
 		{
 			if (FullyResolveSubExpressions) {

ICSharpCode.NRefactory/CSharp/Resolver/VariableResolveResult.cs

@@ -12,13 +12,15 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	public class VariableResolveResult : ResolveResult
 	{
 		readonly IVariable variable;
+		readonly object constantValue;
 		
-		public VariableResolveResult(IVariable variable, IType type)
+		public VariableResolveResult(IVariable variable, IType type, object constantValue = null)
 			: base(type)
 		{
 			if (variable == null)
 				throw new ArgumentNullException("variable");
 			this.variable = variable;
+			this.constantValue = constantValue;
 		}
 		
 		public IVariable Variable {
@@ -29,6 +31,14 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			get { return variable is IParameter; }
 		}
 		
+		public override bool IsCompileTimeConstant {
+			get { return variable.IsConst; }
+		}
+		
+		public override object ConstantValue {
+			get { return constantValue; }
+		}
+		
 		public override string ToString()
 		{
 			return string.Format("[VariableResolveResult {0}]", variable);

ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj

@@ -190,6 +190,7 @@
     <Compile Include="TypeSystem\DomRegion.cs" />
     <Compile Include="TypeSystem\EntityType.cs" />
     <Compile Include="TypeSystem\ExtensionMethods.cs" />
+    <Compile Include="TypeSystem\IAccessor.cs" />
     <Compile Include="TypeSystem\IAttribute.cs" />
     <Compile Include="TypeSystem\IConstantValue.cs" />
     <Compile Include="TypeSystem\IEntity.cs" />
@@ -203,6 +204,7 @@
     <Compile Include="TypeSystem\Implementation\AbstractFreezable.cs" />
     <Compile Include="TypeSystem\Implementation\AbstractMember.cs" />
     <Compile Include="TypeSystem\Implementation\AbstractType.cs" />
+    <Compile Include="TypeSystem\Implementation\DefaultAccessor.cs" />
     <Compile Include="TypeSystem\Implementation\DefaultAttribute.cs" />
     <Compile Include="TypeSystem\Implementation\DefaultEvent.cs" />
     <Compile Include="TypeSystem\Implementation\DefaultExplicitInterfaceImplementation.cs" />

ICSharpCode.NRefactory/TypeSystem/ArrayType.cs

@@ -78,13 +78,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 					yield return p;
 				}
 				DefaultProperty indexer = new DefaultProperty(arrayDef, "Items") {
+					EntityType = EntityType.Indexer,
 					ReturnType = elementType,
 					Accessibility = Accessibility.Public,
-					GetterAccessibility = Accessibility.Public,
-					SetterAccessibility = Accessibility.Public,
-					CanGet = true,
-					CanSet = true,
-					IsIndexer = true,
+					Getter = DefaultAccessor.GetFromAccessibility(Accessibility.Public),
+					Setter = DefaultAccessor.GetFromAccessibility(Accessibility.Public),
 					IsSynthetic = true
 				};
 				for (int i = 0; i < dimensions; i++) {

ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs

@@ -308,6 +308,15 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			}
 		}
 		
+		void AddAttributes(MethodDefinition accessorMethod, DefaultAccessor targetAccessor)
+		{
+			if (accessorMethod.HasCustomAttributes) {
+				foreach (var cecilAttribute in accessorMethod.CustomAttributes) {
+					targetAccessor.Attributes.Add(ReadAttribute(cecilAttribute));
+				}
+			}
+		}
+		
 		static readonly DefaultAttribute serializableAttribute = new DefaultAttribute(typeof(SerializableAttribute).ToTypeReference());
 		
 		void AddAttributes(TypeDefinition typeDefinition, ITypeDefinition targetEntity)
@@ -617,7 +626,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 						if (defaultMemberName != null) {
 							foreach (DefaultProperty p in this.Properties) {
 								if (p.Name == defaultMemberName) {
-									p.IsIndexer = true;
+									p.EntityType = EntityType.Indexer;
 								}
 							}
 						}
@@ -843,13 +852,8 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			TranslateModifiers(property.GetMethod ?? property.SetMethod, p);
 			p.ReturnType = ReadTypeReference(property.PropertyType, typeAttributes: property, entity: p);
 			
-			p.CanGet = property.GetMethod != null && IsVisible(property.GetMethod.Attributes);
-			p.CanSet = property.SetMethod != null && IsVisible(property.SetMethod.Attributes);
-			
-			if (p.CanGet)
-				p.GetterAccessibility = GetAccessibility(property.GetMethod.Attributes);
-			if (p.CanSet)
-				p.SetterAccessibility = GetAccessibility(property.SetMethod.Attributes);
+			p.Getter = ReadAccessor(property.GetMethod);
+			p.Setter = ReadAccessor(property.SetMethod);
 			
 			if (property.HasParameters) {
 				foreach (ParameterDefinition par in property.Parameters) {
@@ -860,6 +864,23 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			
 			return p;
 		}
+		
+		IAccessor ReadAccessor(MethodDefinition accessorMethod)
+		{
+			if (accessorMethod != null && IsVisible(accessorMethod.Attributes)) {
+				Accessibility accessibility = GetAccessibility(accessorMethod.Attributes);
+				if (accessorMethod.HasCustomAttributes) {
+					DefaultAccessor a = new DefaultAccessor();
+					a.Accessibility = accessibility;
+					AddAttributes(accessorMethod, a);
+					return a;
+				} else {
+					return DefaultAccessor.GetFromAccessibility(accessibility);
+				}
+			} else {
+				return null;
+			}
+		}
 		#endregion
 		
 		#region Read Event
@@ -874,16 +895,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			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);
+			e.AddAccessor = ReadAccessor(ev.AddMethod);
+			e.RemoveAccessor = ReadAccessor(ev.RemoveMethod);
+			e.InvokeAccessor = ReadAccessor(ev.InvokeMethod);
 			
 			AddAttributes(ev, e);
 			

ICSharpCode.NRefactory/TypeSystem/IAccessor.cs

@@ -0,0 +1,29 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+
+namespace ICSharpCode.NRefactory.TypeSystem
+{
+	/// <summary>
+	/// Represents an accessor (property getter/setter; or event add/remove/invoke).
+	/// </summary>
+	public interface IAccessor : IFreezable
+	{
+		/// <summary>
+		/// Gets the accessor region.
+		/// </summary>
+		DomRegion Region { get; }
+		
+		/// <summary>
+		/// Gets the attributes defined on this accessor.
+		/// </summary>
+		IList<IAttribute> Attributes { get; }
+		
+		/// <summary>
+		/// Gets the accessibility of this accessor.
+		/// </summary>
+		Accessibility Accessibility { get; }
+	}
+}

ICSharpCode.NRefactory/TypeSystem/IEvent.cs

@@ -12,8 +12,8 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		bool CanRemove { get; }
 		bool CanInvoke { get; }
 		
-		Accessibility AddAccessibility { get; }
-		Accessibility RemoveAccessibility { get; }
-		Accessibility InvokeAccessibility { get; }
+		IAccessor AddAccessor { get; }
+		IAccessor RemoveAccessor { get; }
+		IAccessor InvokeAccessor { get; }
 	}
 }

ICSharpCode.NRefactory/TypeSystem/IField.cs

@@ -17,11 +17,6 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// </summary>
 		new string Name { get; } // solve ambiguity between INamedElement.Name and IVariable.Name
 		
-		/// <summary>
-		/// Gets whether this field is a constant (C#-like const).
-		/// </summary>
-		bool IsConst { get; }
-		
 		/// <summary>
 		/// Gets whether this field is readonly.
 		/// </summary>
@@ -31,11 +26,6 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// Gets whether this field is volatile.
 		/// </summary>
 		bool IsVolatile { get; }
-		
-		/// <summary>
-		/// If this field is a constant, retrieves the value.
-		/// </summary>
-		IConstantValue ConstantValue { get; }
 	}
 	
 	[ContractClassFor(typeof(IField))]
@@ -48,14 +38,6 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			}
 		}
 		
-		bool IField.IsConst {
-			get {
-				IField @this = this;
-				Contract.Ensures(Contract.Result<bool>() == (@this.ConstantValue != null));
-				return false;
-			}
-		}
-		
 		bool IField.IsReadOnly {
 			get { return false; }
 		}
@@ -64,9 +46,6 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			get { return false; }
 		}
 		
-		IConstantValue IField.ConstantValue {
-			get { return null; }
-		}
 		
 		string IVariable.Name {
 			get { return null;  }
@@ -75,5 +54,13 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		ITypeReference IVariable.Type {
 			get { return null; }
 		}
+		
+		bool IVariable.IsConst {
+			get { return false; }
+		}
+		
+		IConstantValue IVariable.ConstantValue {
+			get { return null; }
+		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/IProperty.cs

@@ -13,8 +13,8 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		bool CanGet { get; }
 		bool CanSet { get; }
 		
-		Accessibility GetterAccessibility { get; }
-		Accessibility SetterAccessibility { get; }
+		IAccessor Getter { get; }
+		IAccessor Setter { get; }
 		
 		bool IsIndexer { get; }
 	}

ICSharpCode.NRefactory/TypeSystem/IVariable.cs

@@ -21,6 +21,16 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// Gets the type of the variable.
 		/// </summary>
 		ITypeReference Type { get; }
+		
+		/// <summary>
+		/// Gets whether this field is a constant (C#-like const).
+		/// </summary>
+		bool IsConst { get; }
+		
+		/// <summary>
+		/// If this field is a constant, retrieves the value.
+		/// </summary>
+		IConstantValue ConstantValue { get; }
 	}
 	
 	[ContractClassFor(typeof(IVariable))]
@@ -39,5 +49,17 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				return null;
 			}
 		}
+		
+		bool IVariable.IsConst {
+			get {
+				IVariable @this = this;
+				Contract.Ensures(Contract.Result<bool>() == (@this.ConstantValue != null));
+				return false;
+			}
+		}
+		
+		IConstantValue IVariable.ConstantValue {
+			get { return null; }
+		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultAccessor.cs

@@ -0,0 +1,78 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ICSharpCode.NRefactory.TypeSystem.Implementation
+{
+	/// <summary>
+	/// Default implementation of <see cref="IAccessor"/>.
+	/// </summary>
+	public sealed class DefaultAccessor : AbstractFreezable, IAccessor
+	{
+		static readonly DefaultAccessor[] defaultAccessors = CreateDefaultAccessors();
+		
+		static DefaultAccessor[] CreateDefaultAccessors()
+		{
+			DefaultAccessor[] accessors = new DefaultAccessor[(int)Accessibility.ProtectedAndInternal + 1];
+			for (int i = 0; i < accessors.Length; i++) {
+				accessors[i] = new DefaultAccessor();
+				accessors[i].accessibility = (Accessibility)i;
+				accessors[i].Freeze();
+			}
+			return accessors;
+		}
+		
+		/// <summary>
+		/// Gets the default accessor with the specified accessibility (and without attributes or region).
+		/// </summary>
+		public static IAccessor GetFromAccessibility(Accessibility accessibility)
+		{
+			int index = (int)accessibility;
+			if (index >= 0 && index < defaultAccessors.Length) {
+				return defaultAccessors[index];
+			} else {
+				DefaultAccessor a = new DefaultAccessor();
+				a.accessibility = accessibility;
+				a.Freeze();
+				return a;
+			}
+		}
+		
+		Accessibility accessibility;
+		DomRegion region;
+		IList<IAttribute> attributes;
+		
+		protected override void FreezeInternal()
+		{
+			base.FreezeInternal();
+			this.attributes = FreezeList(this.attributes);
+		}
+		
+		public Accessibility Accessibility {
+			get { return accessibility; }
+			set {
+				CheckBeforeMutation();
+				accessibility = value;
+			}
+		}
+		
+		public DomRegion Region {
+			get { return region; }
+			set {
+				CheckBeforeMutation();
+				region = value;
+			}
+		}
+		
+		public IList<IAttribute> Attributes {
+			get {
+				if (attributes == null)
+					attributes = new List<IAttribute>();
+				return attributes;
+			}
+		}
+	}
+}

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultEvent.cs

@@ -10,13 +10,15 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 	/// </summary>
 	public class DefaultEvent : AbstractMember, IEvent
 	{
-		Accessibility addAccessibility;
-		Accessibility removeAccessibility;
-		Accessibility invokeAccessibility;
+		IAccessor addAccessor, removeAccessor, invokeAccessor;
 		
-		const ushort FlagCanAdd    = 0x1000;
-		const ushort FlagCanRemove = 0x2000;
-		const ushort FlagCanInvoke  = 0x4000;
+		protected override void FreezeInternal()
+		{
+			base.FreezeInternal();
+			if (addAccessor != null)    addAccessor.Freeze();
+			if (removeAccessor != null) removeAccessor.Freeze();
+			if (invokeAccessor != null) invokeAccessor.Freeze();
+		}
 		
 		public DefaultEvent(ITypeDefinition declaringTypeDefinition, string name)
 			: base(declaringTypeDefinition, name, EntityType.Event)
@@ -29,59 +31,44 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		protected DefaultEvent(IEvent ev)
 			: base(ev)
 		{
-			this.CanAdd = ev.CanAdd;
-			this.addAccessibility = ev.AddAccessibility;
-			this.CanRemove = ev.CanRemove;
-			this.removeAccessibility = ev.RemoveAccessibility;
-			this.CanInvoke = ev.CanInvoke;
-			this.invokeAccessibility = ev.InvokeAccessibility;
+			this.addAccessor = ev.AddAccessor;
+			this.removeAccessor = ev.RemoveAccessor;
+			this.invokeAccessor = ev.InvokeAccessor;
 		}
 		
 		public bool CanAdd {
-			get { return flags[FlagCanAdd]; }
-			set {
-				CheckBeforeMutation();
-				flags[FlagCanAdd] = value;
-			}
+			get { return addAccessor != null; }
 		}
 		
 		public bool CanRemove {
-			get { return flags[FlagCanRemove]; }
-			set {
-				CheckBeforeMutation();
-				flags[FlagCanRemove] = value;
-			}
+			get { return removeAccessor != null; }
 		}
 		
 		public bool CanInvoke {
-			get { return flags[FlagCanInvoke]; }
-			set {
-				CheckBeforeMutation();
-				flags[FlagCanInvoke] = value;
-			}
+			get { return invokeAccessor != null; }
 		}
 		
-		public Accessibility AddAccessibility {
-			get { return addAccessibility; }
+		public IAccessor AddAccessor{
+			get { return addAccessor; }
 			set {
 				CheckBeforeMutation();
-				addAccessibility = value;
+				addAccessor = value;
 			}
 		}
 		
-		public Accessibility RemoveAccessibility {
-			get { return removeAccessibility; }
+		public IAccessor RemoveAccessor {
+			get { return removeAccessor; }
 			set {
 				CheckBeforeMutation();
-				removeAccessibility = value;
+				removeAccessor = value;
 			}
 		}
 		
-		public Accessibility InvokeAccessibility {
-			get { return invokeAccessibility; }
+		public IAccessor InvokeAccessor {
+			get { return invokeAccessor; }
 			set {
 				CheckBeforeMutation();
-				invokeAccessibility = value;
+				invokeAccessor = value;
 			}
 		}
 	}

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultParameter.cs

@@ -184,5 +184,13 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 			return b.ToString();
 		}
+		
+		bool IVariable.IsConst {
+			get { return false; }
+		}
+		
+		IConstantValue IVariable.ConstantValue {
+			get { return null; }
+		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultProperty.cs

@@ -11,17 +11,14 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 	/// </summary>
 	public class DefaultProperty : AbstractMember, IProperty
 	{
-		Accessibility getterAccessibility;
-		Accessibility setterAccessibility;
+		IAccessor getter, setter;
 		IList<IParameter> parameters;
 		
-		const ushort FlagIsIndexer = 0x1000;
-		const ushort FlagCanGet    = 0x2000;
-		const ushort FlagCanSet    = 0x4000;
-		
 		protected override void FreezeInternal()
 		{
 			parameters = FreezeList(parameters);
+			if (getter != null) getter.Freeze();
+			if (setter != null) setter.Freeze();
 			base.FreezeInternal();
 		}
 		
@@ -32,12 +29,9 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		protected DefaultProperty(IProperty p) : base(p)
 		{
-			this.getterAccessibility = p.GetterAccessibility;
-			this.setterAccessibility = p.SetterAccessibility;
+			this.getter = p.Getter;
+			this.setter = p.Setter;
 			this.parameters = CopyList(p.Parameters);
-			this.IsIndexer = p.IsIndexer;
-			this.CanGet = p.CanGet;
-			this.CanSet = p.CanSet;
 		}
 		
 		public override void PrepareForInterning(IInterningProvider provider)
@@ -47,11 +41,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		public bool IsIndexer {
-			get { return flags[FlagIsIndexer]; }
-			set {
-				CheckBeforeMutation();
-				flags[FlagIsIndexer] = value;
-			}
+			get { return this.EntityType == EntityType.Indexer; }
 		}
 		
 		public IList<IParameter> Parameters {
@@ -63,34 +53,26 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		public bool CanGet {
-			get { return flags[FlagCanGet]; }
-			set {
-				CheckBeforeMutation();
-				flags[FlagCanGet] = value;
-			}
+			get { return getter != null; }
 		}
 		
 		public bool CanSet {
-			get { return flags[FlagCanSet]; }
-			set {
-				CheckBeforeMutation();
-				flags[FlagCanSet] = value;
-			}
+			get { return setter != null; }
 		}
 		
-		public Accessibility GetterAccessibility {
-			get { return getterAccessibility; }
+		public IAccessor Getter{
+			get { return getter; }
 			set {
 				CheckBeforeMutation();
-				getterAccessibility = value;
+				getter = value;
 			}
 		}
 		
-		public Accessibility SetterAccessibility {
-			get { return setterAccessibility; }
+		public IAccessor Setter {
+			get { return setter; }
 			set {
 				CheckBeforeMutation();
-				setterAccessibility = value;
+				setter = value;
 			}
 		}
 	}