Rename EntityType -> SymbolKind

ICSharpCode.NRefactory.CSharp/Analysis/SemanticHighlightingVisitor.cs

@@ -293,7 +293,7 @@ namespace ICSharpCode.NRefactory.CSharp.Analysis
 		#region IsInactiveConditional helper methods
 		bool IsInactiveConditionalMethod(IParameterizedMember member)
 		{
-			if (member.EntityType != EntityType.Method || member.ReturnType.Kind != TypeKind.Void)
+			if (member.SymbolKind != SymbolKind.Method || member.ReturnType.Kind != TypeKind.Void)
 				return false;
 			while (member.IsOverride) {
 				member = (IParameterizedMember)InheritanceHelper.GetBaseMember(member);
@@ -461,21 +461,21 @@ namespace ICSharpCode.NRefactory.CSharp.Analysis
 		
 		bool TryGetMemberColor(IMember member, out TColor color)
 		{
-			switch (member.EntityType) {
-				case EntityType.Field:
+			switch (member.SymbolKind) {
+				case SymbolKind.Field:
 					color = fieldAccessColor;
 					return true;
-				case EntityType.Property:
+				case SymbolKind.Property:
 					color = propertyAccessColor;
 					return true;
-				case EntityType.Event:
+				case SymbolKind.Event:
 					color = eventAccessColor;
 					return true;
-				case EntityType.Method:
+				case SymbolKind.Method:
 					color = methodCallColor;
 					return true;
-				case EntityType.Constructor:
-				case EntityType.Destructor:
+				case SymbolKind.Constructor:
+				case SymbolKind.Destructor:
 					return TryGetTypeHighlighting (member.DeclaringType.Kind, out color);
 				default:
 					color = default (TColor);

ICSharpCode.NRefactory.CSharp/Ast/DocumentationReference.cs

@@ -29,29 +29,29 @@ namespace ICSharpCode.NRefactory.CSharp
 		public static readonly Role<AstType> DeclaringTypeRole = new Role<AstType>("DeclaringType", AstType.Null);
 		public static readonly Role<AstType> ConversionOperatorReturnTypeRole = new Role<AstType>("ConversionOperatorReturnType", AstType.Null);
 		
-		EntityType entityType;
+		SymbolKind symbolKind;
 		OperatorType operatorType;
 		bool hasParameterList;
 		
 		/// <summary>
 		/// Gets/Sets the entity type.
 		/// Possible values are:
-		///   <c>EntityType.Operator</c> for operators,
-		///   <c>EntityType.Indexer</c> for indexers,
-		///   <c>EntityType.TypeDefinition</c> for references to primitive types,
-		///   and <c>EntityType.None</c> for everything else.
+		///   <c>SymbolKind.Operator</c> for operators,
+		///   <c>SymbolKind.Indexer</c> for indexers,
+		///   <c>SymbolKind.TypeDefinition</c> for references to primitive types,
+		///   and <c>SymbolKind.None</c> for everything else.
 		/// </summary>
-		public EntityType EntityType {
-			get { return entityType; }
+		public SymbolKind SymbolKind {
+			get { return symbolKind; }
 			set {
 				ThrowIfFrozen();
-				entityType = value;
+				symbolKind = value;
 			}
 		}
 		
 		/// <summary>
 		/// Gets/Sets the operator type.
-		/// This property is only used when EntityType==Operator.
+		/// This property is only used when SymbolKind==Operator.
 		/// </summary>
 		public OperatorType OperatorType {
 			get { return operatorType; }
@@ -86,7 +86,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		/// <summary>
 		/// Gets/sets the member name.
-		/// This property is only used when EntityType==None.
+		/// This property is only used when SymbolKind==None.
 		/// </summary>
 		public string MemberName {
 			get { return GetChildByRole(Roles.Identifier).Name; }
@@ -95,7 +95,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		/// <summary>
 		/// Gets/Sets the return type of conversion operators.
-		/// This property is only used when EntityType==Operator and OperatorType is explicit or implicit.
+		/// This property is only used when SymbolKind==Operator and OperatorType is explicit or implicit.
 		/// </summary>
 		public AstType ConversionOperatorReturnType {
 			get { return GetChildByRole(ConversionOperatorReturnTypeRole); }
@@ -113,16 +113,16 @@ namespace ICSharpCode.NRefactory.CSharp
 		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
 		{
 			DocumentationReference o = other as DocumentationReference;
-			if (!(o != null && this.EntityType == o.EntityType && this.HasParameterList == o.HasParameterList))
+			if (!(o != null && this.SymbolKind == o.SymbolKind && this.HasParameterList == o.HasParameterList))
 				return false;
-			if (this.EntityType == EntityType.Operator) {
+			if (this.SymbolKind == SymbolKind.Operator) {
 				if (this.OperatorType != o.OperatorType)
 					return false;
 				if (this.OperatorType == OperatorType.Implicit || this.OperatorType == OperatorType.Explicit) {
 					if (!this.ConversionOperatorReturnType.DoMatch(o.ConversionOperatorReturnType, match))
 						return false;
 				}
-			} else if (this.EntityType == EntityType.None) {
+			} else if (this.SymbolKind == SymbolKind.None) {
 				if (!MatchString(this.MemberName, o.MemberName))
 					return false;
 				if (!this.TypeArguments.DoMatch(o.TypeArguments, match))

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/DelegateDeclaration.cs

@@ -37,8 +37,8 @@ namespace ICSharpCode.NRefactory.CSharp
 			get { return NodeType.TypeDeclaration; }
 		}
 		
-		public override EntityType EntityType {
-			get { return EntityType.TypeDefinition; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.TypeDefinition; }
 		}
 		
 		public CSharpTokenNode DelegateToken {

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/TypeDeclaration.cs

@@ -47,8 +47,8 @@ namespace ICSharpCode.NRefactory.CSharp
 			get { return NodeType.TypeDeclaration; }
 		}
 		
-		public override EntityType EntityType {
-			get { return EntityType.TypeDefinition; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.TypeDefinition; }
 		}
 		
 		ClassType classType;

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/Accessor.cs

@@ -67,8 +67,8 @@ namespace ICSharpCode.NRefactory.CSharp
 			get { return NodeType.Unknown; }
 		}
 		
-		public override EntityType EntityType {
-			get { return EntityType.Method; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Method; }
 		}
 		
 		/// <summary>

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/ConstructorDeclaration.cs

@@ -32,8 +32,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	{
 		public static readonly Role<ConstructorInitializer> InitializerRole = new Role<ConstructorInitializer>("Initializer", ConstructorInitializer.Null);
 		
-		public override EntityType EntityType {
-			get { return EntityType.Constructor; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Constructor; }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/DestructorDeclaration.cs

@@ -36,8 +36,8 @@ namespace ICSharpCode.NRefactory.CSharp
 			get { return GetChildByRole (TildeRole); }
 		}
 		
-		public override EntityType EntityType {
-			get { return EntityType.Destructor; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Destructor; }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EntityDeclaration.cs

@@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			get { return NodeType.Member; }
 		}
 		
-		public abstract NRefactory.TypeSystem.EntityType EntityType { get; }
+		public abstract NRefactory.TypeSystem.SymbolKind SymbolKind { get; }
 		
 		public AstNodeCollection<AttributeSection> Attributes {
 			get { return base.GetChildrenByRole (AttributeRole); }

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EnumMemberDeclaration.cs

@@ -33,8 +33,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	{
 		public static readonly Role<Expression> InitializerRole = new Role<Expression>("Initializer", Expression.Null);
 		
-		public override EntityType EntityType {
-			get { return EntityType.Field; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Field; }
 		}
 
 		public CSharpTokenNode AssignToken {

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EventDeclaration.cs

@@ -36,8 +36,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	{
 		public static readonly TokenRole EventKeywordRole = new TokenRole ("event");
 		
-		public override EntityType EntityType {
-			get { return EntityType.Event; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Event; }
 		}
 
 		public CSharpTokenNode EventToken {
@@ -94,8 +94,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		public static readonly Role<Accessor> AddAccessorRole = new Role<Accessor>("AddAccessor", Accessor.Null);
 		public static readonly Role<Accessor> RemoveAccessorRole = new Role<Accessor>("RemoveAccessor", Accessor.Null);
 		
-		public override EntityType EntityType {
-			get { return EntityType.Event; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Event; }
 		}
 		
 		/// <summary>

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FieldDeclaration.cs

@@ -32,8 +32,8 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class FieldDeclaration : EntityDeclaration
 	{
-		public override EntityType EntityType {
-			get { return EntityType.Field; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Field; }
 		}
 		
 		public AstNodeCollection<VariableInitializer> Variables {

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FixedFieldDeclaration.cs

@@ -33,8 +33,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		public static readonly TokenRole FixedKeywordRole = new TokenRole ("fixed");
 		public static readonly Role<FixedVariableInitializer> VariableRole = new Role<FixedVariableInitializer> ("FixedVariable");
 		
-		public override EntityType EntityType {
-			get { return EntityType.Field; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Field; }
 		}
 		
 		public CSharpTokenNode FixedToken {

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/IndexerDeclaration.cs

@@ -36,8 +36,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		public static readonly Role<Accessor> GetterRole = PropertyDeclaration.GetterRole;
 		public static readonly Role<Accessor> SetterRole = PropertyDeclaration.SetterRole;
 		
-		public override EntityType EntityType {
-			get { return EntityType.Indexer; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Indexer; }
 		}
 		
 		/// <summary>

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/MethodDeclaration.cs

@@ -30,8 +30,8 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class MethodDeclaration : EntityDeclaration
 	{
-		public override EntityType EntityType {
-			get { return EntityType.Method; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Method; }
 		}
 		
 		/// <summary>

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

@@ -106,8 +106,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		public static readonly TokenRole ExplicitRole = new TokenRole ("explicit");
 		public static readonly TokenRole ImplicitRole = new TokenRole ("implicit");
 		
-		public override EntityType EntityType {
-			get { return EntityType.Operator; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Operator; }
 		}
 		
 		OperatorType operatorType;

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

@@ -34,8 +34,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		public static readonly Role<Accessor> GetterRole = new Role<Accessor>("Getter", Accessor.Null);
 		public static readonly Role<Accessor> SetterRole = new Role<Accessor>("Setter", Accessor.Null);
 		
-		public override EntityType EntityType {
-			get { return EntityType.Property; }
+		public override SymbolKind SymbolKind {
+			get { return SymbolKind.Property; }
 		}
 		
 		/// <summary>

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@@ -317,14 +317,14 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 					bool isProtectedAllowed = ctx.CurrentTypeDefinition != null && initializerType.GetDefinition() != null ? 
 						ctx.CurrentTypeDefinition.IsDerivedFrom(initializerType.GetDefinition()) : 
 							false;
-					foreach (var m in initializerType.GetMembers (m => m.EntityType == EntityType.Field)) {
+					foreach (var m in initializerType.GetMembers (m => m.SymbolKind == SymbolKind.Field)) {
 						var f = m as IField;
 						if (f != null && (f.IsReadOnly || f.IsConst))
 						    continue;
 						if (lookup.IsAccessible (m, isProtectedAllowed))
 							contextList.AddMember(m);
 					}
-					foreach (IProperty m in initializerType.GetMembers (m => m.EntityType == EntityType.Property)) {
+					foreach (IProperty m in initializerType.GetMembers (m => m.SymbolKind == SymbolKind.Property)) {
 						if (m.CanSet && lookup.IsAccessible (m.Setter, isProtectedAllowed))
 							contextList.AddMember(m);
 					}
@@ -1506,7 +1506,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 							if (member is IMethod && ((IMethod)member).FullName == "System.Object.Finalize") {
 								continue;
 							}
-							if (member.EntityType == EntityType.Operator) {
+							if (member.SymbolKind == SymbolKind.Operator) {
 								continue;
 							}
 							if (member.IsExplicitInterfaceImplementation) {
@@ -2159,7 +2159,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 		
 		bool MatchDelegate(IType delegateType, IMethod method)
 		{
-			if (method.EntityType != EntityType.Method)
+			if (method.SymbolKind != SymbolKind.Method)
 				return false;
 			var delegateMethod = delegateType.GetDelegateInvokeMethod();
 			if (delegateMethod == null || delegateMethod.Parameters.Count != method.Parameters.Count) {
@@ -2608,7 +2608,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 					result.AddMember(member);
 				}*/
 				foreach (var member in lookup.GetAccessibleMembers (resolveResult)) {
-					if (member.EntityType == EntityType.Indexer || member.EntityType == EntityType.Operator || member.EntityType == EntityType.Constructor || member.EntityType == EntityType.Destructor) {
+					if (member.SymbolKind == SymbolKind.Indexer || member.SymbolKind == SymbolKind.Operator || member.SymbolKind == SymbolKind.Constructor || member.SymbolKind == SymbolKind.Destructor) {
 						continue;
 					}
 					if (resolvedNode is BaseReferenceExpression && member.IsAbstract) {
@@ -2639,7 +2639,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 					if (member is IMethod && ((IMethod)member).FullName == "System.Object.Finalize") {
 						continue;
 					}
-					if (member.EntityType == EntityType.Operator) {
+					if (member.SymbolKind == SymbolKind.Operator) {
 						continue;
 					}
 

ICSharpCode.NRefactory.CSharp/Completion/CompletionDataWrapper.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // CompletionDataWrapper.cs
 //  
 // Author:
@@ -172,14 +172,14 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			List<ICompletionData> existingData;
 			data.TryGetValue (memberKey, out existingData);
 			if (existingData != null) {
-				if (member.EntityType == EntityType.Field || member.EntityType == EntityType.Property || member.EntityType == EntityType.Event)
+				if (member.SymbolKind == SymbolKind.Field || member.SymbolKind == SymbolKind.Property || member.SymbolKind == SymbolKind.Event)
 					return null;
 				var a = member as IEntity;
 				foreach (var d in existingData) {
 					if (!(d is IEntityCompletionData))
 						continue;
 					var b = ((IEntityCompletionData)d).Entity;
-					if (a == null || b == null || a.EntityType == b.EntityType) {
+					if (a == null || b == null || a.SymbolKind == b.SymbolKind) {
 						d.AddOverload (newData);
 						return d;
 					} 

ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs

@@ -96,7 +96,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				WriteMemberDeclarationName((IMember)entity, formatter, formattingPolicy);
 			
 			if ((ConversionFlags & ConversionFlags.ShowParameterList) == ConversionFlags.ShowParameterList && HasParameters(entity)) {
-				formatter.WriteToken(entity.EntityType == EntityType.Indexer ? "[" : "(");
+				formatter.WriteToken(entity.SymbolKind == SymbolKind.Indexer ? "[" : "(");
 				bool first = true;
 				foreach (var param in node.GetChildrenByRole(Roles.Parameter)) {
 					if (first) {
@@ -107,7 +107,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 					param.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
 				}
-				formatter.WriteToken(entity.EntityType == EntityType.Indexer ? "]" : ")");
+				formatter.WriteToken(entity.SymbolKind == SymbolKind.Indexer ? "]" : ")");
 			}
 			
 			if ((ConversionFlags & ConversionFlags.ShowBody) == ConversionFlags.ShowBody && !(node is TypeDeclaration)) {
@@ -135,14 +135,14 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		bool HasParameters(IEntity e)
 		{
-			switch (e.EntityType) {
-				case EntityType.TypeDefinition:
+			switch (e.SymbolKind) {
+				case SymbolKind.TypeDefinition:
 					return ((ITypeDefinition)e).Kind == TypeKind.Delegate;
-				case EntityType.Indexer:
-				case EntityType.Method:
-				case EntityType.Operator:
-				case EntityType.Constructor:
-				case EntityType.Destructor:
+				case SymbolKind.Indexer:
+				case SymbolKind.Method:
+				case SymbolKind.Operator:
+				case SymbolKind.Constructor:
+				case SymbolKind.Destructor:
 					return true;
 				default:
 					return false;
@@ -184,18 +184,18 @@ namespace ICSharpCode.NRefactory.CSharp
 				ConvertType(member.DeclaringType, formatter, formattingPolicy);
 				formatter.WriteToken(".");
 			}
-			switch (member.EntityType) {
-				case EntityType.Indexer:
+			switch (member.SymbolKind) {
+				case SymbolKind.Indexer:
 					formatter.WriteKeyword("this");
 					break;
-				case EntityType.Constructor:
+				case SymbolKind.Constructor:
 					formatter.WriteIdentifier(member.DeclaringType.Name);
 					break;
-				case EntityType.Destructor:
+				case SymbolKind.Destructor:
 					formatter.WriteToken("~");
 					formatter.WriteIdentifier(member.DeclaringType.Name);
 					break;
-				case EntityType.Operator:
+				case SymbolKind.Operator:
 					switch (member.Name) {
 						case "op_Implicit":
 							formatter.WriteKeyword("implicit");
@@ -226,7 +226,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					formatter.WriteIdentifier(member.Name);
 					break;
 			}
-			if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList && member.EntityType == EntityType.Method) {
+			if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList && member.SymbolKind == SymbolKind.Method) {
 				var outputVisitor = new CSharpOutputVisitor(formatter, formattingPolicy);
 				outputVisitor.WriteTypeParameters(astBuilder.ConvertEntity(member).GetChildrenByRole(Roles.TypeParameter));
 			}

ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpOutputVisitor.cs

@@ -2597,18 +2597,18 @@ namespace ICSharpCode.NRefactory.CSharp
 			StartNode(documentationReference);
 			if (!documentationReference.DeclaringType.IsNull) {
 				documentationReference.DeclaringType.AcceptVisitor(this);
-				if (documentationReference.EntityType != EntityType.TypeDefinition) {
+				if (documentationReference.SymbolKind != SymbolKind.TypeDefinition) {
 					WriteToken(Roles.Dot);
 				}
 			}
-			switch (documentationReference.EntityType) {
-				case EntityType.TypeDefinition:
+			switch (documentationReference.SymbolKind) {
+				case SymbolKind.TypeDefinition:
 					// we already printed the DeclaringType
 					break;
-				case EntityType.Indexer:
+				case SymbolKind.Indexer:
 					WriteKeyword(IndexerDeclaration.ThisKeywordRole);
 					break;
-				case EntityType.Operator:
+				case SymbolKind.Operator:
 					var opType = documentationReference.OperatorType;
 					if (opType == OperatorType.Explicit) {
 						WriteKeyword(OperatorDeclaration.ExplicitRole);
@@ -2630,7 +2630,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			WriteTypeArguments(documentationReference.TypeArguments);
 			if (documentationReference.HasParameterList) {
 				Space(policy.SpaceBeforeMethodDeclarationParentheses);
-				if (documentationReference.EntityType == EntityType.Indexer) {
+				if (documentationReference.SymbolKind == SymbolKind.Indexer) {
 					WriteCommaSeparatedListInBrackets(documentationReference.Parameters, policy.SpaceWithinMethodDeclarationParentheses);
 				} else {
 					WriteCommaSeparatedListInParenthesis(documentationReference.Parameters, policy.SpaceWithinMethodDeclarationParentheses);

ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs

@@ -685,7 +685,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		CodeObject IAstVisitor<CodeObject>.VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration)
 		{
 			CodeTypeDelegate d = new CodeTypeDelegate(delegateDeclaration.Name);
-			d.Attributes = ConvertMemberAttributes(delegateDeclaration.Modifiers, EntityType.TypeDefinition);
+			d.Attributes = ConvertMemberAttributes(delegateDeclaration.Modifiers, SymbolKind.TypeDefinition);
 			d.CustomAttributes.AddRange(Convert(delegateDeclaration.Attributes));
 			d.ReturnType = Convert(delegateDeclaration.ReturnType);
 			d.Parameters.AddRange(Convert(delegateDeclaration.Parameters));
@@ -693,14 +693,14 @@ namespace ICSharpCode.NRefactory.CSharp
 			return d;
 		}
 		
-		MemberAttributes ConvertMemberAttributes(Modifiers modifiers, EntityType entityType)
+		MemberAttributes ConvertMemberAttributes(Modifiers modifiers, SymbolKind symbolKind)
 		{
 			MemberAttributes a = 0;
 			if ((modifiers & Modifiers.Abstract) != 0)
 				a |= MemberAttributes.Abstract;
 			if ((modifiers & Modifiers.Sealed) != 0)
 				a |= MemberAttributes.Final;
-			if (entityType != EntityType.TypeDefinition && (modifiers & (Modifiers.Abstract | Modifiers.Override | Modifiers.Virtual)) == 0)
+			if (symbolKind != SymbolKind.TypeDefinition && (modifiers & (Modifiers.Abstract | Modifiers.Override | Modifiers.Virtual)) == 0)
 				a |= MemberAttributes.Final;
 			if ((modifiers & Modifiers.Static) != 0)
 				a |= MemberAttributes.Static;
@@ -748,7 +748,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			//bool isNestedType = typeStack.Count > 0;
 			CodeTypeDeclaration typeDecl = new CodeTypeDeclaration(typeDeclaration.Name);
-			typeDecl.Attributes = ConvertMemberAttributes(typeDeclaration.Modifiers, EntityType.TypeDefinition);
+			typeDecl.Attributes = ConvertMemberAttributes(typeDeclaration.Modifiers, SymbolKind.TypeDefinition);
 			typeDecl.CustomAttributes.AddRange(Convert(typeDeclaration.Attributes));
 			
 			switch (typeDeclaration.ClassType) {
@@ -1056,7 +1056,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		CodeObject IAstVisitor<CodeObject>.VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
 		{
 			CodeConstructor ctor = new CodeConstructor();
-			ctor.Attributes = ConvertMemberAttributes(constructorDeclaration.Modifiers, EntityType.Constructor);
+			ctor.Attributes = ConvertMemberAttributes(constructorDeclaration.Modifiers, SymbolKind.Constructor);
 			ctor.CustomAttributes.AddRange(Convert(constructorDeclaration.Attributes));
 			if (constructorDeclaration.Initializer.ConstructorInitializerType == ConstructorInitializerType.This) {
 				ctor.ChainedConstructorArgs.AddRange(Convert(constructorDeclaration.Initializer.Arguments));
@@ -1098,7 +1098,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				
 				CodeMemberEvent e = new CodeMemberEvent();
-				e.Attributes = ConvertMemberAttributes(eventDeclaration.Modifiers, EntityType.Event);
+				e.Attributes = ConvertMemberAttributes(eventDeclaration.Modifiers, SymbolKind.Event);
 				e.CustomAttributes.AddRange(Convert(eventDeclaration.Attributes));
 				e.Name = vi.Name;
 				e.Type = Convert(eventDeclaration.ReturnType);
@@ -1116,7 +1116,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			foreach (VariableInitializer vi in fieldDeclaration.Variables) {
 				CodeMemberField f = new CodeMemberField(Convert(fieldDeclaration.ReturnType), vi.Name);
-				f.Attributes = ConvertMemberAttributes(fieldDeclaration.Modifiers, EntityType.Field);
+				f.Attributes = ConvertMemberAttributes(fieldDeclaration.Modifiers, SymbolKind.Field);
 				f.CustomAttributes.AddRange(Convert(fieldDeclaration.Attributes));
 				f.InitExpression = ConvertVariableInitializer(vi.Initializer, fieldDeclaration.ReturnType);
 				AddTypeMember(f);
@@ -1127,7 +1127,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		CodeObject IAstVisitor<CodeObject>.VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration)
 		{
 			CodeMemberProperty p = new CodeMemberProperty();
-			p.Attributes = ConvertMemberAttributes(indexerDeclaration.Modifiers, EntityType.Indexer);
+			p.Attributes = ConvertMemberAttributes(indexerDeclaration.Modifiers, SymbolKind.Indexer);
 			p.CustomAttributes.AddRange(Convert(indexerDeclaration.Attributes));
 			p.Name = "Items";
 			p.PrivateImplementationType = Convert(indexerDeclaration.PrivateImplementationType);
@@ -1148,7 +1148,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		CodeObject IAstVisitor<CodeObject>.VisitMethodDeclaration(MethodDeclaration methodDeclaration)
 		{
 			CodeMemberMethod m = new CodeMemberMethod();
-			m.Attributes = ConvertMemberAttributes(methodDeclaration.Modifiers, EntityType.Method);
+			m.Attributes = ConvertMemberAttributes(methodDeclaration.Modifiers, SymbolKind.Method);
 			
 			m.CustomAttributes.AddRange(Convert(methodDeclaration.Attributes.Where(a => a.AttributeTarget != "return")));
 			m.ReturnTypeCustomAttributes.AddRange(Convert(methodDeclaration.Attributes.Where(a => a.AttributeTarget == "return")));
@@ -1166,7 +1166,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		CodeObject IAstVisitor<CodeObject>.VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration)
 		{
 			CodeMemberMethod m = new CodeMemberMethod();
-			m.Attributes = ConvertMemberAttributes(operatorDeclaration.Modifiers, EntityType.Method);
+			m.Attributes = ConvertMemberAttributes(operatorDeclaration.Modifiers, SymbolKind.Method);
 			
 			m.CustomAttributes.AddRange(Convert(operatorDeclaration.Attributes.Where(a => a.AttributeTarget != "return")));
 			m.ReturnTypeCustomAttributes.AddRange(Convert(operatorDeclaration.Attributes.Where(a => a.AttributeTarget == "return")));
@@ -1208,7 +1208,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		CodeObject IAstVisitor<CodeObject>.VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration)
 		{
 			CodeMemberProperty p = new CodeMemberProperty();
-			p.Attributes = ConvertMemberAttributes(propertyDeclaration.Modifiers, EntityType.Property);
+			p.Attributes = ConvertMemberAttributes(propertyDeclaration.Modifiers, SymbolKind.Property);
 			p.CustomAttributes.AddRange(Convert(propertyDeclaration.Attributes));
 			p.Name = propertyDeclaration.Name;
 			p.PrivateImplementationType = Convert(propertyDeclaration.PrivateImplementationType);

ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs

@@ -3573,7 +3573,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				DocumentationReference result = new DocumentationReference();
 				if (doc.ParsedName != null) {
 					if (doc.ParsedName.Name == "<this>") {
-						result.EntityType = EntityType.Indexer;
+						result.SymbolKind = SymbolKind.Indexer;
 					} else {
 						result.MemberName = doc.ParsedName.Name;
 					}
@@ -3588,7 +3588,7 @@ namespace ICSharpCode.NRefactory.CSharp
 						}
 					}
 				} else if (doc.ParsedBuiltinType != null) {
-					result.EntityType = EntityType.TypeDefinition;
+					result.SymbolKind = SymbolKind.TypeDefinition;
 					result.DeclaringType = ConvertToType(doc.ParsedBuiltinType);
 				}
 				if (doc.ParsedParameters != null) {
@@ -3596,7 +3596,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					result.Parameters.AddRange(doc.ParsedParameters.Select(ConvertXmlDocParameter));
 				}
 				if (doc.ParsedOperator != null) {
-					result.EntityType = EntityType.Operator;
+					result.SymbolKind = SymbolKind.Operator;
 					result.OperatorType = (OperatorType)doc.ParsedOperator;
 					if (result.OperatorType == OperatorType.Implicit || result.OperatorType == OperatorType.Explicit) {
 						var returnTypeParam = result.Parameters.LastOrNullObject();

ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/InconsistentNamingIssue/InconsistentNamingIssue.cs

@@ -93,7 +93,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				
 				if (resolveResult is MemberResolveResult) {
 					var member = ((MemberResolveResult)resolveResult).Member;
-					if (member.EntityType == EntityType.Method && member.Attributes.Any(attr => attr.AttributeType.FullName == "NUnit.Framework.TestAttribute")) {
+					if (member.SymbolKind == SymbolKind.Method && member.Attributes.Any(attr => attr.AttributeType.FullName == "NUnit.Framework.TestAttribute")) {
 						if (CheckNamedResolveResult(resolveResult, node, AffectedEntity.TestMethod, identifier, accessibilty)) {
 							return;
 						}

ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/RedundantTypeCastIssue.cs

@@ -96,7 +96,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					var rr = ctx.Resolve(memberRefExpr);
 					var memberResolveResult = rr as MemberResolveResult;
 					if (memberResolveResult != null) {
-						foreach (var member in exprType.GetMembers (m => m.EntityType == memberResolveResult.Member.EntityType)) {
+						foreach (var member in exprType.GetMembers (m => m.SymbolKind == memberResolveResult.Member.SymbolKind)) {
 							if (member.IsExplicitInterfaceImplementation && member.ImplementedInterfaceMembers.Contains (memberResolveResult.Member)) {
 								return true;
 							}

ICSharpCode.NRefactory.CSharp/Refactoring/TypeSystemAstBuilder.cs

@@ -486,27 +486,27 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		{
 			if (entity == null)
 				throw new ArgumentNullException("entity");
-			switch (entity.EntityType) {
-				case EntityType.TypeDefinition:
+			switch (entity.SymbolKind) {
+				case SymbolKind.TypeDefinition:
 					return ConvertTypeDefinition((ITypeDefinition)entity);
-				case EntityType.Field:
+				case SymbolKind.Field:
 					return ConvertField((IField)entity);
-				case EntityType.Property:
+				case SymbolKind.Property:
 					return ConvertProperty((IProperty)entity);
-				case EntityType.Indexer:
+				case SymbolKind.Indexer:
 					return ConvertIndexer((IProperty)entity);
-				case EntityType.Event:
+				case SymbolKind.Event:
 					return ConvertEvent((IEvent)entity);
-				case EntityType.Method:
+				case SymbolKind.Method:
 					return ConvertMethod((IMethod)entity);
-				case EntityType.Operator:
+				case SymbolKind.Operator:
 					return ConvertOperator((IMethod)entity);
-				case EntityType.Constructor:
+				case SymbolKind.Constructor:
 					return ConvertConstructor((IMethod)entity);
-				case EntityType.Destructor:
+				case SymbolKind.Destructor:
 					return ConvertDestructor((IMethod)entity);
 				default:
-					throw new ArgumentException("Invalid value for EntityType: " + entity.EntityType);
+					throw new ArgumentException("Invalid value for SymbolKind: " + entity.SymbolKind);
 			}
 		}
 		

ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs

@@ -147,8 +147,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return false; }
 			}
 			
-			EntityType ISymbol.EntityType {
-				get { return EntityType.Operator; }
+			SymbolKind ISymbol.SymbolKind {
+				get { return SymbolKind.Operator; }
 			}
 			
 			DomRegion IEntity.Region {

ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs

@@ -1696,7 +1696,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public MemberLookup CreateMemberLookup()
 		{
 			ITypeDefinition currentTypeDefinition = this.CurrentTypeDefinition;
-			bool isInEnumMemberInitializer = this.CurrentMember != null && this.CurrentMember.EntityType == EntityType.Field
+			bool isInEnumMemberInitializer = this.CurrentMember != null && this.CurrentMember.SymbolKind == SymbolKind.Field
 				&& currentTypeDefinition != null && currentTypeDefinition.Kind == TypeKind.Enum;
 			return new MemberLookup(currentTypeDefinition, this.Compilation.MainAssembly, isInEnumMemberInitializer);
 		}

ICSharpCode.NRefactory.CSharp/Resolver/FindReferences.cs

@@ -230,45 +230,45 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				topLevelTypeDefinition = topLevelTypeDefinition.DeclaringTypeDefinition;
 			SearchScope scope;
 			SearchScope additionalScope = null;
-			switch (entity.EntityType) {
-				case EntityType.TypeDefinition:
+			switch (entity.SymbolKind) {
+				case SymbolKind.TypeDefinition:
 					scope = FindTypeDefinitionReferences((ITypeDefinition)entity, this.FindTypeReferencesEvenIfAliased, out additionalScope);
 					break;
-				case EntityType.Field:
+				case SymbolKind.Field:
 					if (entity.DeclaringTypeDefinition != null && entity.DeclaringTypeDefinition.Kind == TypeKind.Enum)
 						scope = FindMemberReferences(entity, m => new FindEnumMemberReferences((IField)m));
 					else
 						scope = FindMemberReferences(entity, m => new FindFieldReferences((IField)m));
 					break;
-				case EntityType.Property:
+				case SymbolKind.Property:
 					scope = FindMemberReferences(entity, m => new FindPropertyReferences((IProperty)m));
 					if (entity.Name == "Current")
 						additionalScope = FindEnumeratorCurrentReferences((IProperty)entity);
 					else if (entity.Name == "IsCompleted")
 						additionalScope = FindAwaiterIsCompletedReferences((IProperty)entity);
 					break;
-				case EntityType.Event:
+				case SymbolKind.Event:
 					scope = FindMemberReferences(entity, m => new FindEventReferences((IEvent)m));
 					break;
-				case EntityType.Method:
+				case SymbolKind.Method:
 					scope = GetSearchScopeForMethod((IMethod)entity);
 					break;
-				case EntityType.Indexer:
+				case SymbolKind.Indexer:
 					scope = FindIndexerReferences((IProperty)entity);
 					break;
-				case EntityType.Operator:
+				case SymbolKind.Operator:
 					scope = GetSearchScopeForOperator((IMethod)entity);
 					break;
-				case EntityType.Constructor:
+				case SymbolKind.Constructor:
 					IMethod ctor = (IMethod)entity;
 					scope = FindObjectCreateReferences(ctor);
 					additionalScope = FindChainedConstructorReferences(ctor);
 					break;
-				case EntityType.Destructor:
+				case SymbolKind.Destructor:
 					scope = GetSearchScopeForDestructor((IMethod)entity);
 					break;
 				default:
-					throw new ArgumentException("Unknown entity type " + entity.EntityType);
+					throw new ArgumentException("Unknown entity type " + entity.SymbolKind);
 			}
 			if (scope.accessibility == Accessibility.None)
 				scope.accessibility = effectiveAccessibility;

ICSharpCode.NRefactory.CSharp/Resolver/MemberLookup.cs

@@ -124,7 +124,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			// For static members and type definitions, we do not require the qualifying reference
 			// to be derived from the current class (allowProtectedAccess).
-			if (entity.IsStatic || entity.EntityType == EntityType.TypeDefinition)
+			if (entity.IsStatic || entity.SymbolKind == SymbolKind.TypeDefinition)
 				allowProtectedAccess = true;
 			
 			for (var t = currentTypeDefinition; t != null; t = t.DeclaringTypeDefinition) {
@@ -338,8 +338,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			};
 			Predicate<IUnresolvedMember> memberFilter = delegate(IUnresolvedMember entity) {
 				// NOTE: Atm destructors can be looked up with 'Finalize'
-				return entity.EntityType != EntityType.Indexer &&
-				       entity.EntityType != EntityType.Operator && 
+				return entity.SymbolKind != SymbolKind.Indexer &&
+				       entity.SymbolKind != SymbolKind.Operator && 
 				       entity.Name == name;
 			};
 			
@@ -531,7 +531,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 								}
 							} else {
 								// If the member type matches, replace it with the override
-								if (lookupGroup.NonMethod != null && lookupGroup.NonMethod.EntityType == member.EntityType) {
+								if (lookupGroup.NonMethod != null && lookupGroup.NonMethod.SymbolKind == member.SymbolKind) {
 									lookupGroup.NonMethod = member;
 									replacedVirtualMemberWithOverride = true;
 									break;

ICSharpCode.NRefactory.CSharp/Resolver/ReducedExtensionMethod.cs

@@ -267,9 +267,9 @@ namespace ICSharpCode.NRefactory.CSharp
 
 		#region IEntity implementation
 
-		public EntityType EntityType {
+		public SymbolKind SymbolKind {
 			get {
-				return baseMethod.EntityType;
+				return baseMethod.SymbolKind;
 			}
 		}
 

ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

@@ -653,20 +653,20 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		#region Track CurrentMember
 		ResolveResult IAstVisitor<ResolveResult>.VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
 		{
-			return VisitFieldOrEventDeclaration(fieldDeclaration, EntityType.Field);
+			return VisitFieldOrEventDeclaration(fieldDeclaration, SymbolKind.Field);
 		}
 		
 		ResolveResult IAstVisitor<ResolveResult>.VisitFixedFieldDeclaration(FixedFieldDeclaration fixedFieldDeclaration)
 		{
-			return VisitFieldOrEventDeclaration(fixedFieldDeclaration, EntityType.Field);
+			return VisitFieldOrEventDeclaration(fixedFieldDeclaration, SymbolKind.Field);
 		}
 		
 		ResolveResult IAstVisitor<ResolveResult>.VisitEventDeclaration(EventDeclaration eventDeclaration)
 		{
-			return VisitFieldOrEventDeclaration(eventDeclaration, EntityType.Event);
+			return VisitFieldOrEventDeclaration(eventDeclaration, SymbolKind.Event);
 		}
 		
-		ResolveResult VisitFieldOrEventDeclaration(EntityDeclaration fieldOrEventDeclaration, EntityType entityType)
+		ResolveResult VisitFieldOrEventDeclaration(EntityDeclaration fieldOrEventDeclaration, SymbolKind symbolKind)
 		{
 			//int initializerCount = fieldOrEventDeclaration.GetChildrenByRole(Roles.Variable).Count;
 			CSharpResolver oldResolver = resolver;
@@ -677,7 +677,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 						member = GetMemberFromLocation(node);
 					} else {
 						string name = ((VariableInitializer)node).Name;
-						member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, entityType, name);
+						member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, symbolKind, name);
 					}
 					resolver = resolver.WithCurrentMember(member);
 					
@@ -797,15 +797,15 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					member = GetMemberFromLocation(memberDeclaration);
 				} else {
 					// Re-discover the method:
-					EntityType entityType = memberDeclaration.EntityType;
+					SymbolKind symbolKind = memberDeclaration.SymbolKind;
 					var parameterTypes = TypeSystemConvertVisitor.GetParameterTypes(memberDeclaration.GetChildrenByRole(Roles.Parameter), InterningProvider.Dummy);
-					if (entityType == EntityType.Constructor) {
+					if (symbolKind == SymbolKind.Constructor) {
 						string name = memberDeclaration.HasModifier(Modifiers.Static) ? ".cctor" : ".ctor";
 						member = AbstractUnresolvedMember.Resolve(
-							resolver.CurrentTypeResolveContext, entityType, name,
+							resolver.CurrentTypeResolveContext, symbolKind, name,
 							parameterTypeReferences: parameterTypes);
-					} else if (entityType == EntityType.Destructor) {
-						member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, entityType, "Finalize");
+					} else if (symbolKind == SymbolKind.Destructor) {
+						member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, symbolKind, "Finalize");
 					} else {
 						string[] typeParameterNames = memberDeclaration.GetChildrenByRole(Roles.TypeParameter).Select(tp => tp.Name).ToArray();
 						AstType explicitInterfaceAstType = memberDeclaration.GetChildByRole(EntityDeclaration.PrivateImplementationTypeRole);
@@ -814,7 +814,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 							explicitInterfaceType = explicitInterfaceAstType.ToTypeReference();
 						}
 						member = AbstractUnresolvedMember.Resolve(
-							resolver.CurrentTypeResolveContext, entityType, memberDeclaration.Name,
+							resolver.CurrentTypeResolveContext, symbolKind, memberDeclaration.Name,
 							explicitInterfaceType, typeParameterNames, parameterTypes);
 					}
 				}
@@ -868,7 +868,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 						explicitInterfaceType = explicitInterfaceAstType.ToTypeReference();
 					}
 					member = AbstractUnresolvedMember.Resolve(
-						resolver.CurrentTypeResolveContext, propertyOrIndexerDeclaration.EntityType, name,
+						resolver.CurrentTypeResolveContext, propertyOrIndexerDeclaration.SymbolKind, name,
 						explicitInterfaceType, parameterTypeReferences: parameterTypeReferences);
 				}
 				// We need to use the property as current member so that indexer parameters can be resolved correctly.
@@ -918,9 +918,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					string name = eventDeclaration.Name;
 					AstType explicitInterfaceAstType = eventDeclaration.PrivateImplementationType;
 					if (explicitInterfaceAstType.IsNull) {
-						member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, EntityType.Event, name);
+						member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, SymbolKind.Event, name);
 					} else {
-						member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, EntityType.Event, name,
+						member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, SymbolKind.Event, name,
 						                                          explicitInterfaceAstType.ToTypeReference());
 					}
 				}
@@ -1169,7 +1169,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 						Name = "get_" + name,
 						Accessibility = Accessibility.Public,
 						ReturnType = returnTypeRef,
-						EntityType = EntityType.Accessor,
+						SymbolKind = SymbolKind.Accessor,
 						AccessorOwner = property
 					};
 					unresolvedProperties.Add(property);
@@ -3145,8 +3145,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				this.name = name;
 			}
 			
-			public EntityType EntityType {
-				get { return EntityType.Variable; }
+			public SymbolKind SymbolKind {
+				get { return SymbolKind.Variable; }
 			}
 			
 			public string Name {
@@ -3965,14 +3965,14 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			IType conversionOperatorReturnType = ResolveType(documentationReference.ConversionOperatorReturnType);
 			IParameter[] parameters = documentationReference.Parameters.Select(ResolveXmlDocParameter).ToArray();
 			
-			if (documentationReference.EntityType == EntityType.TypeDefinition) {
+			if (documentationReference.SymbolKind == SymbolKind.TypeDefinition) {
 				if (declaringTypeDef != null)
 					return new TypeResolveResult(declaringTypeDef);
 				else
 					return errorResult;
 			}
 			
-			if (documentationReference.EntityType == EntityType.None) {
+			if (documentationReference.SymbolKind == SymbolKind.None) {
 				// might be a type, member or ctor
 				string memberName = documentationReference.MemberName;
 				ResolveResult rr;
@@ -4010,10 +4010,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			// Indexer or operator
 			if (declaringTypeDef == null)
 				return errorResult;
-			if (documentationReference.EntityType == EntityType.Indexer) {
+			if (documentationReference.SymbolKind == SymbolKind.Indexer) {
 				var indexers = declaringTypeDef.Properties.Where(p => p.IsIndexer && !p.IsExplicitInterfaceImplementation);
 				return FindByParameters(indexers, parameters);
-			} else if (documentationReference.EntityType == EntityType.Operator) {
+			} else if (documentationReference.SymbolKind == SymbolKind.Operator) {
 				var opType = documentationReference.OperatorType;
 				string memberName = OperatorDeclaration.GetName(opType);
 				var methods = declaringTypeDef.Methods.Where(m => m.IsOperator && m.Name == memberName);

ICSharpCode.NRefactory.CSharp/Resolver/TypeInference.cs

@@ -125,7 +125,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				for (int i = 0; i < this.typeParameters.Length; i++) {
 					if (i != typeParameters[i].Index)
 						throw new ArgumentException("Type parameter has wrong index");
-					if (typeParameters[i].OwnerType != EntityType.Method)
+					if (typeParameters[i].OwnerType != SymbolKind.Method)
 						throw new ArgumentException("Type parameter must be owned by a method");
 					this.typeParameters[i] = new TP(typeParameters[i]);
 				}

ICSharpCode.NRefactory.CSharp/TypeSystem/CSharpAssembly.cs

@@ -272,8 +272,8 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 				get { return name; }
 			}
 			
-			EntityType ISymbol.EntityType {
-				get { return EntityType.Namespace; }
+			SymbolKind ISymbol.SymbolKind {
+				get { return SymbolKind.Namespace; }
 			}
 			
 			INamespace INamespace.ParentNamespace {

ICSharpCode.NRefactory.CSharp/TypeSystem/CSharpAttribute.cs

@@ -154,7 +154,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 					} else {
 						namedArgs = new List<KeyValuePair<IMember, ResolveResult>>();
 						foreach (var pair in unresolved.namedArguments) {
-							IMember member = attributeType.GetMembers(m => (m.EntityType == EntityType.Field || m.EntityType == EntityType.Property) && m.Name == pair.Key).FirstOrDefault();
+							IMember member = attributeType.GetMembers(m => (m.SymbolKind == SymbolKind.Field || m.SymbolKind == SymbolKind.Property) && m.Name == pair.Key).FirstOrDefault();
 							if (member != null) {
 								ResolveResult val = pair.Value.Resolve(context);
 								namedArgs.Add(new KeyValuePair<IMember, ResolveResult>(member, val));

ICSharpCode.NRefactory.CSharp/TypeSystem/MethodTypeParameterWithInheritedConstraints.cs

@@ -29,7 +29,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 	public sealed class MethodTypeParameterWithInheritedConstraints : DefaultUnresolvedTypeParameter
 	{
 		public MethodTypeParameterWithInheritedConstraints(int index, string name)
-			: base(EntityType.Method, index, name)
+			: base(SymbolKind.Method, index, name)
 		{
 		}
 		

ICSharpCode.NRefactory.CSharp/TypeSystem/ResolvedUsingScope.cs

@@ -166,8 +166,8 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 				get { return name; }
 			}
 			
-			EntityType ISymbol.EntityType {
-				get { return EntityType.Namespace; }
+			SymbolKind ISymbol.SymbolKind {
+				get { return SymbolKind.Namespace; }
 			}
 			
 			INamespace INamespace.ParentNamespace {

ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs

@@ -223,7 +223,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			
 			ConvertAttributes(td.Attributes, typeDeclaration.Attributes);
 			
-			ConvertTypeParameters(td.TypeParameters, typeDeclaration.TypeParameters, typeDeclaration.Constraints, EntityType.TypeDefinition);
+			ConvertTypeParameters(td.TypeParameters, typeDeclaration.TypeParameters, typeDeclaration.Constraints, SymbolKind.TypeDefinition);
 			
 			foreach (AstType baseType in typeDeclaration.BaseTypes) {
 				td.BaseTypes.Add(ConvertTypeReference(baseType, NameLookupMode.BaseTypeReference));
@@ -249,7 +249,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			ApplyModifiers(td, delegateDeclaration.Modifiers);
 			td.IsSealed = true; // delegates are implicitly sealed
 			
-			ConvertTypeParameters(td.TypeParameters, delegateDeclaration.TypeParameters, delegateDeclaration.Constraints, EntityType.TypeDefinition);
+			ConvertTypeParameters(td.TypeParameters, delegateDeclaration.TypeParameters, delegateDeclaration.Constraints, SymbolKind.TypeDefinition);
 			
 			ITypeReference returnType = ConvertTypeReference(delegateDeclaration.ReturnType);
 			List<IUnresolvedParameter> parameters = new List<IUnresolvedParameter>();
@@ -332,7 +332,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			delegateType.Members.Add(endInvoke);
 			
 			DefaultUnresolvedMethod ctor = new DefaultUnresolvedMethod(delegateType, ".ctor");
-			ctor.EntityType = EntityType.Constructor;
+			ctor.SymbolKind = SymbolKind.Constructor;
 			ctor.Accessibility = Accessibility.Public;
 			ctor.IsSynthetic = true;
 			ctor.Parameters.Add(delegateObjectParameter);
@@ -392,7 +392,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			} else {
 				ITypeReference[] typeArgs = new ITypeReference[currentTypeDefinition.TypeParameters.Count];
 				for (int i = 0; i < typeArgs.Length; i++) {
-					typeArgs[i] = TypeParameterReference.Create(EntityType.TypeDefinition, i);
+					typeArgs[i] = TypeParameterReference.Create(SymbolKind.TypeDefinition, i);
 				}
 				field.ReturnType = interningProvider.Intern(new ParameterizedTypeReference(currentTypeDefinition, typeArgs));
 			}
@@ -435,7 +435,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 					m.TypeParameters.Add(tp);
 				}
 			} else {
-				ConvertTypeParameters(m.TypeParameters, methodDeclaration.TypeParameters, methodDeclaration.Constraints, EntityType.Method);
+				ConvertTypeParameters(m.TypeParameters, methodDeclaration.TypeParameters, methodDeclaration.Constraints, SymbolKind.Method);
 			}
 			m.ReturnType = ConvertTypeReference(methodDeclaration.ReturnType);
 			ConvertAttributes(m.Attributes, methodDeclaration.Attributes.Where(s => s.AttributeTarget != "return"));
@@ -457,7 +457,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 				m.IsExplicitInterfaceImplementation = true;
 				m.ExplicitInterfaceImplementations.Add(
 					interningProvider.Intern(new DefaultMemberReference(
-						m.EntityType,
+						m.SymbolKind,
 						ConvertTypeReference(methodDeclaration.PrivateImplementationType),
 						m.Name, m.TypeParameters.Count, GetParameterTypes(m.Parameters))));
 			}
@@ -488,7 +488,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 		}
 		
 		void ConvertTypeParameters(IList<IUnresolvedTypeParameter> output, AstNodeCollection<TypeParameterDeclaration> typeParameters,
-		                           AstNodeCollection<Constraint> constraints, EntityType ownerType)
+		                           AstNodeCollection<Constraint> constraints, SymbolKind ownerType)
 		{
 			// output might be non-empty when type parameters were copied from an outer class
 			int index = output.Count;
@@ -518,7 +518,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 									continue;
 								}
 							}
-							var lookupMode = (ownerType == EntityType.TypeDefinition) ? NameLookupMode.BaseTypeReference : NameLookupMode.Type;
+							var lookupMode = (ownerType == SymbolKind.TypeDefinition) ? NameLookupMode.BaseTypeReference : NameLookupMode.Type;
 							tp.Constraints.Add(ConvertTypeReference(type, lookupMode));
 						}
 						break;
@@ -535,7 +535,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 		public override IUnresolvedEntity VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration)
 		{
 			DefaultUnresolvedMethod m = new DefaultUnresolvedMethod(currentTypeDefinition, operatorDeclaration.Name);
-			m.EntityType = EntityType.Operator;
+			m.SymbolKind = SymbolKind.Operator;
 			m.Region = MakeRegion(operatorDeclaration);
 			m.BodyRegion = MakeRegion(operatorDeclaration.Body);
 			AddXmlDocumentation(m, operatorDeclaration);
@@ -561,7 +561,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			Modifiers modifiers = constructorDeclaration.Modifiers;
 			bool isStatic = (modifiers & Modifiers.Static) != 0;
 			DefaultUnresolvedMethod ctor = new DefaultUnresolvedMethod(currentTypeDefinition, isStatic ? ".cctor" : ".ctor");
-			ctor.EntityType = EntityType.Constructor;
+			ctor.SymbolKind = SymbolKind.Constructor;
 			ctor.Region = MakeRegion(constructorDeclaration);
 			if (!constructorDeclaration.Initializer.IsNull) {
 				ctor.BodyRegion = MakeRegion(constructorDeclaration.Initializer.StartLocation, constructorDeclaration.EndLocation);
@@ -590,7 +590,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 		public override IUnresolvedEntity VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration)
 		{
 			DefaultUnresolvedMethod dtor = new DefaultUnresolvedMethod(currentTypeDefinition, "Finalize");
-			dtor.EntityType = EntityType.Destructor;
+			dtor.SymbolKind = SymbolKind.Destructor;
 			dtor.Region = MakeRegion(destructorDeclaration);
 			dtor.BodyRegion = MakeRegion(destructorDeclaration.Body);
 			dtor.Accessibility = Accessibility.Protected;
@@ -621,7 +621,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 				p.Accessibility = Accessibility.None;
 				p.IsExplicitInterfaceImplementation = true;
 				p.ExplicitInterfaceImplementations.Add(interningProvider.Intern(new DefaultMemberReference(
-					p.EntityType, ConvertTypeReference(propertyDeclaration.PrivateImplementationType), p.Name)));
+					p.SymbolKind, ConvertTypeReference(propertyDeclaration.PrivateImplementationType), p.Name)));
 			}
 			bool isExtern = propertyDeclaration.HasModifier(Modifiers.Extern);
 			p.Getter = ConvertAccessor(propertyDeclaration.Getter, p, "get_", isExtern);
@@ -634,7 +634,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 		public override IUnresolvedEntity VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration)
 		{
 			DefaultUnresolvedProperty p = new DefaultUnresolvedProperty(currentTypeDefinition, "Item");
-			p.EntityType = EntityType.Indexer;
+			p.SymbolKind = SymbolKind.Indexer;
 			p.Region = MakeRegion(indexerDeclaration);
 			p.BodyRegion = MakeBraceRegion(indexerDeclaration);
 			ApplyModifiers(p, indexerDeclaration.Modifiers);
@@ -648,7 +648,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 				p.Accessibility = Accessibility.None;
 				p.IsExplicitInterfaceImplementation = true;
 				p.ExplicitInterfaceImplementations.Add(interningProvider.Intern(new DefaultMemberReference(
-					p.EntityType, indexerDeclaration.PrivateImplementationType.ToTypeReference(), p.Name, 0, GetParameterTypes(p.Parameters))));
+					p.SymbolKind, indexerDeclaration.PrivateImplementationType.ToTypeReference(), p.Name, 0, GetParameterTypes(p.Parameters))));
 			}
 			bool isExtern = indexerDeclaration.HasModifier(Modifiers.Extern);
 			p.Getter = ConvertAccessor(indexerDeclaration.Getter, p, "get_", isExtern);
@@ -664,7 +664,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			if (accessor.IsNull)
 				return null;
 			var a = new DefaultUnresolvedMethod(currentTypeDefinition, prefix + p.Name);
-			a.EntityType = EntityType.Accessor;
+			a.SymbolKind = SymbolKind.Accessor;
 			a.AccessorOwner = p;
 			a.Accessibility = GetAccessibility(accessor.Modifiers) ?? p.Accessibility;
 			a.IsAbstract = p.IsAbstract;
@@ -680,7 +680,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			//  a) there's no body in the code
 			//  b) the member is either abstract or extern
 			a.HasBody = !(accessor.Body.IsNull && (p.IsAbstract || memberIsExtern));
-			if (p.EntityType == EntityType.Indexer) {
+			if (p.SymbolKind == SymbolKind.Indexer) {
 				foreach (var indexerParam in ((IUnresolvedProperty)p).Parameters)
 					a.Parameters.Add(indexerParam);
 			}
@@ -705,7 +705,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 				a.IsExplicitInterfaceImplementation = true;
 				Debug.Assert(p.ExplicitInterfaceImplementations.Count == 1);
 				a.ExplicitInterfaceImplementations.Add(interningProvider.Intern(new DefaultMemberReference(
-					EntityType.Accessor,
+					SymbolKind.Accessor,
 					p.ExplicitInterfaceImplementations[0].DeclaringTypeReference,
 					a.Name, 0, GetParameterTypes(a.Parameters)
 				)));
@@ -757,7 +757,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 		DefaultUnresolvedMethod CreateDefaultEventAccessor(IUnresolvedEvent ev, string name, IUnresolvedParameter valueParameter)
 		{
 			var a = new DefaultUnresolvedMethod(currentTypeDefinition, name);
-			a.EntityType = EntityType.Accessor;
+			a.SymbolKind = SymbolKind.Accessor;
 			a.AccessorOwner = ev;
 			a.Region = ev.BodyRegion;
 			a.BodyRegion = ev.BodyRegion;
@@ -788,7 +788,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 				e.Accessibility = Accessibility.None;
 				e.IsExplicitInterfaceImplementation = true;
 				e.ExplicitInterfaceImplementations.Add(interningProvider.Intern(new DefaultMemberReference(
-					e.EntityType, eventDeclaration.PrivateImplementationType.ToTypeReference(), e.Name)));
+					e.SymbolKind, eventDeclaration.PrivateImplementationType.ToTypeReference(), e.Name)));
 			}
 			
 			// custom events can't be extern; the non-custom event syntax must be used for extern events

ICSharpCode.NRefactory.ConsistencyCheck/FindReferencesConsistencyCheck.cs

@@ -84,8 +84,8 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			//return entity.FullName != "ICSharpCode.NRefactory.TypeSystem.Implementation.DefaultResolvedTypeDefinition.parts";
 		}
 		
-		Dictionary<EntityType, TimeSpan> timings = new Dictionary<EntityType, TimeSpan>();
-		Dictionary<EntityType, int> entityCount = new Dictionary<EntityType, int>();
+		Dictionary<SymbolKind, TimeSpan> timings = new Dictionary<SymbolKind, TimeSpan>();
+		Dictionary<SymbolKind, int> entityCount = new Dictionary<SymbolKind, int>();
 		
 		void TestFindReferences(IEntity entity)
 		{
@@ -119,10 +119,10 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 					                        }, CancellationToken.None);
 				}
 				w.Stop();
-				if (timings.ContainsKey(entity.EntityType)) {
-					timings[entity.EntityType] += w.Elapsed;
+				if (timings.ContainsKey(entity.SymbolKind)) {
+					timings[entity.SymbolKind] += w.Elapsed;
 				} else {
-					timings[entity.EntityType] = w.Elapsed;
+					timings[entity.SymbolKind] = w.Elapsed;
 				}
 				
 				
@@ -151,10 +151,10 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 				}
 			}
 			
-			if (entityCount.ContainsKey(entity.EntityType)) {
-				entityCount[entity.EntityType]++;
+			if (entityCount.ContainsKey(entity.SymbolKind)) {
+				entityCount[entity.SymbolKind]++;
 			} else {
-				entityCount[entity.EntityType] = 1;
+				entityCount[entity.SymbolKind] = 1;
 			}
 		}
 		

ICSharpCode.NRefactory.Tests/CSharp/Resolver/AnonymousTypeTests.cs

@@ -58,7 +58,7 @@ class Test {
 			var rr = Resolve<MemberResolveResult>(program);
 			Assert.AreEqual(TypeKind.Anonymous, rr.Member.DeclaringType.Kind);
 			Assert.AreEqual("Item1", rr.Member.Name);
-			Assert.AreEqual(EntityType.Property, rr.Member.EntityType);
+			Assert.AreEqual(SymbolKind.Property, rr.Member.SymbolKind);
 			Assert.AreEqual("System.String", rr.Member.ReturnType.FullName);
 		}
 		
@@ -68,7 +68,7 @@ class Test {
 			string program = programStart + "var q = list1.Zip(list2, (a,b) => $new { a, b }$);" + programEnd;
 			var rr = Resolve<InvocationResolveResult>(program);
 			Assert.AreEqual(TypeKind.Anonymous, rr.Type.Kind);
-			Assert.AreEqual(EntityType.Constructor, rr.Member.EntityType);
+			Assert.AreEqual(SymbolKind.Constructor, rr.Member.SymbolKind);
 			Assert.AreEqual(rr.Type, rr.Member.DeclaringType);
 			Assert.AreEqual(0, rr.Arguments.Count);
 			Assert.AreEqual(2, rr.InitializerStatements.Count);

ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConversionsTest.cs

@@ -257,9 +257,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void UnconstrainedTypeParameter()
 		{
-			ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T");
-			ITypeParameter t2 = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 1, "T2");
-			ITypeParameter tm = new DefaultTypeParameter(compilation, EntityType.Method, 0, "TM");
+			ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T");
+			ITypeParameter t2 = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 1, "T2");
+			ITypeParameter tm = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "TM");
 			
 			Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t));
 			Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object)));
@@ -276,7 +276,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void TypeParameterWithReferenceTypeConstraint()
 		{
-			ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T", hasReferenceTypeConstraint: true);
+			ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T", hasReferenceTypeConstraint: true);
 			
 			Assert.AreEqual(C.NullLiteralConversion, conversions.ImplicitConversion(SpecialType.NullType, t));
 			Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object)));
@@ -287,7 +287,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void TypeParameterWithValueTypeConstraint()
 		{
-			ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T", hasValueTypeConstraint: true);
+			ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T", hasValueTypeConstraint: true);
 			
 			Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t));
 			Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object)));
@@ -298,7 +298,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void TypeParameterWithClassConstraint()
 		{
-			ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T",
+			ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T",
 			                                            constraints: new[] { compilation.FindType(typeof(StringComparer)) });
 			
 			Assert.AreEqual(C.NullLiteralConversion,
@@ -320,7 +320,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void TypeParameterWithInterfaceConstraint()
 		{
-			ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T",
+			ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T",
 			                                            constraints: new [] { compilation.FindType(typeof(IList)) });
 			
 			Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t));
@@ -500,13 +500,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			var b = new DefaultUnresolvedTypeDefinition(string.Empty, "B");
 			// interface A<in U>
 			a.Kind = TypeKind.Interface;
-			a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "U") { Variance = VarianceModifier.Contravariant });
+			a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "U") { Variance = VarianceModifier.Contravariant });
 			// interface B<X> : A<A<B<X>>> { }
-			b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "X"));
+			b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "X"));
 			b.BaseTypes.Add(new ParameterizedTypeReference(
 				a, new[] { new ParameterizedTypeReference(
 					a, new [] { new ParameterizedTypeReference(
-						b, new [] { new TypeParameterReference(EntityType.TypeDefinition, 0) }
+						b, new [] { new TypeParameterReference(SymbolKind.TypeDefinition, 0) }
 					) } ) }));
 			
 			ICompilation compilation = TypeSystemHelper.CreateCompilation(a, b);

ICSharpCode.NRefactory.Tests/CSharp/Resolver/OverloadResolutionTests.cs

@@ -177,28 +177,28 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			
 			// static void Foo<T>(T? ignored = default(T?)) where T : struct
 			var m1 = MakeUnresolvedMethod();
-			m1.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.Method, 0, "T") { HasValueTypeConstraint = true });
+			m1.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.Method, 0, "T") { HasValueTypeConstraint = true });
 			m1.Parameters.Add(MakeOptionalParameter(
-				NullableType.Create(new TypeParameterReference(EntityType.Method, 0)),
+				NullableType.Create(new TypeParameterReference(SymbolKind.Method, 0)),
 				"ignored"
 			));
 			
 			// class ClassConstraint<T> where T : class {}
 			var classConstraint = new DefaultUnresolvedTypeDefinition(string.Empty, "ClassConstraint");
-			classConstraint.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T") { HasReferenceTypeConstraint = true });
+			classConstraint.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T") { HasReferenceTypeConstraint = true });
 			
 			// static void Foo<T>(ClassConstraint<T> ignored = default(ClassConstraint<T>))
 			// where T : class
 			var m2 = MakeUnresolvedMethod();
-			m2.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.Method, 0, "T") { HasReferenceTypeConstraint = true });
+			m2.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.Method, 0, "T") { HasReferenceTypeConstraint = true });
 			m2.Parameters.Add(MakeOptionalParameter(
-				new ParameterizedTypeReference(classConstraint, new[] { new TypeParameterReference(EntityType.Method, 0) }),
+				new ParameterizedTypeReference(classConstraint, new[] { new TypeParameterReference(SymbolKind.Method, 0) }),
 				"ignored"
 			));
 			
 			// static void Foo<T>()
 			var m3 = MakeUnresolvedMethod();
-			m3.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.Method, 0, "T"));
+			m3.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.Method, 0, "T"));
 			
 			ICompilation compilation = TypeSystemHelper.CreateCompilation(classConstraint);
 			var context = new SimpleTypeResolveContext(compilation.MainAssembly);

ICSharpCode.NRefactory.Tests/CSharp/Resolver/ResolveAtLocationTests.cs

@@ -130,7 +130,7 @@ class A { public A() : ba$se() {} }");
 			var rr = ResolveAtLocation<CSharpInvocationResolveResult>(
 				"using System.Collections.Generic;" +
 				"public class A { int M(List<int> a) { return a$[1]; } }");
-			Assert.AreEqual(EntityType.Indexer, rr.Member.EntityType);
+			Assert.AreEqual(SymbolKind.Indexer, rr.Member.SymbolKind);
 		}
 
 		[Test]

ICSharpCode.NRefactory.Tests/CSharp/Resolver/TypeInferenceTests.cs

@@ -55,7 +55,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void ArrayToEnumerable()
 		{
-			ITypeParameter tp = new DefaultTypeParameter(compilation, EntityType.Method, 0, "T");
+			ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T");
 			IType stringType = compilation.FindType(KnownTypeCode.String);
 			ITypeDefinition enumerableType = compilation.FindType(KnownTypeCode.IEnumerableOfT).GetDefinition();
 			
@@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void ArrayToReadOnlyList()
 		{
-			ITypeParameter tp = new DefaultTypeParameter(compilation, EntityType.Method, 0, "T");
+			ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T");
 			IType stringType = compilation.FindType(KnownTypeCode.String);
 			ITypeDefinition readOnlyListType = compilation.FindType(KnownTypeCode.IReadOnlyListOfT).GetDefinition();
 			if (readOnlyListType == null)
@@ -91,7 +91,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void EnumerableToArrayInContravariantType()
 		{
-			ITypeParameter tp = new DefaultTypeParameter(compilation, EntityType.Method, 0, "T");
+			ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T");
 			IType stringType = compilation.FindType(KnownTypeCode.String);
 			ITypeDefinition enumerableType = compilation.FindType(typeof(IEnumerable<>)).GetDefinition();
 			ITypeDefinition comparerType = compilation.FindType(typeof(IComparer<>)).GetDefinition();
@@ -113,7 +113,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public void InferFromObjectAndFromNullLiteral()
 		{
 			// M<T>(T a, T b);
-			ITypeParameter tp = new DefaultTypeParameter(compilation, EntityType.Method, 0, "T");
+			ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T");
 			
 			// M(new object(), null);
 			bool success;
@@ -129,7 +129,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void ArrayToListWithArrayCovariance()
 		{
-			ITypeParameter tp = new DefaultTypeParameter(compilation, EntityType.Method, 0, "T");
+			ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T");
 			IType objectType = compilation.FindType(KnownTypeCode.Object);
 			IType stringType = compilation.FindType(KnownTypeCode.String);
 			ITypeDefinition listType = compilation.FindType(KnownTypeCode.IListOfT).GetDefinition();
@@ -151,7 +151,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void IEnumerableCovarianceWithDynamic()
 		{
-			ITypeParameter tp = new DefaultTypeParameter(compilation, EntityType.Method, 0, "T");
+			ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T");
 			var ienumerableOfT = new ParameterizedType(compilation.FindType(typeof(IEnumerable<>)).GetDefinition(), new[] { tp });
 			var ienumerableOfString = compilation.FindType(typeof(IEnumerable<string>));
 			var ienumerableOfDynamic = compilation.FindType(typeof(IEnumerable<ReflectionHelper.Dynamic>));
@@ -179,8 +179,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			// static void M<A, B>(Func<A, B> f) {}
 			// M(int.Parse); // type inference fails
-			var A = new DefaultTypeParameter(compilation, EntityType.Method, 0, "A");
-			var B = new DefaultTypeParameter(compilation, EntityType.Method, 1, "B");
+			var A = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "A");
+			var B = new DefaultTypeParameter(compilation, SymbolKind.Method, 1, "B");
 			
 			IType declType = compilation.FindType(typeof(int));
 			var methods = new MethodListWithDeclaringType(declType, declType.GetMethods(m => m.Name == "Parse"));
@@ -199,7 +199,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			// static void M<T>(Func<T> f) {}
 			// M(Console.ReadKey); // type inference produces ConsoleKeyInfo
 			
-			var T = new DefaultTypeParameter(compilation, EntityType.Method, 0, "T");
+			var T = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T");
 			
 			IType declType = compilation.FindType(typeof(Console));
 			var methods = new MethodListWithDeclaringType(declType, declType.GetMethods(m => m.Name == "ReadKey"));
@@ -281,9 +281,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public void TestLambdaInference()
 		{
 			ITypeParameter[] typeParameters = {
-				new DefaultTypeParameter(compilation, EntityType.Method, 0, "X"),
-				new DefaultTypeParameter(compilation, EntityType.Method, 1, "Y"),
-				new DefaultTypeParameter(compilation, EntityType.Method, 2, "Z")
+				new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "X"),
+				new DefaultTypeParameter(compilation, SymbolKind.Method, 1, "Y"),
+				new DefaultTypeParameter(compilation, SymbolKind.Method, 2, "Z")
 			};
 			IType[] parameterTypes = {
 				typeParameters[0],
@@ -311,8 +311,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void ConvertAllLambdaInference()
 		{
-			ITypeParameter[] classTypeParameters  = { new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T") };
-			ITypeParameter[] methodTypeParameters = { new DefaultTypeParameter(compilation, EntityType.Method, 0, "R") };
+			ITypeParameter[] classTypeParameters  = { new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T") };
+			ITypeParameter[] methodTypeParameters = { new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "R") };
 			
 			IType[] parameterTypes = {
 				new ParameterizedType(compilation.FindType(typeof(Converter<,>)).GetDefinition(),

ICSharpCode.NRefactory.Tests/Documentation/CSharpCrefParserTests.cs

@@ -44,7 +44,7 @@ namespace ICSharpCode.NRefactory.Documentation
 			ParseUtilCSharp.AssertDocumentationReference(
 				"this",
 				new DocumentationReference {
-					EntityType = EntityType.Indexer
+					SymbolKind = SymbolKind.Indexer
 				});
 		}
 		
@@ -55,7 +55,7 @@ namespace ICSharpCode.NRefactory.Documentation
 			ParseUtilCSharp.AssertDocumentationReference(
 				"this[int]",
 				new DocumentationReference {
-					EntityType = EntityType.Indexer,
+					SymbolKind = SymbolKind.Indexer,
 					HasParameterList = true,
 					Parameters = { new ParameterDeclaration { Type = new PrimitiveType("int") } }
 				});
@@ -67,7 +67,7 @@ namespace ICSharpCode.NRefactory.Documentation
 			ParseUtilCSharp.AssertDocumentationReference(
 				"List{T}.this",
 				new DocumentationReference {
-					EntityType = EntityType.Indexer,
+					SymbolKind = SymbolKind.Indexer,
 					DeclaringType = new SimpleType("List", new SimpleType("T"))
 				});
 		}
@@ -101,7 +101,7 @@ namespace ICSharpCode.NRefactory.Documentation
 			ParseUtilCSharp.AssertDocumentationReference(
 				"int",
 				new DocumentationReference {
-					EntityType = EntityType.TypeDefinition,
+					SymbolKind = SymbolKind.TypeDefinition,
 					DeclaringType = new PrimitiveType("int")
 				});
 		}
@@ -211,7 +211,7 @@ namespace ICSharpCode.NRefactory.Documentation
 			ParseUtilCSharp.AssertDocumentationReference(
 				"operator +",
 				new DocumentationReference {
-					EntityType = EntityType.Operator,
+					SymbolKind = SymbolKind.Operator,
 					OperatorType = OperatorType.Addition
 				});
 		}
@@ -224,7 +224,7 @@ namespace ICSharpCode.NRefactory.Documentation
 				"Test.operator +",
 				new DocumentationReference {
 					DeclaringType = new SimpleType("Test"),
-					EntityType = EntityType.Operator,
+					SymbolKind = SymbolKind.Operator,
 					OperatorType = OperatorType.Addition
 				});
 		}
@@ -235,7 +235,7 @@ namespace ICSharpCode.NRefactory.Documentation
 			ParseUtilCSharp.AssertDocumentationReference(
 				"operator +(Test, int)",
 				new DocumentationReference {
-					EntityType = EntityType.Operator,
+					SymbolKind = SymbolKind.Operator,
 					OperatorType = OperatorType.Addition,
 					HasParameterList = true,
 					Parameters = {
@@ -250,7 +250,7 @@ namespace ICSharpCode.NRefactory.Documentation
 			ParseUtilCSharp.AssertDocumentationReference(
 				"implicit operator int",
 				new DocumentationReference {
-					EntityType = EntityType.Operator,
+					SymbolKind = SymbolKind.Operator,
 					OperatorType = OperatorType.Implicit,
 					ConversionOperatorReturnType = new PrimitiveType("int")
 				});
@@ -262,7 +262,7 @@ namespace ICSharpCode.NRefactory.Documentation
 			ParseUtilCSharp.AssertDocumentationReference(
 				"explicit operator int(Test)",
 				new DocumentationReference {
-					EntityType = EntityType.Operator,
+					SymbolKind = SymbolKind.Operator,
 					OperatorType = OperatorType.Explicit,
 					ConversionOperatorReturnType = new PrimitiveType("int"),
 					HasParameterList = true,
@@ -279,7 +279,7 @@ namespace ICSharpCode.NRefactory.Documentation
 			ParseUtilCSharp.AssertDocumentationReference(
 				"Test.explicit operator int(Test)",
 				new DocumentationReference {
-					EntityType = EntityType.Operator,
+					SymbolKind = SymbolKind.Operator,
 					OperatorType = OperatorType.Explicit,
 					DeclaringType = new SimpleType("Test"),
 					ConversionOperatorReturnType = new PrimitiveType("int"),

ICSharpCode.NRefactory.Tests/Documentation/IDStringTests.cs

@@ -160,7 +160,7 @@ namespace Acme
 }";
 			Init(program);
 			ITypeDefinition widget = GetTypeDefinition("Acme", "Widget");
-			Assert.AreEqual("M:Acme.Widget.Finalize", widget.Methods.Single(m => m.EntityType == EntityType.Destructor).Documentation.ToString());
+			Assert.AreEqual("M:Acme.Widget.Finalize", widget.Methods.Single(m => m.SymbolKind == SymbolKind.Destructor).Documentation.ToString());
 		}
 		
 		[Test]
@@ -200,7 +200,7 @@ namespace Acme
 }";
 			Init(program);
 			ITypeDefinition widget = GetTypeDefinition("Acme", "Widget");
-			Assert.AreEqual("M:Acme.Widget.NestedClass.M(System.Int32)", widget.NestedTypes.Single().Methods.Single(m => m.EntityType == EntityType.Method).Documentation.ToString());
+			Assert.AreEqual("M:Acme.Widget.NestedClass.M(System.Int32)", widget.NestedTypes.Single().Methods.Single(m => m.SymbolKind == SymbolKind.Method).Documentation.ToString());
 			Assert.AreEqual("M:Acme.Widget.M0", widget.Methods.Single(m => m.Name == "M0").Documentation.ToString());
 			Assert.AreEqual("M:Acme.Widget.M1(System.Char,System.Single@,Acme.ValueType@)",
 			                widget.Methods.Single(m => m.Name == "M1").Documentation.ToString());
@@ -230,7 +230,7 @@ namespace Acme
 			Init("class A<X> { class B<Y> { void M(A<Y>.B<X> a) { } } }");
 			ITypeDefinition b = GetTypeDefinition("", "A", 1).NestedTypes.Single();
 			Assert.AreEqual("T:A`1.B`1", b.Documentation.ToString());
-			Assert.AreEqual("M:A`1.B`1.M(A{`1}.B{`0})", b.Methods.Single(m => m.EntityType == EntityType.Method).Documentation.ToString());
+			Assert.AreEqual("M:A`1.B`1.M(A{`1}.B{`0})", b.Methods.Single(m => m.SymbolKind == SymbolKind.Method).Documentation.ToString());
 		}
 		
 		[Test]
@@ -286,7 +286,7 @@ namespace Acme
 }";
 			Init(program);
 			ITypeDefinition widget = GetTypeDefinition("Acme", "Widget");
-			Assert.AreEqual("M:Acme.Widget.op_UnaryPlus(Acme.Widget)", widget.Methods.Single(m => m.EntityType == EntityType.Operator).Documentation.ToString());
+			Assert.AreEqual("M:Acme.Widget.op_UnaryPlus(Acme.Widget)", widget.Methods.Single(m => m.SymbolKind == SymbolKind.Operator).Documentation.ToString());
 		}
 		
 		[Test]
@@ -302,7 +302,7 @@ namespace Acme
 }";
 			Init(program);
 			ITypeDefinition widget = GetTypeDefinition("Acme", "Widget");
-			Assert.AreEqual("M:Acme.Widget.op_Addition(Acme.Widget,Acme.Widget)", widget.Methods.Single(m => m.EntityType == EntityType.Operator).Documentation.ToString());
+			Assert.AreEqual("M:Acme.Widget.op_Addition(Acme.Widget,Acme.Widget)", widget.Methods.Single(m => m.SymbolKind == SymbolKind.Operator).Documentation.ToString());
 		}
 		
 		[Test]
@@ -319,8 +319,8 @@ namespace Acme
 }";
 			Init(program);
 			ITypeDefinition widget = GetTypeDefinition("Acme", "Widget");
-			Assert.AreEqual("M:Acme.Widget.op_Explicit(Acme.Widget)~System.Int32", widget.Methods.First(m => m.EntityType == EntityType.Operator).Documentation.ToString());
-			Assert.AreEqual("M:Acme.Widget.op_Implicit(Acme.Widget)~System.Int64", widget.Methods.Last(m => m.EntityType == EntityType.Operator).Documentation.ToString());
+			Assert.AreEqual("M:Acme.Widget.op_Explicit(Acme.Widget)~System.Int32", widget.Methods.First(m => m.SymbolKind == SymbolKind.Operator).Documentation.ToString());
+			Assert.AreEqual("M:Acme.Widget.op_Implicit(Acme.Widget)~System.Int64", widget.Methods.Last(m => m.SymbolKind == SymbolKind.Operator).Documentation.ToString());
 		}
 		
 		[Test]

ICSharpCode.NRefactory.Tests/TypeSystem/GetAllBaseTypesTest.cs

@@ -158,8 +158,8 @@ namespace System.Collections.Generic {
 		{
 			// class C<X> : C<C<X>> {}
 			var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
-			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "X"));
-			c.BaseTypes.Add(new ParameterizedTypeReference(c, new [] { new ParameterizedTypeReference(c, new [] { new TypeParameterReference(EntityType.TypeDefinition, 0) }) }));
+			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "X"));
+			c.BaseTypes.Add(new ParameterizedTypeReference(c, new [] { new ParameterizedTypeReference(c, new [] { new TypeParameterReference(SymbolKind.TypeDefinition, 0) }) }));
 			compilation = TypeSystemHelper.CreateCompilation(c);
 			ITypeDefinition resolvedC = Resolve(c);
 			Assert.AreEqual(new [] { resolvedC }, resolvedC.GetAllBaseTypes().ToArray());

ICSharpCode.NRefactory.Tests/TypeSystem/GetMembersTests.cs

@@ -82,11 +82,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			// class A<X> { class B<Y> { } }
 			DefaultUnresolvedTypeDefinition a = new DefaultUnresolvedTypeDefinition(string.Empty, "A");
-			a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "X"));
+			a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "X"));
 			
 			DefaultUnresolvedTypeDefinition b = new DefaultUnresolvedTypeDefinition(a, "B");
 			b.TypeParameters.Add(a.TypeParameters[0]);
-			b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "Y"));
+			b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "Y"));
 			
 			a.NestedTypes.Add(b);
 			

ICSharpCode.NRefactory.Tests/TypeSystem/TypeParameterTests.cs

@@ -32,9 +32,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			// class C<T, U> where T : class where U : T
 			var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
-			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T") { HasReferenceTypeConstraint = true });
-			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U") {
-			                     	Constraints = { new TypeParameterReference(EntityType.TypeDefinition, 0) }
+			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T") { HasReferenceTypeConstraint = true });
+			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "U") {
+			                     	Constraints = { new TypeParameterReference(SymbolKind.TypeDefinition, 0) }
 			                     });
 			
 			ITypeDefinition resolvedC = TypeSystemHelper.CreateCompilationAndResolve(c);
@@ -49,10 +49,10 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			// class C<T, U> where T : class where U : struct, T
 			var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
-			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T") { HasReferenceTypeConstraint = true });
-			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U") {
+			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T") { HasReferenceTypeConstraint = true });
+			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "U") {
 			                     	HasValueTypeConstraint = true,
-			                     	Constraints = { new TypeParameterReference(EntityType.TypeDefinition, 0) }
+			                     	Constraints = { new TypeParameterReference(SymbolKind.TypeDefinition, 0) }
 			                     });
 			
 			ITypeDefinition resolvedC = TypeSystemHelper.CreateCompilationAndResolve(c);
@@ -67,11 +67,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			// class C<T, U> where T : List<string> where U : T
 			var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
-			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T") {
+			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T") {
 			                     	Constraints = { typeof(List<string>).ToTypeReference() }
 			                     });
-			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U") {
-			                     	Constraints = { new TypeParameterReference(EntityType.TypeDefinition, 0) }
+			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "U") {
+			                     	Constraints = { new TypeParameterReference(SymbolKind.TypeDefinition, 0) }
 			                     });
 			
 			ITypeDefinition resolvedC = TypeSystemHelper.CreateCompilationAndResolve(c);
@@ -87,10 +87,10 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			// class C<T, U> { void M<X>() {} }
 			
 			var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
-			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T"));
-			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U"));
+			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T"));
+			c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "U"));
 			var m = new DefaultUnresolvedMethod(c, "M");
-			m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.Method, 0, "X"));
+			m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.Method, 0, "X"));
 			c.Members.Add(m);
 			
 			var resolvedC1 = TypeSystemHelper.CreateCompilationAndResolve(c);

ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs

@@ -67,7 +67,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Assert.AreEqual(typeof(SimplePublicClass).FullName + ".Method", method.FullName);
 			Assert.AreSame(c, method.DeclaringType);
 			Assert.AreEqual(Accessibility.Public, method.Accessibility);
-			Assert.AreEqual(EntityType.Method, method.EntityType);
+			Assert.AreEqual(SymbolKind.Method, method.SymbolKind);
 			Assert.IsFalse(method.IsVirtual);
 			Assert.IsFalse(method.IsStatic);
 			Assert.AreEqual(0, method.Parameters.Count);
@@ -161,8 +161,8 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		public void TestClassTypeParameters()
 		{
 			var testClass = GetTypeDefinition(typeof(GenericClass<,>));
-			Assert.AreEqual(EntityType.TypeDefinition, testClass.TypeParameters[0].OwnerType);
-			Assert.AreEqual(EntityType.TypeDefinition, testClass.TypeParameters[1].OwnerType);
+			Assert.AreEqual(SymbolKind.TypeDefinition, testClass.TypeParameters[0].OwnerType);
+			Assert.AreEqual(SymbolKind.TypeDefinition, testClass.TypeParameters[1].OwnerType);
 			Assert.AreSame(testClass.TypeParameters[1], testClass.TypeParameters[0].DirectBaseTypes.First());
 		}
 		
@@ -174,8 +174,8 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			IMethod m = testClass.Methods.Single(me => me.Name == "TestMethod");
 			Assert.AreEqual("K", m.TypeParameters[0].Name);
 			Assert.AreEqual("V", m.TypeParameters[1].Name);
-			Assert.AreEqual(EntityType.Method, m.TypeParameters[0].OwnerType);
-			Assert.AreEqual(EntityType.Method, m.TypeParameters[1].OwnerType);
+			Assert.AreEqual(SymbolKind.Method, m.TypeParameters[0].OwnerType);
+			Assert.AreEqual(SymbolKind.Method, m.TypeParameters[1].OwnerType);
 			
 			Assert.AreEqual("System.IComparable`1[[``1]]", m.TypeParameters[0].DirectBaseTypes.First().ReflectionName);
 			Assert.AreSame(m.TypeParameters[0], m.TypeParameters[1].DirectBaseTypes.First());
@@ -188,7 +188,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			
 			IMethod m = testClass.Methods.Single(me => me.Name == "GetIndex");
 			Assert.AreEqual("T", m.TypeParameters[0].Name);
-			Assert.AreEqual(EntityType.Method, m.TypeParameters[0].OwnerType);
+			Assert.AreEqual(SymbolKind.Method, m.TypeParameters[0].OwnerType);
 			Assert.AreSame(m, m.TypeParameters[0].Owner);
 			
 			ParameterizedType constraint = (ParameterizedType)m.TypeParameters[0].DirectBaseTypes.First();
@@ -210,7 +210,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			));
 			
 			Assert.AreEqual("T", m.TypeParameters[0].Name);
-			Assert.AreEqual(EntityType.Method, m.TypeParameters[0].OwnerType);
+			Assert.AreEqual(SymbolKind.Method, m.TypeParameters[0].OwnerType);
 			Assert.AreSame(m, m.TypeParameters[0].Owner);
 			
 			ParameterizedType constraint = (ParameterizedType)m.TypeParameters[0].DirectBaseTypes.First();
@@ -377,7 +377,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			var testClass = GetTypeDefinition(typeof(PropertyTest));
 			IProperty p = testClass.Properties.Single(pr => pr.IsIndexer);
 			Assert.IsTrue(p.CanGet);
-			Assert.AreEqual(EntityType.Accessor, p.Getter.EntityType);
+			Assert.AreEqual(SymbolKind.Accessor, p.Getter.SymbolKind);
 			Assert.AreEqual("get_Item", p.Getter.Name);
 			Assert.AreEqual(Accessibility.Public, p.Getter.Accessibility);
 			Assert.AreEqual(new[] { "index" }, p.Getter.Parameters.Select(x => x.Name).ToArray());
@@ -391,7 +391,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			var testClass = GetTypeDefinition(typeof(PropertyTest));
 			IProperty p = testClass.Properties.Single(pr => pr.IsIndexer);
 			Assert.IsTrue(p.CanSet);
-			Assert.AreEqual(EntityType.Accessor, p.Setter.EntityType);
+			Assert.AreEqual(SymbolKind.Accessor, p.Setter.SymbolKind);
 			Assert.AreEqual("set_Item", p.Setter.Name);
 			Assert.AreEqual(Accessibility.Public, p.Setter.Accessibility);
 			Assert.AreEqual(new[] { "index", "value" }, p.Setter.Parameters.Select(x => x.Name).ToArray());
@@ -1052,7 +1052,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		public void ExplicitIndexerImplementationReturnsTheCorrectMembers() {
 			ITypeDefinition type = GetTypeDefinition(typeof(ClassThatImplementsIndexersExplicitly));
 
-			Assert.That(type.Properties.All(p => p.EntityType == EntityType.Indexer));
+			Assert.That(type.Properties.All(p => p.SymbolKind == SymbolKind.Indexer));
 			Assert.That(type.Properties.All(p => p.ImplementedInterfaceMembers.Count == 1));
 			Assert.That(type.Properties.All(p => p.Getter.ImplementedInterfaceMembers.Count == 1));
 			Assert.That(type.Properties.All(p => p.Setter.ImplementedInterfaceMembers.Count == 1));

ICSharpCode.NRefactory/Documentation/IdStringMemberReference.cs

@@ -37,21 +37,21 @@ namespace ICSharpCode.NRefactory.Documentation
 		
 		bool CanMatch(IUnresolvedMember member)
 		{
-			switch (member.EntityType) {
-				case EntityType.Field:
+			switch (member.SymbolKind) {
+				case SymbolKind.Field:
 					return memberType == 'F';
-				case EntityType.Property:
-				case EntityType.Indexer:
+				case SymbolKind.Property:
+				case SymbolKind.Indexer:
 					return memberType == 'P';
-				case EntityType.Event:
+				case SymbolKind.Event:
 					return memberType == 'E';
-				case EntityType.Method:
-				case EntityType.Operator:
-				case EntityType.Constructor:
-				case EntityType.Destructor:
+				case SymbolKind.Method:
+				case SymbolKind.Operator:
+				case SymbolKind.Constructor:
+				case SymbolKind.Destructor:
 					return memberType == 'M';
 				default:
-					throw new NotSupportedException(member.EntityType.ToString());
+					throw new NotSupportedException(member.SymbolKind.ToString());
 			}
 		}
 		

ICSharpCode.NRefactory/Documentation/IdStringProvider.cs

@@ -38,19 +38,19 @@ namespace ICSharpCode.NRefactory.Documentation
 		public static string GetIdString(this IEntity entity)
 		{
 			StringBuilder b = new StringBuilder();
-			switch (entity.EntityType) {
-				case EntityType.TypeDefinition:
+			switch (entity.SymbolKind) {
+				case SymbolKind.TypeDefinition:
 					b.Append("T:");
 					AppendTypeName(b, (ITypeDefinition)entity, false);
 					return b.ToString();
-				case EntityType.Field:
+				case SymbolKind.Field:
 					b.Append("F:");
 					break;
-				case EntityType.Property:
-				case EntityType.Indexer:
+				case SymbolKind.Property:
+				case SymbolKind.Indexer:
 					b.Append("P:");
 					break;
-				case EntityType.Event:
+				case SymbolKind.Event:
 					b.Append("E:");
 					break;
 				default:
@@ -80,7 +80,7 @@ namespace ICSharpCode.NRefactory.Documentation
 				}
 				b.Append(')');
 			}
-			if (member.EntityType == EntityType.Operator && (member.Name == "op_Implicit" || member.Name == "op_Explicit")) {
+			if (member.SymbolKind == SymbolKind.Operator && (member.Name == "op_Implicit" || member.Name == "op_Explicit")) {
 				b.Append('~');
 				AppendTypeName(b, member.ReturnType, false);
 			}
@@ -110,7 +110,7 @@ namespace ICSharpCode.NRefactory.Documentation
 						b.Append(tp.Name);
 					} else {
 						b.Append('`');
-						if (tp.OwnerType == EntityType.Method)
+						if (tp.OwnerType == SymbolKind.Method)
 							b.Append('`');
 						b.Append(tp.Index);
 					}
@@ -285,11 +285,11 @@ namespace ICSharpCode.NRefactory.Documentation
 					// method type parameter reference
 					pos++;
 					int index = ReflectionHelper.ReadTypeParameterCount(reflectionTypeName, ref pos);
-					result = TypeParameterReference.Create(EntityType.Method, index);
+					result = TypeParameterReference.Create(SymbolKind.Method, index);
 				} else {
 					// class type parameter reference
 					int index = ReflectionHelper.ReadTypeParameterCount(reflectionTypeName, ref pos);
-					result = TypeParameterReference.Create(EntityType.TypeDefinition, index);
+					result = TypeParameterReference.Create(SymbolKind.TypeDefinition, index);
 				}
 			} else {
 				// not a type parameter reference: read the actual type name

ICSharpCode.NRefactory/Semantics/MemberResolveResult.cs

@@ -39,7 +39,7 @@ namespace ICSharpCode.NRefactory.Semantics
 		readonly bool isVirtualCall;
 		
 		public MemberResolveResult(ResolveResult targetResult, IMember member, IType returnTypeOverride = null)
-			: base(returnTypeOverride ?? (member.EntityType == EntityType.Constructor ? member.DeclaringType : member.ReturnType))
+			: base(returnTypeOverride ?? (member.SymbolKind == SymbolKind.Constructor ? member.DeclaringType : member.ReturnType))
 		{
 			this.targetResult = targetResult;
 			this.member = member;
@@ -55,7 +55,7 @@ namespace ICSharpCode.NRefactory.Semantics
 		}
 		
 		public MemberResolveResult(ResolveResult targetResult, IMember member, bool isVirtualCall, IType returnTypeOverride = null)
-			: base(returnTypeOverride ?? (member.EntityType == EntityType.Constructor ? member.DeclaringType : member.ReturnType))
+			: base(returnTypeOverride ?? (member.SymbolKind == SymbolKind.Constructor ? member.DeclaringType : member.ReturnType))
 		{
 			this.targetResult = targetResult;
 			this.member = member;

ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs

@@ -397,7 +397,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				return interningProvider.Intern(new ParameterizedTypeReference(baseType, para));
 			} else if (type is GenericParameter) {
 				GenericParameter typeGP = (GenericParameter)type;
-				return TypeParameterReference.Create(typeGP.Owner is MethodDefinition ? EntityType.Method : EntityType.TypeDefinition, typeGP.Position);
+				return TypeParameterReference.Create(typeGP.Owner is MethodDefinition ? SymbolKind.Method : SymbolKind.TypeDefinition, typeGP.Position);
 			} else if (type.IsNested) {
 				ITypeReference typeRef = CreateType(type.DeclaringType, typeAttributes, ref typeIndex);
 				int partTypeParameterCount;
@@ -1271,14 +1271,14 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			
 			public KeyValuePair<IMember, ResolveResult> ReadNamedArg(IType attributeType)
 			{
-				EntityType memberType;
+				SymbolKind memberType;
 				var b = ReadByte();
 				switch (b) {
 					case 0x53:
-						memberType = EntityType.Field;
+						memberType = SymbolKind.Field;
 						break;
 					case 0x54:
-						memberType = EntityType.Property;
+						memberType = SymbolKind.Property;
 						break;
 					default:
 						throw new NotSupportedException(string.Format("Custom member type 0x{0:x} is not supported.", b));
@@ -1288,7 +1288,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				ResolveResult val = ReadFixedArg(type);
 				IMember member = null;
 				// Use last matching member, as GetMembers() returns members from base types first.
-				foreach (IMember m in attributeType.GetMembers(m => m.EntityType == memberType && m.Name == name)) {
+				foreach (IMember m in attributeType.GetMembers(m => m.SymbolKind == memberType && m.Name == name)) {
 					if (m.ReturnType.Equals(type))
 						member = m;
 				}
@@ -1543,7 +1543,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				if (typeDefinition.GenericParameters[i].Position != i)
 					throw new InvalidOperationException("g.Position != i");
 				typeParameters.Add(new DefaultUnresolvedTypeParameter(
-					EntityType.TypeDefinition, i, typeDefinition.GenericParameters[i].Name));
+					SymbolKind.TypeDefinition, i, typeDefinition.GenericParameters[i].Name));
 			}
 		}
 		
@@ -1698,12 +1698,12 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			if (typeDefinition.HasMethods) {
 				foreach (MethodDefinition method in typeDefinition.Methods) {
 					if (IsVisible(method.Attributes) && !IsAccessor(method.SemanticsAttributes)) {
-						EntityType type = EntityType.Method;
+						SymbolKind type = SymbolKind.Method;
 						if (method.IsSpecialName) {
 							if (method.IsConstructor)
-								type = EntityType.Constructor;
+								type = SymbolKind.Constructor;
 							else if (method.Name.StartsWith("op_", StringComparison.Ordinal))
-								type = EntityType.Operator;
+								type = SymbolKind.Operator;
 						}
 						members.Add(ReadMethod(method, td, type));
 					}
@@ -1727,14 +1727,14 @@ namespace ICSharpCode.NRefactory.TypeSystem
 					bool getterVisible = property.GetMethod != null && IsVisible(property.GetMethod.Attributes);
 					bool setterVisible = property.SetMethod != null && IsVisible(property.SetMethod.Attributes);
 					if (getterVisible || setterVisible) {
-						EntityType type = EntityType.Property;
+						SymbolKind type = SymbolKind.Property;
 						if (property.HasParameters) {
 							// Try to detect indexer:
 							if (property.Name == defaultMemberName) {
-								type = EntityType.Indexer; // normal indexer
+								type = SymbolKind.Indexer; // normal indexer
 							} else if (property.Name.EndsWith(".Item", StringComparison.Ordinal) && (property.GetMethod ?? property.SetMethod).HasOverrides) {
 								// explicit interface implementation of indexer
-								type = EntityType.Indexer;
+								type = SymbolKind.Indexer;
 								// We can't really tell parameterized properties and indexers apart in this case without
 								// resolving the interface, so we rely on the "Item" naming convention instead.
 							}
@@ -1775,7 +1775,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			{
 				this.loader = loader;
 				this.cecilTypeDef = typeDefinition;
-				this.EntityType = EntityType.TypeDefinition;
+				this.SymbolKind = SymbolKind.TypeDefinition;
 				this.namespaceName = cecilTypeDef.Namespace;
 				this.Name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(cecilTypeDef.Name);
 				var tps = new List<IUnresolvedTypeParameter>();
@@ -1912,17 +1912,17 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		
 		#region Read Method
 		[CLSCompliant(false)]
-		public IUnresolvedMethod ReadMethod(MethodDefinition method, IUnresolvedTypeDefinition parentType, EntityType methodType = EntityType.Method)
+		public IUnresolvedMethod ReadMethod(MethodDefinition method, IUnresolvedTypeDefinition parentType, SymbolKind methodType = SymbolKind.Method)
 		{
 			return ReadMethod(method, parentType, methodType, null);
 		}
 		
-		IUnresolvedMethod ReadMethod(MethodDefinition method, IUnresolvedTypeDefinition parentType, EntityType methodType, IUnresolvedMember accessorOwner)
+		IUnresolvedMethod ReadMethod(MethodDefinition method, IUnresolvedTypeDefinition parentType, SymbolKind methodType, IUnresolvedMember accessorOwner)
 		{
 			if (method == null)
 				return null;
 			DefaultUnresolvedMethod m = new DefaultUnresolvedMethod(parentType, method.Name);
-			m.EntityType = methodType;
+			m.SymbolKind = methodType;
 			m.AccessorOwner = accessorOwner;
 			m.HasBody = method.HasBody;
 			if (method.HasGenericParameters) {
@@ -1930,7 +1930,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 					if (method.GenericParameters[i].Position != i)
 						throw new InvalidOperationException("g.Position != i");
 					m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(
-						EntityType.Method, i, method.GenericParameters[i].Name));
+						SymbolKind.Method, i, method.GenericParameters[i].Name));
 				}
 				for (int i = 0; i < method.GenericParameters.Count; i++) {
 					var tp = (DefaultUnresolvedTypeParameter)m.TypeParameters[i];
@@ -1963,7 +1963,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				m.IsExplicitInterfaceImplementation = true;
 				foreach (var or in method.Overrides) {
 					m.ExplicitInterfaceImplementations.Add(new DefaultMemberReference(
-						accessorOwner != null ? EntityType.Accessor : EntityType.Method,
+						accessorOwner != null ? SymbolKind.Accessor : SymbolKind.Method,
 						ReadTypeReference(or.DeclaringType),
 						or.Name, or.GenericParameters.Count, m.Parameters.Select(p => p.Type).ToList()));
 				}
@@ -2223,22 +2223,22 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		}
 
 		[CLSCompliant(false)]
-		public IUnresolvedProperty ReadProperty(PropertyDefinition property, IUnresolvedTypeDefinition parentType, EntityType propertyType = EntityType.Property)
+		public IUnresolvedProperty ReadProperty(PropertyDefinition property, IUnresolvedTypeDefinition parentType, SymbolKind propertyType = SymbolKind.Property)
 		{
 			if (property == null)
 				throw new ArgumentNullException("property");
 			if (parentType == null)
 				throw new ArgumentNullException("parentType");
 			DefaultUnresolvedProperty p = new DefaultUnresolvedProperty(parentType, property.Name);
-			p.EntityType = propertyType;
+			p.SymbolKind = propertyType;
 			TranslateModifiers(property.GetMethod ?? property.SetMethod, p);
 			if (property.GetMethod != null && property.SetMethod != null)
 				p.Accessibility = MergePropertyAccessibility (GetAccessibility (property.GetMethod.Attributes), GetAccessibility (property.SetMethod.Attributes));
 
 			p.ReturnType = ReadTypeReference(property.PropertyType, typeAttributes: property);
 			
-			p.Getter = ReadMethod(property.GetMethod, parentType, EntityType.Accessor, p);
-			p.Setter = ReadMethod(property.SetMethod, parentType, EntityType.Accessor, p);
+			p.Getter = ReadMethod(property.GetMethod, parentType, SymbolKind.Accessor, p);
+			p.Setter = ReadMethod(property.SetMethod, parentType, SymbolKind.Accessor, p);
 			
 			if (property.HasParameters) {
 				foreach (ParameterDefinition par in property.Parameters) {
@@ -2274,9 +2274,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			TranslateModifiers(ev.AddMethod, e);
 			e.ReturnType = ReadTypeReference(ev.EventType, typeAttributes: ev);
 			
-			e.AddAccessor    = ReadMethod(ev.AddMethod,    parentType, EntityType.Accessor, e);
-			e.RemoveAccessor = ReadMethod(ev.RemoveMethod, parentType, EntityType.Accessor, e);
-			e.InvokeAccessor = ReadMethod(ev.InvokeMethod, parentType, EntityType.Accessor, e);
+			e.AddAccessor    = ReadMethod(ev.AddMethod,    parentType, SymbolKind.Accessor, e);
+			e.RemoveAccessor = ReadMethod(ev.RemoveMethod, parentType, SymbolKind.Accessor, e);
+			e.InvokeAccessor = ReadMethod(ev.InvokeMethod, parentType, SymbolKind.Accessor, e);
 			
 			AddAttributes(ev, e);
 			

ICSharpCode.NRefactory/TypeSystem/EntityType.cs

@@ -20,7 +20,7 @@ using System;
 
 namespace ICSharpCode.NRefactory.TypeSystem
 {
-	public enum EntityType : byte
+	public enum SymbolKind : byte
 	{
 		None,
 		/// <seealso cref="ITypeDefinition"/>

ICSharpCode.NRefactory/TypeSystem/IEntity.cs

@@ -31,7 +31,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// <summary>
 		/// Gets the entity type.
 		/// </summary>
-		EntityType EntityType { get; }
+		SymbolKind SymbolKind { get; }
 		
 		/// <summary>
 		/// Gets the complete entity region (including header+body)

ICSharpCode.NRefactory/TypeSystem/ISymbol.cs

@@ -29,7 +29,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// This property returns an enum specifying which kind of symbol this is
 		/// (which derived interfaces of ISymbol are implemented)
 		/// </summary>
-		EntityType EntityType { get; }
+		SymbolKind SymbolKind { get; }
 		
 		/// <summary>
 		/// Gets the short name of the symbol.

ICSharpCode.NRefactory/TypeSystem/ITypeParameter.cs

@@ -31,8 +31,8 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// <summary>
 		/// Get the type of this type parameter's owner.
 		/// </summary>
-		/// <returns>EntityType.TypeDefinition or EntityType.Method</returns>
-		EntityType OwnerType { get; }
+		/// <returns>SymbolKind.TypeDefinition or SymbolKind.Method</returns>
+		SymbolKind OwnerType { get; }
 		
 		/// <summary>
 		/// Gets the index of the type parameter in the type parameter list of the owning method/class.
@@ -65,8 +65,8 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// <summary>
 		/// Get the type of this type parameter's owner.
 		/// </summary>
-		/// <returns>EntityType.TypeDefinition or EntityType.Method</returns>
-		EntityType OwnerType { get; }
+		/// <returns>SymbolKind.TypeDefinition or SymbolKind.Method</returns>
+		SymbolKind OwnerType { get; }
 		
 		/// <summary>
 		/// Gets the owning method/class.

ICSharpCode.NRefactory/TypeSystem/IkvmLoader.cs

@@ -1,4 +1,4 @@
-//
+//
 // IkvmLoader.cs
 //
 // Author:
@@ -288,7 +288,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				return interningProvider.Intern (new ParameterizedTypeReference (baseType, para));
 			}
 			if (type.IsGenericParameter) {
-				return TypeParameterReference.Create (type.DeclaringMethod != null ? EntityType.Method : EntityType.TypeDefinition, type.GenericParameterPosition);
+				return TypeParameterReference.Create (type.DeclaringMethod != null ? SymbolKind.Method : SymbolKind.TypeDefinition, type.GenericParameterPosition);
 			}
 			if (type.IsNested) {
 				ITypeReference typeRef = CreateTypeReference (type.DeclaringType, typeAttributes, ref typeIndex);
@@ -1199,14 +1199,14 @@ namespace ICSharpCode.NRefactory.TypeSystem
 
 			public KeyValuePair<IMember, ResolveResult> ReadNamedArg(IType attributeType)
 			{
-				EntityType memberType;
+				SymbolKind memberType;
 				var b = ReadByte();
 				switch (b) {
 					case 0x53:
-					memberType = EntityType.Field;
+					memberType = SymbolKind.Field;
 					break;
 					case 0x54:
-					memberType = EntityType.Property;
+					memberType = SymbolKind.Property;
 					break;
 					default:
 					throw new NotSupportedException(string.Format("Custom member type 0x{0:x} is not supported.", b));
@@ -1216,7 +1216,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				ResolveResult val = ReadFixedArg(type);
 				IMember member = null;
 				// Use last matching member, as GetMembers() returns members from base types first.
-				foreach (IMember m in attributeType.GetMembers(m => m.EntityType == memberType && m.Name == name)) {
+				foreach (IMember m in attributeType.GetMembers(m => m.SymbolKind == memberType && m.Name == name)) {
 					if (m.ReturnType.Equals(type))
 						member = m;
 				}
@@ -1450,7 +1450,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				if (genericArguments[i].GenericParameterPosition != i)
 					throw new InvalidOperationException("g.GenericParameterPosition != i");
 				typeParameters.Add(new DefaultUnresolvedTypeParameter(
-					EntityType.TypeDefinition, i, genericArguments [i].Name));
+					SymbolKind.TypeDefinition, i, genericArguments [i].Name));
 			}
 		}
 
@@ -1598,10 +1598,10 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			foreach (var method in typeDefinition.GetMethods (bindingFlags)) {
 				if (IsVisible(method.Attributes) && !IsAccessor(method)) {
-					EntityType type = EntityType.Method;
+					SymbolKind type = SymbolKind.Method;
 					if (method.IsSpecialName) {
 						if (method.Name.StartsWith("op_", StringComparison.Ordinal))
-							type = EntityType.Operator;
+							type = SymbolKind.Operator;
 					}
 					members.Add(ReadMethod(method, td, type));
 				}
@@ -1609,7 +1609,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 
 			foreach (var method in typeDefinition.GetConstructors (bindingFlags)) {
 				if (IsVisible(method.Attributes)) {
-					EntityType type = EntityType.Constructor;
+					SymbolKind type = SymbolKind.Constructor;
 					members.Add(ReadConstructor(method, td, type));
 				}
 			}
@@ -1632,16 +1632,16 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				bool getterVisible = property.GetMethod != null && IsVisible(property.GetMethod.Attributes);
 				bool setterVisible = property.SetMethod != null && IsVisible(property.SetMethod.Attributes);
 				if (getterVisible || setterVisible) {
-					EntityType type = EntityType.Property;
+					SymbolKind type = SymbolKind.Property;
 					if (property.GetIndexParameters () != null) {
 						// Try to detect indexer:
 						if (property.Name == defaultMemberName) {
-							type = EntityType.Indexer; // normal indexer
+							type = SymbolKind.Indexer; // normal indexer
 						}
 						// TODO: HasOverrides ?
 						else if (property.Name.EndsWith(".Item", StringComparison.Ordinal) /*&& (property.GetMethod ?? property.SetMethod).HasOverrides*/) {
 							// explicit interface implementation of indexer
-							type = EntityType.Indexer;
+							type = SymbolKind.Indexer;
 							// We can't really tell parameterized properties and indexers apart in this case without
 							// resolving the interface, so we rely on the "Item" naming convention instead.
 						}
@@ -1674,17 +1674,17 @@ namespace ICSharpCode.NRefactory.TypeSystem
 
 		#region Read Method
 		[CLSCompliant(false)]
-		public IUnresolvedMethod ReadMethod(MethodInfo method, IUnresolvedTypeDefinition parentType, EntityType methodType = EntityType.Method)
+		public IUnresolvedMethod ReadMethod(MethodInfo method, IUnresolvedTypeDefinition parentType, SymbolKind methodType = SymbolKind.Method)
 		{
 			return ReadMethod(method, parentType, methodType, null);
 		}
 
-		IUnresolvedMethod ReadMethod(MethodInfo method, IUnresolvedTypeDefinition parentType, EntityType methodType, IUnresolvedMember accessorOwner)
+		IUnresolvedMethod ReadMethod(MethodInfo method, IUnresolvedTypeDefinition parentType, SymbolKind methodType, IUnresolvedMember accessorOwner)
 		{
 			if (method == null)
 				return null;
 			var m = new DefaultUnresolvedMethod(parentType, method.Name);
-			m.EntityType = methodType;
+			m.SymbolKind = methodType;
 			m.AccessorOwner = accessorOwner;
 			m.HasBody = method.GetMethodBody () != null;
 			var genericArguments = method.GetGenericArguments ();
@@ -1693,7 +1693,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 					if (genericArguments[i].GenericParameterPosition != i)
 						throw new InvalidOperationException("g.Position != i");
 					m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(
-						EntityType.Method, i, genericArguments[i].Name));
+						SymbolKind.Method, i, genericArguments[i].Name));
 				}
 				for (int i = 0; i < genericArguments.Length; i++) {
 					var tp = (DefaultUnresolvedTypeParameter)m.TypeParameters[i];
@@ -1725,7 +1725,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				
 				foreach (var or in method.__GetMethodImpls ()) {
 					m.ExplicitInterfaceImplementations.Add(new DefaultMemberReference(
-						accessorOwner != null ? EntityType.Accessor : EntityType.Method,
+						accessorOwner != null ? SymbolKind.Accessor : SymbolKind.Method,
 						ReadTypeReference(or.DeclaringType),
 						or.Name, or.GetGenericArguments ().Length, m.Parameters.Select(p => p.Type).ToList()));
 				}
@@ -1800,17 +1800,17 @@ namespace ICSharpCode.NRefactory.TypeSystem
 
 		#region Read Constructor
 		[CLSCompliant(false)]
-		public IUnresolvedMethod ReadConstructor(ConstructorInfo method, IUnresolvedTypeDefinition parentType, EntityType methodType = EntityType.Method)
+		public IUnresolvedMethod ReadConstructor(ConstructorInfo method, IUnresolvedTypeDefinition parentType, SymbolKind methodType = SymbolKind.Method)
 		{
 			return ReadConstructor(method, parentType, methodType, null);
 		}
 
-		IUnresolvedMethod ReadConstructor(ConstructorInfo method, IUnresolvedTypeDefinition parentType, EntityType methodType, IUnresolvedMember accessorOwner)
+		IUnresolvedMethod ReadConstructor(ConstructorInfo method, IUnresolvedTypeDefinition parentType, SymbolKind methodType, IUnresolvedMember accessorOwner)
 		{
 			if (method == null)
 				return null;
 			var m = new DefaultUnresolvedMethod(parentType, method.Name);
-			m.EntityType = methodType;
+			m.SymbolKind = methodType;
 			m.AccessorOwner = accessorOwner;
 			m.HasBody = method.GetMethodBody () != null;
 			var genericArguments = method.GetGenericArguments ();
@@ -1819,7 +1819,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 					if (genericArguments[i].GenericParameterPosition != i)
 						throw new InvalidOperationException("g.Position != i");
 					m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(
-						EntityType.Method, i, genericArguments[i].Name));
+						SymbolKind.Method, i, genericArguments[i].Name));
 				}
 				for (int i = 0; i < genericArguments.Length; i++) {
 					var tp = (DefaultUnresolvedTypeParameter)m.TypeParameters[i];
@@ -2024,7 +2024,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		}
 
 		[CLSCompliant(false)]
-		public IUnresolvedProperty ReadProperty(PropertyInfo property, IUnresolvedTypeDefinition parentType, EntityType propertyType = EntityType.Property)
+		public IUnresolvedProperty ReadProperty(PropertyInfo property, IUnresolvedTypeDefinition parentType, SymbolKind propertyType = SymbolKind.Property)
 		{
 			if (property == null)
 				throw new ArgumentNullException("property");
@@ -2032,14 +2032,14 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				throw new ArgumentNullException("parentType");
 
 			var p = new DefaultUnresolvedProperty(parentType, property.Name);
-			p.EntityType = propertyType;
+			p.SymbolKind = propertyType;
 			TranslateModifiers(property.GetMethod ?? property.SetMethod, p);
 			if (property.GetMethod != null && property.SetMethod != null)
 				p.Accessibility = MergePropertyAccessibility (GetAccessibility (property.GetMethod.Attributes), GetAccessibility (property.SetMethod.Attributes));
 			p.ReturnType = ReadTypeReference(property.PropertyType, typeAttributes: property.CustomAttributes);
 
-			p.Getter = ReadMethod(property.GetMethod, parentType, EntityType.Accessor, p);
-			p.Setter = ReadMethod(property.SetMethod, parentType, EntityType.Accessor, p);
+			p.Getter = ReadMethod(property.GetMethod, parentType, SymbolKind.Accessor, p);
+			p.Setter = ReadMethod(property.SetMethod, parentType, SymbolKind.Accessor, p);
 
 			foreach (var par in property.GetIndexParameters ()) {
 				p.Parameters.Add(ReadParameter(par));
@@ -2074,9 +2074,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			TranslateModifiers(ev.AddMethod, e);
 			e.ReturnType = ReadTypeReference(ev.EventHandlerType, typeAttributes: ev.CustomAttributes);
 
-			e.AddAccessor    = ReadMethod(ev.AddMethod,    parentType, EntityType.Accessor, e);
-			e.RemoveAccessor = ReadMethod(ev.RemoveMethod, parentType, EntityType.Accessor, e);
-			e.InvokeAccessor = ReadMethod(ev.RaiseMethod, parentType, EntityType.Accessor, e);
+			e.AddAccessor    = ReadMethod(ev.AddMethod,    parentType, SymbolKind.Accessor, e);
+			e.RemoveAccessor = ReadMethod(ev.RemoveMethod, parentType, SymbolKind.Accessor, e);
+			e.InvokeAccessor = ReadMethod(ev.RaiseMethod, parentType, SymbolKind.Accessor, e);
 
 			AddAttributes(ev, e);
 

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedEntity.cs

@@ -41,8 +41,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			this.Attributes = unresolved.Attributes.CreateResolvedAttributes(parentContext);
 		}
 		
-		public EntityType EntityType {
-			get { return unresolved.EntityType; }
+		public SymbolKind SymbolKind {
+			get { return unresolved.SymbolKind; }
 		}
 		
 		public DomRegion Region {
@@ -111,7 +111,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public override string ToString()
 		{
-			return "[" + this.EntityType.ToString() + " " + this.ReflectionName + "]";
+			return "[" + this.SymbolKind.ToString() + " " + this.ReflectionName + "]";
 		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs

@@ -85,7 +85,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 					.ToArray();
 
 				IEnumerable<IMember> otherMembers = DeclaringTypeDefinition.Members;
-				if (EntityType == EntityType.Accessor)
+				if (SymbolKind == SymbolKind.Accessor)
 					otherMembers = DeclaringTypeDefinition.GetAccessors(options: GetMemberOptions.IgnoreInheritedMembers);
 				result = result.Where(item => !otherMembers.Any(m => m.IsExplicitInterfaceImplementation && m.ImplementedInterfaceMembers.Contains(item))).ToArray();
 
@@ -133,7 +133,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			if (IsExplicitInterfaceImplementation && ImplementedInterfaceMembers.Count == 1) {
 				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToMemberReference());
 			} else {
-				return new DefaultMemberReference(this.EntityType, declTypeRef, this.Name);
+				return new DefaultMemberReference(this.SymbolKind, declTypeRef, this.Name);
 			}
 		}
 		

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedTypeParameter.cs

@@ -27,7 +27,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 	public abstract class AbstractTypeParameter : ITypeParameter, ICompilationProvider
 	{
 		readonly ICompilation compilation;
-		readonly EntityType ownerType;
+		readonly SymbolKind ownerType;
 		readonly IEntity owner;
 		readonly int index;
 		readonly string name;
@@ -41,32 +41,32 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				throw new ArgumentNullException("owner");
 			this.owner = owner;
 			this.compilation = owner.Compilation;
-			this.ownerType = owner.EntityType;
+			this.ownerType = owner.SymbolKind;
 			this.index = index;
-			this.name = name ?? ((this.OwnerType == EntityType.Method ? "!!" : "!") + index.ToString(CultureInfo.InvariantCulture));
+			this.name = name ?? ((this.OwnerType == SymbolKind.Method ? "!!" : "!") + index.ToString(CultureInfo.InvariantCulture));
 			this.attributes = attributes ?? EmptyList<IAttribute>.Instance;
 			this.region = region;
 			this.variance = variance;
 		}
 		
-		protected AbstractTypeParameter(ICompilation compilation, EntityType ownerType, int index, string name, VarianceModifier variance, IList<IAttribute> attributes, DomRegion region)
+		protected AbstractTypeParameter(ICompilation compilation, SymbolKind ownerType, int index, string name, VarianceModifier variance, IList<IAttribute> attributes, DomRegion region)
 		{
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
 			this.compilation = compilation;
 			this.ownerType = ownerType;
 			this.index = index;
-			this.name = name ?? ((this.OwnerType == EntityType.Method ? "!!" : "!") + index.ToString(CultureInfo.InvariantCulture));
+			this.name = name ?? ((this.OwnerType == SymbolKind.Method ? "!!" : "!") + index.ToString(CultureInfo.InvariantCulture));
 			this.attributes = attributes ?? EmptyList<IAttribute>.Instance;
 			this.region = region;
 			this.variance = variance;
 		}
 		
-		EntityType ISymbol.EntityType {
-			get { return EntityType.TypeParameter; }
+		SymbolKind ISymbol.SymbolKind {
+			get { return SymbolKind.TypeParameter; }
 		}
 		
-		public EntityType OwnerType {
+		public SymbolKind OwnerType {
 			get { return ownerType; }
 		}
 		
@@ -236,7 +236,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public string ReflectionName {
 			get {
-				return (this.OwnerType == EntityType.Method ? "``" : "`") + index.ToString(CultureInfo.InvariantCulture);
+				return (this.OwnerType == SymbolKind.Method ? "``" : "`") + index.ToString(CultureInfo.InvariantCulture);
 			}
 		}
 		

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedEntity.cs

@@ -39,7 +39,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		internal RareFields rareFields;
 		
 		// 1 byte per enum + 2 bytes for flags
-		EntityType entityType;
+		SymbolKind symbolKind;
 		Accessibility accessibility;
 		internal BitVector16 flags;
 		
@@ -146,11 +146,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			FreezableHelper.ThrowIfFrozen(this);
 		}
 		
-		public EntityType EntityType {
-			get { return entityType; }
+		public SymbolKind SymbolKind {
+			get { return symbolKind; }
 			set {
 				ThrowIfFrozen();
-				entityType = value;
+				symbolKind = value;
 			}
 		}
 		

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedMember.cs

@@ -149,7 +149,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			ITypeReference interfaceTypeReference = null;
 			if (this.IsExplicitInterfaceImplementation && this.ExplicitInterfaceImplementations.Count == 1)
 				interfaceTypeReference = this.ExplicitInterfaceImplementations[0].DeclaringTypeReference;
-			return Resolve(ExtendContextForType(context, this.DeclaringTypeDefinition), this.EntityType, this.Name, interfaceTypeReference);
+			return Resolve(ExtendContextForType(context, this.DeclaringTypeDefinition), this.SymbolKind, this.Name, interfaceTypeReference);
 		}
 		
 		protected static ITypeResolveContext ExtendContextForType(ITypeResolveContext assemblyContext, IUnresolvedTypeDefinition typeDef)
@@ -166,7 +166,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		public static IMember Resolve(ITypeResolveContext context,
-		                              EntityType entityType,
+		                              SymbolKind symbolKind,
 		                              string name,
 		                              ITypeReference explicitInterfaceTypeReference = null,
 		                              IList<string> typeParameterNames = null,
@@ -184,7 +184,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 					foreach (IMember member in context.CurrentTypeDefinition.Members) {
 						if (member.IsExplicitInterfaceImplementation)
 							continue;
-						if (IsNonGenericMatch(member, entityType, name, parameterTypes))
+						if (IsNonGenericMatch(member, symbolKind, name, parameterTypes))
 							return member;
 					}
 				} else {
@@ -194,7 +194,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 							continue;
 						if (member.ImplementedInterfaceMembers.Count != 1)
 							continue;
-						if (IsNonGenericMatch(member, entityType, name, parameterTypes)) {
+						if (IsNonGenericMatch(member, symbolKind, name, parameterTypes)) {
 							if (explicitInterfaceType.Equals(member.ImplementedInterfaceMembers[0].DeclaringType))
 								return member;
 						}
@@ -204,7 +204,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				// generic member
 				// In this case, we must specify the correct context for resolving the parameter types
 				foreach (IMethod method in context.CurrentTypeDefinition.Methods) {
-					if (method.EntityType != entityType)
+					if (method.SymbolKind != symbolKind)
 						continue;
 					if (method.Name != name)
 						continue;
@@ -232,9 +232,9 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			return null;
 		}
 		
-		static bool IsNonGenericMatch(IMember member, EntityType entityType, string name, IList<IType> parameterTypes)
+		static bool IsNonGenericMatch(IMember member, SymbolKind symbolKind, string name, IList<IType> parameterTypes)
 		{
-			if (member.EntityType != entityType)
+			if (member.SymbolKind != symbolKind)
 				return false;
 			if (member.Name != name)
 				return false;

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultMemberReference.cs

@@ -33,21 +33,21 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 	[Serializable]
 	public sealed class DefaultMemberReference : IMemberReference, ISupportsInterning
 	{
-		readonly EntityType entityType;
+		readonly SymbolKind symbolKind;
 		readonly ITypeReference typeReference;
 		readonly string name;
 		readonly int typeParameterCount;
 		readonly IList<ITypeReference> parameterTypes;
 		
-		public DefaultMemberReference(EntityType entityType, ITypeReference typeReference, string name, int typeParameterCount = 0, IList<ITypeReference> parameterTypes = null)
+		public DefaultMemberReference(SymbolKind symbolKind, ITypeReference typeReference, string name, int typeParameterCount = 0, IList<ITypeReference> parameterTypes = null)
 		{
 			if (typeReference == null)
 				throw new ArgumentNullException("typeReference");
 			if (name == null)
 				throw new ArgumentNullException("name");
-			if (typeParameterCount != 0 && entityType != EntityType.Method)
+			if (typeParameterCount != 0 && symbolKind != SymbolKind.Method)
 				throw new ArgumentException("Type parameter count > 0 is only supported for methods.");
-			this.entityType = entityType;
+			this.symbolKind = symbolKind;
 			this.typeReference = typeReference;
 			this.name = name;
 			this.typeParameterCount = typeParameterCount;
@@ -62,18 +62,18 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		{
 			IType type = typeReference.Resolve(context);
 			IEnumerable<IMember> members;
-			if (entityType == EntityType.Accessor) {
+			if (symbolKind == SymbolKind.Accessor) {
 				members = type.GetAccessors(
 					m => m.Name == name && !m.IsExplicitInterfaceImplementation,
 					GetMemberOptions.IgnoreInheritedMembers);
-			} else if (entityType == EntityType.Method) {
+			} else if (symbolKind == SymbolKind.Method) {
 				members = type.GetMethods(
-					m => m.Name == name && m.EntityType == EntityType.Method
+					m => m.Name == name && m.SymbolKind == SymbolKind.Method
 					&& m.TypeParameters.Count == typeParameterCount && !m.IsExplicitInterfaceImplementation,
 					GetMemberOptions.IgnoreInheritedMembers);
 			} else {
 				members = type.GetMembers(
-					m => m.Name == name && m.EntityType == entityType && !m.IsExplicitInterfaceImplementation,
+					m => m.Name == name && m.SymbolKind == symbolKind && !m.IsExplicitInterfaceImplementation,
 					GetMemberOptions.IgnoreInheritedMembers);
 			}
 			var resolvedParameterTypes = parameterTypes.Resolve(context);
@@ -101,13 +101,13 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		int ISupportsInterning.GetHashCodeForInterning()
 		{
-			return (int)entityType ^ typeReference.GetHashCode() ^ name.GetHashCode() ^ parameterTypes.GetHashCode();
+			return (int)symbolKind ^ typeReference.GetHashCode() ^ name.GetHashCode() ^ parameterTypes.GetHashCode();
 		}
 		
 		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
 		{
 			DefaultMemberReference o = other as DefaultMemberReference;
-			return o != null && entityType == o.entityType && typeReference == o.typeReference && name == o.name && parameterTypes == o.parameterTypes;
+			return o != null && symbolKind == o.symbolKind && typeReference == o.typeReference && name == o.name && parameterTypes == o.parameterTypes;
 		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultParameter.cs

@@ -62,8 +62,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			this.defaultValue = defaultValue;
 		}
 		
-		EntityType ISymbol.EntityType {
-			get { return EntityType.Parameter; }
+		SymbolKind ISymbol.SymbolKind {
+			get { return SymbolKind.Parameter; }
 		}
 		
 		public IList<IAttribute> Attributes {

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedMethod.cs

@@ -241,7 +241,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToMemberReference());
 			} else {
 				return new DefaultMemberReference(
-					this.EntityType, declTypeRef, this.Name, this.TypeParameters.Count,
+					this.SymbolKind, declTypeRef, this.Name, this.TypeParameters.Count,
 					this.Parameters.Select(p => p.Type.ToTypeReference()).ToList());
 			}
 		}
@@ -259,7 +259,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public override string ToString()
 		{
 			StringBuilder b = new StringBuilder("[");
-			b.Append(this.EntityType);
+			b.Append(this.SymbolKind);
 			b.Append(' ');
 			if (this.DeclaringType.Kind != TypeKind.Unknown) {
 				b.Append(this.DeclaringType.ReflectionName);

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedProperty.cs

@@ -68,7 +68,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToMemberReference());
 			} else {
 				return new DefaultMemberReference(
-					this.EntityType, declTypeRef, this.Name, 0,
+					this.SymbolKind, declTypeRef, this.Name, 0,
 					this.Parameters.Select(p => p.Type.ToTypeReference()).ToList());
 			}
 		}

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs

@@ -110,8 +110,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return parts; }
 		}
 		
-		public EntityType EntityType {
-			get { return parts[0].EntityType; }
+		public SymbolKind SymbolKind {
+			get { return parts[0].SymbolKind; }
 		}
 		
 		public virtual TypeKind Kind {
@@ -325,7 +325,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 			if (addDefaultConstructorIfRequired) {
 				TypeKind kind = this.Kind;
-				if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.EntityType == EntityType.Constructor && !m.IsStatic)
+				if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.SymbolKind == SymbolKind.Constructor && !m.IsStatic)
 				    || kind == TypeKind.Enum || kind == TypeKind.Struct)
 				{
 					contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this));
@@ -344,7 +344,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get {
 				var members = GetMemberList();
 				for (int i = 0; i < members.unresolvedMembers.Length; i++) {
-					if (members.unresolvedMembers[i].EntityType == EntityType.Field)
+					if (members.unresolvedMembers[i].SymbolKind == SymbolKind.Field)
 						yield return (IField)members[i];
 				}
 			}
@@ -367,9 +367,9 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get {
 				var members = GetMemberList();
 				for (int i = 0; i < members.unresolvedMembers.Length; i++) {
-					switch (members.unresolvedMembers[i].EntityType) {
-						case EntityType.Property:
-						case EntityType.Indexer:
+					switch (members.unresolvedMembers[i].SymbolKind) {
+						case SymbolKind.Property:
+						case SymbolKind.Indexer:
 							yield return (IProperty)members[i];
 							break;
 					}
@@ -381,7 +381,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get {
 				var members = GetMemberList();
 				for (int i = 0; i < members.unresolvedMembers.Length; i++) {
-					if (members.unresolvedMembers[i].EntityType == EntityType.Event)
+					if (members.unresolvedMembers[i].SymbolKind == SymbolKind.Event)
 						yield return (IEvent)members[i];
 				}
 			}

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeParameter.cs

@@ -48,7 +48,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		public DefaultTypeParameter(
-			ICompilation compilation, EntityType ownerType,
+			ICompilation compilation, SymbolKind ownerType,
 			int index, string name = null,
 			VarianceModifier variance = VarianceModifier.Invariant,
 			IList<IAttribute> attributes = null,
@@ -112,7 +112,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			base.FreezeInternal();
 		}
 		
-		public DefaultTypeParameter(EntityType ownerType, int index, string name)
+		public DefaultTypeParameter(SymbolKind ownerType, int index, string name)
 			: base(ownerType, index, name)
 		{
 		}

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAssembly.cs

@@ -403,8 +403,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 					get { return ns.FullName; }
 				}
 				
-				EntityType ISymbol.EntityType {
-					get { return EntityType.Namespace; }
+				SymbolKind ISymbol.SymbolKind {
+					get { return SymbolKind.Namespace; }
 				}
 				
 				public string Name {

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAttribute.cs

@@ -101,7 +101,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public void AddNamedFieldArgument(string fieldName, IConstantValue value)
 		{
 			this.NamedArguments.Add(new KeyValuePair<IMemberReference, IConstantValue>(
-				new DefaultMemberReference(EntityType.Field, attributeType, fieldName),
+				new DefaultMemberReference(SymbolKind.Field, attributeType, fieldName),
 				value
 			));
 		}
@@ -109,7 +109,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public void AddNamedPropertyArgument(string propertyName, IConstantValue value)
 		{
 			this.NamedArguments.Add(new KeyValuePair<IMemberReference, IConstantValue>(
-				new DefaultMemberReference(EntityType.Property, attributeType, propertyName),
+				new DefaultMemberReference(SymbolKind.Property, attributeType, propertyName),
 				value
 			));
 		}

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedEvent.cs

@@ -38,12 +38,12 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public DefaultUnresolvedEvent()
 		{
-			this.EntityType = EntityType.Event;
+			this.SymbolKind = SymbolKind.Event;
 		}
 		
 		public DefaultUnresolvedEvent(IUnresolvedTypeDefinition declaringType, string name)
 		{
-			this.EntityType = EntityType.Event;
+			this.SymbolKind = SymbolKind.Event;
 			this.DeclaringTypeDefinition = declaringType;
 			this.Name = name;
 			if (declaringType != null)

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedField.cs

@@ -36,12 +36,12 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public DefaultUnresolvedField()
 		{
-			this.EntityType = EntityType.Field;
+			this.SymbolKind = SymbolKind.Field;
 		}
 		
 		public DefaultUnresolvedField(IUnresolvedTypeDefinition declaringType, string name)
 		{
-			this.EntityType = EntityType.Field;
+			this.SymbolKind = SymbolKind.Field;
 			this.DeclaringTypeDefinition = declaringType;
 			this.Name = name;
 			if (declaringType != null)

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedMethod.cs

@@ -66,12 +66,12 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public DefaultUnresolvedMethod()
 		{
-			this.EntityType = EntityType.Method;
+			this.SymbolKind = SymbolKind.Method;
 		}
 		
 		public DefaultUnresolvedMethod(IUnresolvedTypeDefinition declaringType, string name)
 		{
-			this.EntityType = EntityType.Method;
+			this.SymbolKind = SymbolKind.Method;
 			this.DeclaringTypeDefinition = declaringType;
 			this.Name = name;
 			if (declaringType != null)
@@ -103,15 +103,15 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		public bool IsConstructor {
-			get { return this.EntityType == EntityType.Constructor; }
+			get { return this.SymbolKind == SymbolKind.Constructor; }
 		}
 		
 		public bool IsDestructor {
-			get { return this.EntityType == EntityType.Destructor; }
+			get { return this.SymbolKind == SymbolKind.Destructor; }
 		}
 		
 		public bool IsOperator {
-			get { return this.EntityType == EntityType.Operator; }
+			get { return this.SymbolKind == SymbolKind.Operator; }
 		}
 		
 		public bool IsPartial {
@@ -183,7 +183,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public override string ToString()
 		{
 			StringBuilder b = new StringBuilder("[");
-			b.Append(EntityType.ToString());
+			b.Append(SymbolKind.ToString());
 			b.Append(' ');
 			if (DeclaringTypeDefinition != null) {
 				b.Append(DeclaringTypeDefinition.Name);
@@ -232,7 +232,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			if (this.IsExplicitInterfaceImplementation && this.ExplicitInterfaceImplementations.Count == 1)
 				interfaceTypeReference = this.ExplicitInterfaceImplementations[0].DeclaringTypeReference;
 			return Resolve(ExtendContextForType(context, this.DeclaringTypeDefinition),
-			               this.EntityType, this.Name, interfaceTypeReference,
+			               this.SymbolKind, this.Name, interfaceTypeReference,
 			               this.TypeParameters.Select(tp => tp.Name).ToList(),
 			               this.Parameters.Select(p => p.Type).ToList());
 		}
@@ -249,7 +249,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			DomRegion region = typeDefinition.Region;
 			region = new DomRegion(region.FileName, region.BeginLine, region.BeginColumn); // remove endline/endcolumn
 			return new DefaultUnresolvedMethod(typeDefinition, ".ctor") {
-				EntityType = EntityType.Constructor,
+				SymbolKind = SymbolKind.Constructor,
 				Accessibility = typeDefinition.IsAbstract ? Accessibility.Protected : Accessibility.Public,
 				IsSynthetic = true,
 				HasBody = true,
@@ -274,7 +274,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		static IUnresolvedMethod CreateDummyConstructor()
 		{
 			var m = new DefaultUnresolvedMethod {
-				EntityType = EntityType.Constructor,
+				SymbolKind = SymbolKind.Constructor,
 				Name = ".ctor",
 				Accessibility = Accessibility.Public,
 				IsSynthetic = true,

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedParameter.cs

@@ -228,7 +228,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				this.context = context;
 			}
 			
-			EntityType ISymbol.EntityType { get { return EntityType.Parameter; } }
+			SymbolKind ISymbol.SymbolKind { get { return SymbolKind.Parameter; } }
 			public IType Type { get; internal set; }
 			public string Name { get; internal set; }
 			public DomRegion Region { get; internal set; }

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedProperty.cs

@@ -55,12 +55,12 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public DefaultUnresolvedProperty()
 		{
-			this.EntityType = EntityType.Property;
+			this.SymbolKind = SymbolKind.Property;
 		}
 		
 		public DefaultUnresolvedProperty(IUnresolvedTypeDefinition declaringType, string name)
 		{
-			this.EntityType = EntityType.Property;
+			this.SymbolKind = SymbolKind.Property;
 			this.DeclaringTypeDefinition = declaringType;
 			this.Name = name;
 			if (declaringType != null)
@@ -68,7 +68,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		public bool IsIndexer {
-			get { return this.EntityType == EntityType.Indexer; }
+			get { return this.SymbolKind == SymbolKind.Indexer; }
 		}
 		
 		public IList<IUnresolvedParameter> Parameters {
@@ -114,7 +114,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			if (this.IsExplicitInterfaceImplementation && this.ExplicitInterfaceImplementations.Count == 1)
 				interfaceTypeReference = this.ExplicitInterfaceImplementations[0].DeclaringTypeReference;
 			return Resolve(ExtendContextForType(context, this.DeclaringTypeDefinition), 
-			               this.EntityType, this.Name, interfaceTypeReference,
+			               this.SymbolKind, this.Name, interfaceTypeReference,
 			               parameterTypeReferences: this.Parameters.Select(p => p.Type).ToList());
 		}
 		

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeDefinition.cs

@@ -38,7 +38,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public DefaultUnresolvedTypeDefinition()
 		{
-			this.EntityType = EntityType.TypeDefinition;
+			this.SymbolKind = SymbolKind.TypeDefinition;
 		}
 		
 		public DefaultUnresolvedTypeDefinition(string fullName)
@@ -54,21 +54,21 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				name = fullName;
 			}
 
-			this.EntityType = EntityType.TypeDefinition;
+			this.SymbolKind = SymbolKind.TypeDefinition;
 			this.namespaceName = namespaceName;
 			this.Name = name;
 		}
 		
 		public DefaultUnresolvedTypeDefinition(string namespaceName, string name)
 		{
-			this.EntityType = EntityType.TypeDefinition;
+			this.SymbolKind = SymbolKind.TypeDefinition;
 			this.namespaceName = namespaceName;
 			this.Name = name;
 		}
 		
 		public DefaultUnresolvedTypeDefinition(IUnresolvedTypeDefinition declaringTypeDefinition, string name)
 		{
-			this.EntityType = EntityType.TypeDefinition;
+			this.SymbolKind = SymbolKind.TypeDefinition;
 			this.DeclaringTypeDefinition = declaringTypeDefinition;
 			this.namespaceName = declaringTypeDefinition.Namespace;
 			this.Name = name;

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeParameter.cs

@@ -36,7 +36,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		string name;
 		DomRegion region;
 		
-		EntityType ownerType;
+		SymbolKind ownerType;
 		VarianceModifier variance;
 		BitVector16 flags;
 		const ushort FlagFrozen                       = 0x0001;
@@ -57,14 +57,14 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			attributes = FreezableHelper.FreezeListAndElements(attributes);
 		}
 		
-		public DefaultUnresolvedTypeParameter(EntityType ownerType, int index, string name = null)
+		public DefaultUnresolvedTypeParameter(SymbolKind ownerType, int index, string name = null)
 		{
 			this.ownerType = ownerType;
 			this.index = index;
-			this.name = name ?? ((ownerType == EntityType.Method ? "!!" : "!") + index.ToString(CultureInfo.InvariantCulture));
+			this.name = name ?? ((ownerType == SymbolKind.Method ? "!!" : "!") + index.ToString(CultureInfo.InvariantCulture));
 		}
 		
-		public EntityType OwnerType {
+		public SymbolKind OwnerType {
 			get { return ownerType; }
 		}
 		
@@ -94,7 +94,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		string INamedElement.ReflectionName {
 			get {
-				if (ownerType == EntityType.Method)
+				if (ownerType == SymbolKind.Method)
 					return "``" + index.ToString(CultureInfo.InvariantCulture);
 				else
 					return "`" + index.ToString(CultureInfo.InvariantCulture);
@@ -176,9 +176,9 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public virtual ITypeParameter CreateResolvedTypeParameter(ITypeResolveContext context)
 		{
 			IEntity owner = null;
-			if (this.OwnerType == EntityType.Method) {
+			if (this.OwnerType == SymbolKind.Method) {
 				owner = context.CurrentMember as IMethod;
-			} else if (this.OwnerType == EntityType.TypeDefinition) {
+			} else if (this.OwnerType == SymbolKind.TypeDefinition) {
 				owner = context.CurrentTypeDefinition;
 			}
 			if (owner == null)

ICSharpCode.NRefactory/TypeSystem/Implementation/DummyTypeParameter.cs

@@ -24,20 +24,20 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 {
 	public sealed class DummyTypeParameter : AbstractType, ITypeParameter
 	{
-		static ITypeParameter[] methodTypeParameters = { new DummyTypeParameter(EntityType.Method, 0) };
-		static ITypeParameter[] classTypeParameters = { new DummyTypeParameter(EntityType.TypeDefinition, 0) };
+		static ITypeParameter[] methodTypeParameters = { new DummyTypeParameter(SymbolKind.Method, 0) };
+		static ITypeParameter[] classTypeParameters = { new DummyTypeParameter(SymbolKind.TypeDefinition, 0) };
 		
 		public static ITypeParameter GetMethodTypeParameter(int index)
 		{
-			return GetTypeParameter(ref methodTypeParameters, EntityType.Method, index);
+			return GetTypeParameter(ref methodTypeParameters, SymbolKind.Method, index);
 		}
 		
 		public static ITypeParameter GetClassTypeParameter(int index)
 		{
-			return GetTypeParameter(ref classTypeParameters, EntityType.TypeDefinition, index);
+			return GetTypeParameter(ref classTypeParameters, SymbolKind.TypeDefinition, index);
 		}
 		
-		static ITypeParameter GetTypeParameter(ref ITypeParameter[] typeParameters, EntityType entityType, int index)
+		static ITypeParameter GetTypeParameter(ref ITypeParameter[] typeParameters, SymbolKind symbolKind, int index)
 		{
 			ITypeParameter[] tps = typeParameters;
 			while (index >= tps.Length) {
@@ -47,7 +47,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				ITypeParameter[] newTps = new ITypeParameter[index + 1];
 				tps.CopyTo(newTps, 0);
 				for (int i = tps.Length; i < newTps.Length; i++) {
-					newTps[i] = new DummyTypeParameter(entityType, i);
+					newTps[i] = new DummyTypeParameter(symbolKind, i);
 				}
 				ITypeParameter[] oldTps = Interlocked.CompareExchange(ref typeParameters, newTps, tps);
 				if (oldTps == tps) {
@@ -65,7 +65,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		{
 			public override IType VisitTypeParameter(ITypeParameter type)
 			{
-				if (type.OwnerType == EntityType.Method) {
+				if (type.OwnerType == SymbolKind.Method) {
 					return DummyTypeParameter.GetMethodTypeParameter(type.Index);
 				} else {
 					return base.VisitTypeParameter(type);
@@ -76,7 +76,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		{
 			public override IType VisitTypeParameter(ITypeParameter type)
 			{
-				if (type.OwnerType == EntityType.TypeDefinition) {
+				if (type.OwnerType == SymbolKind.TypeDefinition) {
 					return DummyTypeParameter.GetClassTypeParameter(type.Index);
 				} else {
 					return base.VisitTypeParameter(type);
@@ -117,28 +117,28 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			return type.AcceptVisitor(normalizeClassTypeParameters).AcceptVisitor(normalizeMethodTypeParameters);
 		}
 		
-		readonly EntityType ownerType;
+		readonly SymbolKind ownerType;
 		readonly int index;
 		
-		private DummyTypeParameter(EntityType ownerType, int index)
+		private DummyTypeParameter(SymbolKind ownerType, int index)
 		{
 			this.ownerType = ownerType;
 			this.index = index;
 		}
 		
-		EntityType ISymbol.EntityType {
-			get { return EntityType.TypeParameter; }
+		SymbolKind ISymbol.SymbolKind {
+			get { return SymbolKind.TypeParameter; }
 		}
 		
 		public override string Name {
 			get {
-				return (ownerType == EntityType.Method ? "!!" : "!") + index;
+				return (ownerType == SymbolKind.Method ? "!!" : "!") + index;
 			}
 		}
 		
 		public override string ReflectionName {
 			get {
-				return (ownerType == EntityType.Method ? "``" : "`") + index;
+				return (ownerType == SymbolKind.Method ? "``" : "`") + index;
 			}
 		}
 		
@@ -173,7 +173,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return EmptyList<IAttribute>.Instance; }
 		}
 		
-		EntityType ITypeParameter.OwnerType {
+		SymbolKind ITypeParameter.OwnerType {
 			get { return ownerType; }
 		}
 		

ICSharpCode.NRefactory/TypeSystem/Implementation/ExplicitInterfaceImplementationMemberReference.cs

@@ -60,13 +60,13 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			if (interfaceMember == null)
 				return null;
 			IEnumerable<IMember> members;
-			if (interfaceMember.EntityType == EntityType.Accessor) {
+			if (interfaceMember.SymbolKind == SymbolKind.Accessor) {
 				members = declaringType.GetAccessors(
 					m => m.IsExplicitInterfaceImplementation,
 					GetMemberOptions.IgnoreInheritedMembers);
 			} else {
 				members = declaringType.GetMembers(
-					m => m.EntityType == interfaceMember.EntityType && m.IsExplicitInterfaceImplementation,
+					m => m.SymbolKind == interfaceMember.SymbolKind && m.IsExplicitInterfaceImplementation,
 					GetMemberOptions.IgnoreInheritedMembers);
 			}
 			return members.FirstOrDefault(m => m.ImplementedInterfaceMembers.Count == 1 && interfaceMember.Equals(m.ImplementedInterfaceMembers[0]));

ICSharpCode.NRefactory/TypeSystem/Implementation/MergedNamespace.cs

@@ -91,8 +91,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
-		public EntityType EntityType {
-			get { return EntityType.Namespace; }
+		public SymbolKind SymbolKind {
+			get { return SymbolKind.Namespace; }
 		}
 		
 		public ICompilation Compilation {

ICSharpCode.NRefactory/TypeSystem/Implementation/MinimalCorlib.cs

@@ -45,7 +45,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				if (typeRef != null) {
 					types[i] = new DefaultUnresolvedTypeDefinition(typeRef.Namespace, typeRef.Name);
 					for (int j = 0; j < typeRef.TypeParameterCount; j++) {
-						types[i].TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, j));
+						types[i].TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, j));
 					}
 					AddTypeDefinition(types[i]);
 				}

ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs

@@ -173,8 +173,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return baseMember.IsOverridable; }
 		}
 		
-		public EntityType EntityType {
-			get { return baseMember.EntityType; }
+		public SymbolKind SymbolKind {
+			get { return baseMember.SymbolKind; }
 		}
 		
 		public DomRegion Region {
@@ -405,7 +405,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				this.newType = newType;
 			}
 			
-			EntityType ISymbol.EntityType { get { return EntityType.Parameter; } }
+			SymbolKind ISymbol.SymbolKind { get { return SymbolKind.Parameter; } }
 			
 			public IList<IAttribute> Attributes {
 				get { return originalParameter.Attributes; }

ICSharpCode.NRefactory/TypeSystem/Implementation/TypeParameterReference.cs

@@ -32,10 +32,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		/// Creates a type parameter reference.
 		/// For common type parameter references, this method may return a shared instance.
 		/// </summary>
-		public static TypeParameterReference Create(EntityType ownerType, int index)
+		public static TypeParameterReference Create(SymbolKind ownerType, int index)
 		{
-			if (index >= 0 && index < 8 && (ownerType == EntityType.TypeDefinition || ownerType == EntityType.Method)) {
-				TypeParameterReference[] arr = (ownerType == EntityType.TypeDefinition) ? classTypeParameterReferences : methodTypeParameterReferences;
+			if (index >= 0 && index < 8 && (ownerType == SymbolKind.TypeDefinition || ownerType == SymbolKind.Method)) {
+				TypeParameterReference[] arr = (ownerType == SymbolKind.TypeDefinition) ? classTypeParameterReferences : methodTypeParameterReferences;
 				TypeParameterReference result = LazyInit.VolatileRead(ref arr[index]);
 				if (result == null) {
 					result = LazyInit.GetOrSet(ref arr[index], new TypeParameterReference(ownerType, index));
@@ -46,7 +46,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
-		readonly EntityType ownerType;
+		readonly SymbolKind ownerType;
 		readonly int index;
 
 		public int Index {
@@ -55,7 +55,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 
-		public TypeParameterReference(EntityType ownerType, int index)
+		public TypeParameterReference(SymbolKind ownerType, int index)
 		{
 			this.ownerType = ownerType;
 			this.index = index;
@@ -63,13 +63,13 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public IType Resolve(ITypeResolveContext context)
 		{
-			if (ownerType == EntityType.Method) {
+			if (ownerType == SymbolKind.Method) {
 				IMethod method = context.CurrentMember as IMethod;
 				if (method != null && index < method.TypeParameters.Count) {
 					return method.TypeParameters[index];
 				}
 				return DummyTypeParameter.GetMethodTypeParameter(index);
-			} else if (ownerType == EntityType.TypeDefinition) {
+			} else if (ownerType == SymbolKind.TypeDefinition) {
 				ITypeDefinition typeDef = context.CurrentTypeDefinition;
 				if (typeDef != null && index < typeDef.TypeParameters.Count) {
 					return typeDef.TypeParameters[index];
@@ -82,7 +82,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public override string ToString()
 		{
-			if (ownerType == EntityType.Method)
+			if (ownerType == SymbolKind.Method)
 				return "!!" + index.ToString(CultureInfo.InvariantCulture);
 			else
 				return "!" + index.ToString(CultureInfo.InvariantCulture);

ICSharpCode.NRefactory/TypeSystem/InheritanceHelper.cs

@@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 					continue;
 
 				IEnumerable<IMember> baseMembers;
-				if (member.EntityType == EntityType.Accessor) {
+				if (member.SymbolKind == SymbolKind.Accessor) {
 					baseMembers = baseType.GetAccessors(m => m.Name == member.Name && !m.IsExplicitInterfaceImplementation, GetMemberOptions.IgnoreInheritedMembers);
 				} else {
 					baseMembers = baseType.GetMembers(m => m.Name == member.Name && !m.IsExplicitInterfaceImplementation, GetMemberOptions.IgnoreInheritedMembers);

ICSharpCode.NRefactory/TypeSystem/ParameterListComparer.cs

@@ -111,7 +111,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			if (x == y)
 				return true;
-			if (x == null || y == null || x.EntityType != y.EntityType || !nameComparer.Equals(x.Name, y.Name))
+			if (x == null || y == null || x.SymbolKind != y.SymbolKind || !nameComparer.Equals(x.Name, y.Name))
 				return false;
 			IParameterizedMember px = x as IParameterizedMember;
 			IParameterizedMember py = y as IParameterizedMember;
@@ -129,7 +129,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		public int GetHashCode(IMember obj)
 		{
 			unchecked {
-				int hash = (int)obj.EntityType * 33 + nameComparer.GetHashCode(obj.Name);
+				int hash = (int)obj.SymbolKind * 33 + nameComparer.GetHashCode(obj.Name);
 				IParameterizedMember pm = obj as IParameterizedMember;
 				if (pm != null) {
 					hash *= 27;

ICSharpCode.NRefactory/TypeSystem/ReflectionHelper.cs

@@ -95,9 +95,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				return new ByReferenceTypeReference(ToTypeReference(type.GetElementType()));
 			} else if (type.IsGenericParameter) {
 				if (type.DeclaringMethod != null) {
-					return TypeParameterReference.Create(EntityType.Method, type.GenericParameterPosition);
+					return TypeParameterReference.Create(SymbolKind.Method, type.GenericParameterPosition);
 				} else {
-					return TypeParameterReference.Create(EntityType.TypeDefinition, type.GenericParameterPosition);
+					return TypeParameterReference.Create(SymbolKind.TypeDefinition, type.GenericParameterPosition);
 				}
 			} else if (type.DeclaringType != null) {
 				if (type == typeof(Dynamic))
@@ -249,11 +249,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 					// method type parameter reference
 					pos++;
 					int index = ReadTypeParameterCount(reflectionTypeName, ref pos);
-					reference = TypeParameterReference.Create(EntityType.Method, index);
+					reference = TypeParameterReference.Create(SymbolKind.Method, index);
 				} else {
 					// class type parameter reference
 					int index = ReadTypeParameterCount(reflectionTypeName, ref pos);
-					reference = TypeParameterReference.Create(EntityType.TypeDefinition, index);
+					reference = TypeParameterReference.Create(SymbolKind.TypeDefinition, index);
 				}
 			} else {
 				// not a type parameter reference: read the actual type name

ICSharpCode.NRefactory/TypeSystem/TypeParameterSubstitution.cs

@@ -148,12 +148,12 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		public override IType VisitTypeParameter(ITypeParameter type)
 		{
 			int index = type.Index;
-			if (classTypeArguments != null && type.OwnerType == EntityType.TypeDefinition) {
+			if (classTypeArguments != null && type.OwnerType == SymbolKind.TypeDefinition) {
 				if (index >= 0 && index < classTypeArguments.Count)
 					return classTypeArguments[index];
 				else
 					return SpecialType.UnknownType;
-			} else if (methodTypeArguments != null && type.OwnerType == EntityType.Method) {
+			} else if (methodTypeArguments != null && type.OwnerType == SymbolKind.Method) {
 				if (index >= 0 && index < methodTypeArguments.Count)
 					return methodTypeArguments[index];
 				else