From 7c388ba920693991ed207da4e8ade81d8d345044 Mon Sep 17 00:00:00 2001 From: Daniel Grunwald Date: Wed, 12 Jun 2013 23:05:13 +0200 Subject: [PATCH] Rename EntityType -> SymbolKind --- .../Analysis/SemanticHighlightingVisitor.cs | 16 ++--- .../Ast/DocumentationReference.cs | 28 ++++----- .../Ast/GeneralScope/DelegateDeclaration.cs | 4 +- .../Ast/GeneralScope/TypeDeclaration.cs | 4 +- .../Ast/TypeMembers/Accessor.cs | 4 +- .../Ast/TypeMembers/ConstructorDeclaration.cs | 4 +- .../Ast/TypeMembers/DestructorDeclaration.cs | 4 +- .../Ast/TypeMembers/EntityDeclaration.cs | 2 +- .../Ast/TypeMembers/EnumMemberDeclaration.cs | 4 +- .../Ast/TypeMembers/EventDeclaration.cs | 8 +-- .../Ast/TypeMembers/FieldDeclaration.cs | 4 +- .../Ast/TypeMembers/FixedFieldDeclaration.cs | 4 +- .../Ast/TypeMembers/IndexerDeclaration.cs | 4 +- .../Ast/TypeMembers/MethodDeclaration.cs | 4 +- .../Ast/TypeMembers/OperatorDeclaration.cs | 4 +- .../Ast/TypeMembers/PropertyDeclaration.cs | 4 +- .../Completion/CSharpCompletionEngine.cs | 12 ++-- .../Completion/CompletionDataWrapper.cs | 6 +- .../OutputVisitor/CSharpAmbience.cs | 30 +++++----- .../OutputVisitor/CSharpOutputVisitor.cs | 12 ++-- .../OutputVisitor/CodeDomConvertVisitor.cs | 22 +++---- .../Parser/CSharpParser.cs | 6 +- .../InconsistentNamingIssue.cs | 2 +- .../CodeIssues/RedundantTypeCastIssue.cs | 2 +- .../Refactoring/TypeSystemAstBuilder.cs | 22 +++---- .../Resolver/CSharpOperators.cs | 4 +- .../Resolver/CSharpResolver.cs | 2 +- .../Resolver/FindReferences.cs | 22 +++---- .../Resolver/MemberLookup.cs | 8 +-- .../Resolver/ReducedExtensionMethod.cs | 4 +- .../Resolver/ResolveVisitor.cs | 42 +++++++------- .../Resolver/TypeInference.cs | 2 +- .../TypeSystem/CSharpAssembly.cs | 4 +- .../TypeSystem/CSharpAttribute.cs | 2 +- ...odTypeParameterWithInheritedConstraints.cs | 2 +- .../TypeSystem/ResolvedUsingScope.cs | 4 +- .../TypeSystem/TypeSystemConvertVisitor.cs | 38 ++++++------ .../FindReferencesConsistencyCheck.cs | 16 ++--- .../CSharp/Resolver/AnonymousTypeTests.cs | 4 +- .../CSharp/Resolver/ConversionsTest.cs | 20 +++---- .../Resolver/OverloadResolutionTests.cs | 12 ++-- .../CSharp/Resolver/ResolveAtLocationTests.cs | 2 +- .../CSharp/Resolver/TypeInferenceTests.cs | 28 ++++----- .../Documentation/CSharpCrefParserTests.cs | 20 +++---- .../Documentation/IDStringTests.cs | 14 ++--- .../TypeSystem/GetAllBaseTypesTest.cs | 4 +- .../TypeSystem/GetMembersTests.cs | 4 +- .../TypeSystem/TypeParameterTests.cs | 24 ++++---- .../TypeSystem/TypeSystemTests.cs | 20 +++---- .../Documentation/IdStringMemberReference.cs | 20 +++---- .../Documentation/IdStringProvider.cs | 20 +++---- .../Semantics/MemberResolveResult.cs | 4 +- .../TypeSystem/CecilLoader.cs | 50 ++++++++-------- .../TypeSystem/EntityType.cs | 2 +- ICSharpCode.NRefactory/TypeSystem/IEntity.cs | 2 +- ICSharpCode.NRefactory/TypeSystem/ISymbol.cs | 2 +- .../TypeSystem/ITypeParameter.cs | 8 +-- .../TypeSystem/IkvmLoader.cs | 58 +++++++++---------- .../Implementation/AbstractResolvedEntity.cs | 6 +- .../Implementation/AbstractResolvedMember.cs | 4 +- .../AbstractResolvedTypeParameter.cs | 18 +++--- .../AbstractUnresolvedEntity.cs | 8 +-- .../AbstractUnresolvedMember.cs | 14 ++--- .../Implementation/DefaultMemberReference.cs | 20 +++---- .../Implementation/DefaultParameter.cs | 4 +- .../Implementation/DefaultResolvedMethod.cs | 4 +- .../Implementation/DefaultResolvedProperty.cs | 2 +- .../DefaultResolvedTypeDefinition.cs | 16 ++--- .../DefaultResolvedTypeParameter.cs | 4 +- .../DefaultUnresolvedAssembly.cs | 4 +- .../DefaultUnresolvedAttribute.cs | 4 +- .../Implementation/DefaultUnresolvedEvent.cs | 4 +- .../Implementation/DefaultUnresolvedField.cs | 4 +- .../Implementation/DefaultUnresolvedMethod.cs | 18 +++--- .../DefaultUnresolvedParameter.cs | 2 +- .../DefaultUnresolvedProperty.cs | 8 +-- .../DefaultUnresolvedTypeDefinition.cs | 8 +-- .../DefaultUnresolvedTypeParameter.cs | 14 ++--- .../Implementation/DummyTypeParameter.cs | 30 +++++----- ...tInterfaceImplementationMemberReference.cs | 4 +- .../Implementation/MergedNamespace.cs | 4 +- .../Implementation/MinimalCorlib.cs | 2 +- .../Implementation/SpecializedMember.cs | 6 +- .../Implementation/TypeParameterReference.cs | 16 ++--- .../TypeSystem/InheritanceHelper.cs | 2 +- .../TypeSystem/ParameterListComparer.cs | 4 +- .../TypeSystem/ReflectionHelper.cs | 8 +-- .../TypeSystem/TypeParameterSubstitution.cs | 4 +- 88 files changed, 465 insertions(+), 465 deletions(-) diff --git a/ICSharpCode.NRefactory.CSharp/Analysis/SemanticHighlightingVisitor.cs b/ICSharpCode.NRefactory.CSharp/Analysis/SemanticHighlightingVisitor.cs index c6fc1c0dc..8db19292a 100644 --- a/ICSharpCode.NRefactory.CSharp/Analysis/SemanticHighlightingVisitor.cs +++ b/ICSharpCode.NRefactory.CSharp/Analysis/SemanticHighlightingVisitor.cs @@ -293,7 +293,7 @@ public override void VisitInvocationExpression(InvocationExpression invocationEx #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 @@ void HandleConstructorOrDestructor(AstNode constructorDeclaration) 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); diff --git a/ICSharpCode.NRefactory.CSharp/Ast/DocumentationReference.cs b/ICSharpCode.NRefactory.CSharp/Ast/DocumentationReference.cs index 8d677c1c2..633f921b2 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/DocumentationReference.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/DocumentationReference.cs @@ -29,29 +29,29 @@ public class DocumentationReference : AstNode public static readonly Role DeclaringTypeRole = new Role("DeclaringType", AstType.Null); public static readonly Role ConversionOperatorReturnTypeRole = new Role("ConversionOperatorReturnType", AstType.Null); - EntityType entityType; + SymbolKind symbolKind; OperatorType operatorType; bool hasParameterList; /// /// Gets/Sets the entity type. /// Possible values are: - /// EntityType.Operator for operators, - /// EntityType.Indexer for indexers, - /// EntityType.TypeDefinition for references to primitive types, - /// and EntityType.None for everything else. + /// SymbolKind.Operator for operators, + /// SymbolKind.Indexer for indexers, + /// SymbolKind.TypeDefinition for references to primitive types, + /// and SymbolKind.None for everything else. /// - public EntityType EntityType { - get { return entityType; } + public SymbolKind SymbolKind { + get { return symbolKind; } set { ThrowIfFrozen(); - entityType = value; + symbolKind = value; } } /// /// Gets/Sets the operator type. - /// This property is only used when EntityType==Operator. + /// This property is only used when SymbolKind==Operator. /// public OperatorType OperatorType { get { return operatorType; } @@ -86,7 +86,7 @@ public AstType DeclaringType { /// /// Gets/sets the member name. - /// This property is only used when EntityType==None. + /// This property is only used when SymbolKind==None. /// public string MemberName { get { return GetChildByRole(Roles.Identifier).Name; } @@ -95,7 +95,7 @@ public string MemberName { /// /// 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. /// public AstType ConversionOperatorReturnType { get { return GetChildByRole(ConversionOperatorReturnTypeRole); } @@ -113,16 +113,16 @@ public AstNodeCollection Parameters { 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)) diff --git a/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/DelegateDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/DelegateDeclaration.cs index 088afa90b..68489bc7f 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/DelegateDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/DelegateDeclaration.cs @@ -37,8 +37,8 @@ public override NodeType NodeType { get { return NodeType.TypeDeclaration; } } - public override EntityType EntityType { - get { return EntityType.TypeDefinition; } + public override SymbolKind SymbolKind { + get { return SymbolKind.TypeDefinition; } } public CSharpTokenNode DelegateToken { diff --git a/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/TypeDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/TypeDeclaration.cs index d4ac6eaf6..1aba4f331 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/TypeDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/TypeDeclaration.cs @@ -47,8 +47,8 @@ public override NodeType NodeType { get { return NodeType.TypeDeclaration; } } - public override EntityType EntityType { - get { return EntityType.TypeDefinition; } + public override SymbolKind SymbolKind { + get { return SymbolKind.TypeDefinition; } } ClassType classType; diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/Accessor.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/Accessor.cs index dc0d7477f..ae73d1d5a 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/Accessor.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/Accessor.cs @@ -67,8 +67,8 @@ public override NodeType NodeType { get { return NodeType.Unknown; } } - public override EntityType EntityType { - get { return EntityType.Method; } + public override SymbolKind SymbolKind { + get { return SymbolKind.Method; } } /// diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/ConstructorDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/ConstructorDeclaration.cs index c8e742919..6a3f59aec 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/ConstructorDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/ConstructorDeclaration.cs @@ -32,8 +32,8 @@ public class ConstructorDeclaration : EntityDeclaration { public static readonly Role InitializerRole = new Role("Initializer", ConstructorInitializer.Null); - public override EntityType EntityType { - get { return EntityType.Constructor; } + public override SymbolKind SymbolKind { + get { return SymbolKind.Constructor; } } public CSharpTokenNode LParToken { diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/DestructorDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/DestructorDeclaration.cs index 5f2411ec8..0609e5dc6 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/DestructorDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/DestructorDeclaration.cs @@ -36,8 +36,8 @@ public CSharpTokenNode TildeToken { get { return GetChildByRole (TildeRole); } } - public override EntityType EntityType { - get { return EntityType.Destructor; } + public override SymbolKind SymbolKind { + get { return SymbolKind.Destructor; } } public CSharpTokenNode LParToken { diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EntityDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EntityDeclaration.cs index 8ba649f4d..c02ff21b6 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EntityDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EntityDeclaration.cs @@ -33,7 +33,7 @@ public override NodeType NodeType { get { return NodeType.Member; } } - public abstract NRefactory.TypeSystem.EntityType EntityType { get; } + public abstract NRefactory.TypeSystem.SymbolKind SymbolKind { get; } public AstNodeCollection Attributes { get { return base.GetChildrenByRole (AttributeRole); } diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EnumMemberDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EnumMemberDeclaration.cs index 8aabb39f9..b7c924ab9 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EnumMemberDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EnumMemberDeclaration.cs @@ -33,8 +33,8 @@ public class EnumMemberDeclaration : EntityDeclaration { public static readonly Role InitializerRole = new Role("Initializer", Expression.Null); - public override EntityType EntityType { - get { return EntityType.Field; } + public override SymbolKind SymbolKind { + get { return SymbolKind.Field; } } public CSharpTokenNode AssignToken { diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EventDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EventDeclaration.cs index 9c9e900e3..d543f9ea7 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EventDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EventDeclaration.cs @@ -36,8 +36,8 @@ public class EventDeclaration : EntityDeclaration { 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 @@ public class CustomEventDeclaration : EntityDeclaration public static readonly Role AddAccessorRole = new Role("AddAccessor", Accessor.Null); public static readonly Role RemoveAccessorRole = new Role("RemoveAccessor", Accessor.Null); - public override EntityType EntityType { - get { return EntityType.Event; } + public override SymbolKind SymbolKind { + get { return SymbolKind.Event; } } /// diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FieldDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FieldDeclaration.cs index d9af2f374..de220ecd7 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FieldDeclaration.cs +++ b/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 Variables { diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FixedFieldDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FixedFieldDeclaration.cs index ebc20c5ef..fea2a2af2 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FixedFieldDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FixedFieldDeclaration.cs @@ -33,8 +33,8 @@ public class FixedFieldDeclaration : EntityDeclaration public static readonly TokenRole FixedKeywordRole = new TokenRole ("fixed"); public static readonly Role VariableRole = new Role ("FixedVariable"); - public override EntityType EntityType { - get { return EntityType.Field; } + public override SymbolKind SymbolKind { + get { return SymbolKind.Field; } } public CSharpTokenNode FixedToken { diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/IndexerDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/IndexerDeclaration.cs index d82001920..a958797e8 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/IndexerDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/IndexerDeclaration.cs @@ -36,8 +36,8 @@ public class IndexerDeclaration : EntityDeclaration public static readonly Role GetterRole = PropertyDeclaration.GetterRole; public static readonly Role SetterRole = PropertyDeclaration.SetterRole; - public override EntityType EntityType { - get { return EntityType.Indexer; } + public override SymbolKind SymbolKind { + get { return SymbolKind.Indexer; } } /// diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/MethodDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/MethodDeclaration.cs index 0d4a2340b..90aaa3047 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/MethodDeclaration.cs +++ b/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; } } /// diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/OperatorDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/OperatorDeclaration.cs index f0a07e84d..b4ae52a2a 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/OperatorDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/OperatorDeclaration.cs @@ -106,8 +106,8 @@ public class OperatorDeclaration : EntityDeclaration 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; diff --git a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/PropertyDeclaration.cs b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/PropertyDeclaration.cs index df0fa9876..1f137e0c9 100644 --- a/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/PropertyDeclaration.cs +++ b/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/PropertyDeclaration.cs @@ -34,8 +34,8 @@ public class PropertyDeclaration : EntityDeclaration public static readonly Role GetterRole = new Role("Getter", Accessor.Null); public static readonly Role SetterRole = new Role("Setter", Accessor.Null); - public override EntityType EntityType { - get { return EntityType.Property; } + public override SymbolKind SymbolKind { + get { return SymbolKind.Property; } } /// diff --git a/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs b/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs index c526f6d8e..093990990 100644 --- a/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs +++ b/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs @@ -317,14 +317,14 @@ IEnumerable HandleObjectInitializer(SyntaxTree unit, AstNode n) 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 @@ void AddTypesAndNamespaces(CompletionDataWrapper wrapper, CSharpResolver state, 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 @@ public string GetPreviousMemberReferenceExpression(int tokenIndex) 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 @@ out trr 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 @@ out trr if (member is IMethod && ((IMethod)member).FullName == "System.Object.Finalize") { continue; } - if (member.EntityType == EntityType.Operator) { + if (member.SymbolKind == SymbolKind.Operator) { continue; } diff --git a/ICSharpCode.NRefactory.CSharp/Completion/CompletionDataWrapper.cs b/ICSharpCode.NRefactory.CSharp/Completion/CompletionDataWrapper.cs index 1ac8de493..24e18d818 100644 --- a/ICSharpCode.NRefactory.CSharp/Completion/CompletionDataWrapper.cs +++ b/ICSharpCode.NRefactory.CSharp/Completion/CompletionDataWrapper.cs @@ -1,4 +1,4 @@ -// +// // CompletionDataWrapper.cs // // Author: @@ -172,14 +172,14 @@ public ICompletionData AddMember (IMember member) List 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; } diff --git a/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs b/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs index 043461bd7..8d7522529 100644 --- a/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs +++ b/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs @@ -96,7 +96,7 @@ public void ConvertEntity(IEntity entity, IOutputFormatter formatter, CSharpForm 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 @@ public void ConvertEntity(IEntity entity, IOutputFormatter formatter, CSharpForm } 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 @@ public void ConvertEntity(IEntity entity, IOutputFormatter formatter, CSharpForm 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 @@ void WriteMemberDeclarationName(IMember member, IOutputFormatter formatter, CSha 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 @@ void WriteMemberDeclarationName(IMember member, IOutputFormatter formatter, CSha 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)); } diff --git a/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpOutputVisitor.cs b/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpOutputVisitor.cs index c0c6f4b79..46390a06b 100644 --- a/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpOutputVisitor.cs +++ b/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpOutputVisitor.cs @@ -2597,18 +2597,18 @@ public void VisitDocumentationReference(DocumentationReference documentationRefe 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 @@ public void VisitDocumentationReference(DocumentationReference documentationRefe 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); diff --git a/ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs b/ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs index f22091776..830e2672d 100644 --- a/ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs +++ b/ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs @@ -685,7 +685,7 @@ CodeAttributeDeclaration[] Convert(IEnumerable attributeSectio CodeObject IAstVisitor.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 @@ CodeObject IAstVisitor.VisitDelegateDeclaration(DelegateDeclaration 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 @@ CodeObject IAstVisitor.VisitTypeDeclaration(TypeDeclaration typeDecl { //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 @@ CodeObject IAstVisitor.VisitAccessor(Accessor accessor) CodeObject IAstVisitor.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 @@ CodeObject IAstVisitor.VisitEventDeclaration(EventDeclaration eventD } 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 @@ CodeObject IAstVisitor.VisitFieldDeclaration(FieldDeclaration fieldD { 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 @@ CodeObject IAstVisitor.VisitFieldDeclaration(FieldDeclaration fieldD CodeObject IAstVisitor.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 @@ CodeObject IAstVisitor.VisitIndexerDeclaration(IndexerDeclaration in CodeObject IAstVisitor.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 @@ CodeObject IAstVisitor.VisitMethodDeclaration(MethodDeclaration meth CodeObject IAstVisitor.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 @@ CodeParameterDeclarationExpression[] Convert(IEnumerable p CodeObject IAstVisitor.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); diff --git a/ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs b/ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs index 59b829a15..0d4a0fd05 100644 --- a/ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs +++ b/ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs @@ -3573,7 +3573,7 @@ public DocumentationReference ConvertXmlDoc(DocumentationBuilder doc) DocumentationReference result = new DocumentationReference(); if (doc.ParsedName != null) { if (doc.ParsedName.Name == "") { - result.EntityType = EntityType.Indexer; + result.SymbolKind = SymbolKind.Indexer; } else { result.MemberName = doc.ParsedName.Name; } @@ -3588,7 +3588,7 @@ public DocumentationReference ConvertXmlDoc(DocumentationBuilder doc) } } } 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 @@ public DocumentationReference ConvertXmlDoc(DocumentationBuilder doc) 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(); diff --git a/ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/InconsistentNamingIssue/InconsistentNamingIssue.cs b/ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/InconsistentNamingIssue/InconsistentNamingIssue.cs index b1ad18321..b39f67780 100644 --- a/ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/InconsistentNamingIssue/InconsistentNamingIssue.cs +++ b/ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/InconsistentNamingIssue/InconsistentNamingIssue.cs @@ -93,7 +93,7 @@ void CheckName(MethodDeclaration node, AffectedEntity entity, Identifier identif 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; } diff --git a/ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/RedundantTypeCastIssue.cs b/ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/RedundantTypeCastIssue.cs index 60d583aa0..31ed10f2b 100644 --- a/ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/RedundantTypeCastIssue.cs +++ b/ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/RedundantTypeCastIssue.cs @@ -96,7 +96,7 @@ bool IsExplicitImplementation(IType exprType, IType interfaceType, Expression ty 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; } diff --git a/ICSharpCode.NRefactory.CSharp/Refactoring/TypeSystemAstBuilder.cs b/ICSharpCode.NRefactory.CSharp/Refactoring/TypeSystemAstBuilder.cs index f3ed1e848..6be4c5401 100644 --- a/ICSharpCode.NRefactory.CSharp/Refactoring/TypeSystemAstBuilder.cs +++ b/ICSharpCode.NRefactory.CSharp/Refactoring/TypeSystemAstBuilder.cs @@ -486,27 +486,27 @@ public EntityDeclaration ConvertEntity(IEntity entity) { 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); } } diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs b/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs index ae6361230..1588b6b2d 100644 --- a/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs +++ b/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs @@ -147,8 +147,8 @@ bool IMember.IsOverridable { get { return false; } } - EntityType ISymbol.EntityType { - get { return EntityType.Operator; } + SymbolKind ISymbol.SymbolKind { + get { return SymbolKind.Operator; } } DomRegion IEntity.Region { diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs b/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs index 32615c00f..34fd5c2ad 100644 --- a/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs +++ b/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs @@ -1696,7 +1696,7 @@ ResolveResult ResolveMemberAccessOnNamespace(NamespaceResolveResult nrr, string 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); } diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/FindReferences.cs b/ICSharpCode.NRefactory.CSharp/Resolver/FindReferences.cs index 7ba41a91a..54f48bb38 100644 --- a/ICSharpCode.NRefactory.CSharp/Resolver/FindReferences.cs +++ b/ICSharpCode.NRefactory.CSharp/Resolver/FindReferences.cs @@ -230,45 +230,45 @@ public IList GetSearchScopes(IEntity entity) 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; diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/MemberLookup.cs b/ICSharpCode.NRefactory.CSharp/Resolver/MemberLookup.cs index 9d5d98969..e393211b4 100644 --- a/ICSharpCode.NRefactory.CSharp/Resolver/MemberLookup.cs +++ b/ICSharpCode.NRefactory.CSharp/Resolver/MemberLookup.cs @@ -124,7 +124,7 @@ bool IsProtectedAccessible(bool allowProtectedAccess, IEntity entity) { // 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 @@ public ResolveResult Lookup(ResolveResult targetResolveResult, string name, ILis }; Predicate 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 @@ void AddMembers(IType type, IEnumerable members, } } 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; diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/ReducedExtensionMethod.cs b/ICSharpCode.NRefactory.CSharp/Resolver/ReducedExtensionMethod.cs index 86bfbcc1a..49b73670b 100644 --- a/ICSharpCode.NRefactory.CSharp/Resolver/ReducedExtensionMethod.cs +++ b/ICSharpCode.NRefactory.CSharp/Resolver/ReducedExtensionMethod.cs @@ -267,9 +267,9 @@ public System.Collections.Generic.IList Parameters { #region IEntity implementation - public EntityType EntityType { + public SymbolKind SymbolKind { get { - return baseMethod.EntityType; + return baseMethod.SymbolKind; } } diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs b/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs index 12458abee..9c5612d41 100644 --- a/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs +++ b/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs @@ -653,20 +653,20 @@ ResolveResult IAstVisitor.VisitDelegateDeclaration(DelegateDeclar #region Track CurrentMember ResolveResult IAstVisitor.VisitFieldDeclaration(FieldDeclaration fieldDeclaration) { - return VisitFieldOrEventDeclaration(fieldDeclaration, EntityType.Field); + return VisitFieldOrEventDeclaration(fieldDeclaration, SymbolKind.Field); } ResolveResult IAstVisitor.VisitFixedFieldDeclaration(FixedFieldDeclaration fixedFieldDeclaration) { - return VisitFieldOrEventDeclaration(fixedFieldDeclaration, EntityType.Field); + return VisitFieldOrEventDeclaration(fixedFieldDeclaration, SymbolKind.Field); } ResolveResult IAstVisitor.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 @@ ResolveResult VisitFieldOrEventDeclaration(EntityDeclaration fieldOrEventDeclara 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 @@ ResolveResult VisitMethodMember(EntityDeclaration memberDeclaration) 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 @@ ResolveResult VisitMethodMember(EntityDeclaration memberDeclaration) explicitInterfaceType = explicitInterfaceAstType.ToTypeReference(); } member = AbstractUnresolvedMember.Resolve( - resolver.CurrentTypeResolveContext, entityType, memberDeclaration.Name, + resolver.CurrentTypeResolveContext, symbolKind, memberDeclaration.Name, explicitInterfaceType, typeParameterNames, parameterTypes); } } @@ -868,7 +868,7 @@ ResolveResult VisitPropertyMember(EntityDeclaration propertyOrIndexerDeclaration 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 @@ ResolveResult IAstVisitor.VisitCustomEventDeclaration(CustomEvent 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 @@ ResolveResult IAstVisitor.VisitAnonymousTypeCreateExpression(Anon Name = "get_" + name, Accessibility = Accessibility.Public, ReturnType = returnTypeRef, - EntityType = EntityType.Accessor, + SymbolKind = SymbolKind.Accessor, AccessorOwner = property }; unresolvedProperties.Add(property); @@ -3145,8 +3145,8 @@ public SimpleVariable(DomRegion region, IType type, string name) this.name = name; } - public EntityType EntityType { - get { return EntityType.Variable; } + public SymbolKind SymbolKind { + get { return SymbolKind.Variable; } } public string Name { @@ -3965,14 +3965,14 @@ ResolveResult IAstVisitor.VisitDocumentationReference(Documentati 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 @@ ResolveResult IAstVisitor.VisitDocumentationReference(Documentati // 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); diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/TypeInference.cs b/ICSharpCode.NRefactory.CSharp/Resolver/TypeInference.cs index 70132fefc..abea6edc0 100644 --- a/ICSharpCode.NRefactory.CSharp/Resolver/TypeInference.cs +++ b/ICSharpCode.NRefactory.CSharp/Resolver/TypeInference.cs @@ -125,7 +125,7 @@ public IType[] InferTypeArguments(IList typeParameters, IList> IAttribute.NamedArguments { } else { namedArgs = new List>(); 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(member, val)); diff --git a/ICSharpCode.NRefactory.CSharp/TypeSystem/MethodTypeParameterWithInheritedConstraints.cs b/ICSharpCode.NRefactory.CSharp/TypeSystem/MethodTypeParameterWithInheritedConstraints.cs index 05b01af55..fc9e6cd86 100644 --- a/ICSharpCode.NRefactory.CSharp/TypeSystem/MethodTypeParameterWithInheritedConstraints.cs +++ b/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) { } diff --git a/ICSharpCode.NRefactory.CSharp/TypeSystem/ResolvedUsingScope.cs b/ICSharpCode.NRefactory.CSharp/TypeSystem/ResolvedUsingScope.cs index 719768966..5ea1016be 100644 --- a/ICSharpCode.NRefactory.CSharp/TypeSystem/ResolvedUsingScope.cs +++ b/ICSharpCode.NRefactory.CSharp/TypeSystem/ResolvedUsingScope.cs @@ -166,8 +166,8 @@ public string Name { get { return name; } } - EntityType ISymbol.EntityType { - get { return EntityType.Namespace; } + SymbolKind ISymbol.SymbolKind { + get { return SymbolKind.Namespace; } } INamespace INamespace.ParentNamespace { diff --git a/ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs b/ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs index 55cdad7a0..b82a3888d 100644 --- a/ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs +++ b/ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs @@ -223,7 +223,7 @@ public override IUnresolvedEntity VisitTypeDeclaration(TypeDeclaration typeDecla 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 @@ public override IUnresolvedEntity VisitDelegateDeclaration(DelegateDeclaration d 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 parameters = new List(); @@ -332,7 +332,7 @@ public static void AddDefaultMethodsToDelegate(DefaultUnresolvedTypeDefinition d 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 @@ public override IUnresolvedEntity VisitEnumMemberDeclaration(EnumMemberDeclarati } 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 @@ public override IUnresolvedEntity VisitMethodDeclaration(MethodDeclaration metho 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 @@ public override IUnresolvedEntity VisitMethodDeclaration(MethodDeclaration metho 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 @@ bool InheritsConstraints(MethodDeclaration methodDeclaration) } void ConvertTypeParameters(IList output, AstNodeCollection typeParameters, - AstNodeCollection constraints, EntityType ownerType) + AstNodeCollection 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 @@ void ConvertTypeParameters(IList output, AstNodeCollec 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 @@ void ConvertTypeParameters(IList output, AstNodeCollec 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 @@ public override IUnresolvedEntity VisitConstructorDeclaration(ConstructorDeclara 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 @@ public override IUnresolvedEntity VisitConstructorDeclaration(ConstructorDeclara 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 @@ public override IUnresolvedEntity VisitPropertyDeclaration(PropertyDeclaration p 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 @@ public override IUnresolvedEntity VisitPropertyDeclaration(PropertyDeclaration p 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 @@ public override IUnresolvedEntity VisitIndexerDeclaration(IndexerDeclaration ind 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 @@ DefaultUnresolvedMethod ConvertAccessor(Accessor accessor, IUnresolvedMember p, 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 @@ DefaultUnresolvedMethod ConvertAccessor(Accessor accessor, IUnresolvedMember p, // 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 @@ DefaultUnresolvedMethod ConvertAccessor(Accessor accessor, IUnresolvedMember p, 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 @@ public override IUnresolvedEntity VisitEventDeclaration(EventDeclaration eventDe 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 @@ public override IUnresolvedEntity VisitCustomEventDeclaration(CustomEventDeclara 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 diff --git a/ICSharpCode.NRefactory.ConsistencyCheck/FindReferencesConsistencyCheck.cs b/ICSharpCode.NRefactory.ConsistencyCheck/FindReferencesConsistencyCheck.cs index 3b4590e84..1ad62c900 100644 --- a/ICSharpCode.NRefactory.ConsistencyCheck/FindReferencesConsistencyCheck.cs +++ b/ICSharpCode.NRefactory.ConsistencyCheck/FindReferencesConsistencyCheck.cs @@ -84,8 +84,8 @@ bool IgnoreEntity(IEntity entity) //return entity.FullName != "ICSharpCode.NRefactory.TypeSystem.Implementation.DefaultResolvedTypeDefinition.parts"; } - Dictionary timings = new Dictionary(); - Dictionary entityCount = new Dictionary(); + Dictionary timings = new Dictionary(); + Dictionary entityCount = new Dictionary(); void TestFindReferences(IEntity entity) { @@ -119,10 +119,10 @@ void TestFindReferences(IEntity entity) }, 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 @@ void TestFindReferences(IEntity entity) } } - 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; } } diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/AnonymousTypeTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/AnonymousTypeTests.cs index bd7983711..978404eea 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/AnonymousTypeTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/AnonymousTypeTests.cs @@ -58,7 +58,7 @@ public void ZipItem1() var rr = Resolve(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 @@ public void ZipAnonymousType() string program = programStart + "var q = list1.Zip(list2, (a,b) => $new { a, b }$);" + programEnd; var rr = Resolve(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); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConversionsTest.cs b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConversionsTest.cs index 945b80a13..ed1e7d0ea 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConversionsTest.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConversionsTest.cs @@ -257,9 +257,9 @@ public void NoConversionFromPointerTypeToObject() [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 @@ public void UnconstrainedTypeParameter() [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 @@ public void TypeParameterWithReferenceTypeConstraint() [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 @@ public void TypeParameterWithValueTypeConstraint() [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 @@ public void TypeParameterWithClassConstraint() [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 @@ public void ExpansiveInheritance() var b = new DefaultUnresolvedTypeDefinition(string.Empty, "B"); // interface A 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 : A>> { } - 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); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/OverloadResolutionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/OverloadResolutionTests.cs index 4429df05b..513bfc5a1 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/OverloadResolutionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/OverloadResolutionTests.cs @@ -177,28 +177,28 @@ public void SkeetEvilOverloadResolution() // static void Foo(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 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(ClassConstraint ignored = default(ClassConstraint)) // 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() 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); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ResolveAtLocationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ResolveAtLocationTests.cs index 5bf6a72fa..31d03134a 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ResolveAtLocationTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ResolveAtLocationTests.cs @@ -130,7 +130,7 @@ public void Indexer() var rr = ResolveAtLocation( "using System.Collections.Generic;" + "public class A { int M(List a) { return a$[1]; } }"); - Assert.AreEqual(EntityType.Indexer, rr.Member.EntityType); + Assert.AreEqual(SymbolKind.Indexer, rr.Member.SymbolKind); } [Test] diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/TypeInferenceTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/TypeInferenceTests.cs index 4d120f9ee..039434fca 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/TypeInferenceTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/TypeInferenceTests.cs @@ -55,7 +55,7 @@ IType[] Resolve(params Type[] types) [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 @@ public void ArrayToEnumerable() [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 @@ public void ArrayToReadOnlyList() [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 @@ public void EnumerableToArrayInContravariantType() public void InferFromObjectAndFromNullLiteral() { // M(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 @@ public void InferFromObjectAndFromNullLiteral() [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 @@ public void ArrayToListWithArrayCovariance() [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)); var ienumerableOfDynamic = compilation.FindType(typeof(IEnumerable)); @@ -179,8 +179,8 @@ public void CannotInferFromMethodParameterTypes() { // static void M(Func 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 @@ public void InferFromMethodReturnType() // static void M(Func 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 @@ public override string ToString() 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 @@ public void TestLambdaInference() [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(), diff --git a/ICSharpCode.NRefactory.Tests/Documentation/CSharpCrefParserTests.cs b/ICSharpCode.NRefactory.Tests/Documentation/CSharpCrefParserTests.cs index 06219c208..52cb01d1e 100644 --- a/ICSharpCode.NRefactory.Tests/Documentation/CSharpCrefParserTests.cs +++ b/ICSharpCode.NRefactory.Tests/Documentation/CSharpCrefParserTests.cs @@ -44,7 +44,7 @@ public void This() ParseUtilCSharp.AssertDocumentationReference( "this", new DocumentationReference { - EntityType = EntityType.Indexer + SymbolKind = SymbolKind.Indexer }); } @@ -55,7 +55,7 @@ public void ThisWithParameter() 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 @@ public void ThisWithDeclaringType() ParseUtilCSharp.AssertDocumentationReference( "List{T}.this", new DocumentationReference { - EntityType = EntityType.Indexer, + SymbolKind = SymbolKind.Indexer, DeclaringType = new SimpleType("List", new SimpleType("T")) }); } @@ -101,7 +101,7 @@ public void PrimitiveType() ParseUtilCSharp.AssertDocumentationReference( "int", new DocumentationReference { - EntityType = EntityType.TypeDefinition, + SymbolKind = SymbolKind.TypeDefinition, DeclaringType = new PrimitiveType("int") }); } @@ -211,7 +211,7 @@ public void OperatorPlus() ParseUtilCSharp.AssertDocumentationReference( "operator +", new DocumentationReference { - EntityType = EntityType.Operator, + SymbolKind = SymbolKind.Operator, OperatorType = OperatorType.Addition }); } @@ -224,7 +224,7 @@ public void OperatorPlusWithDeclaringType() "Test.operator +", new DocumentationReference { DeclaringType = new SimpleType("Test"), - EntityType = EntityType.Operator, + SymbolKind = SymbolKind.Operator, OperatorType = OperatorType.Addition }); } @@ -235,7 +235,7 @@ public void OperatorPlusWithParameterList() ParseUtilCSharp.AssertDocumentationReference( "operator +(Test, int)", new DocumentationReference { - EntityType = EntityType.Operator, + SymbolKind = SymbolKind.Operator, OperatorType = OperatorType.Addition, HasParameterList = true, Parameters = { @@ -250,7 +250,7 @@ public void ImplicitOperator() ParseUtilCSharp.AssertDocumentationReference( "implicit operator int", new DocumentationReference { - EntityType = EntityType.Operator, + SymbolKind = SymbolKind.Operator, OperatorType = OperatorType.Implicit, ConversionOperatorReturnType = new PrimitiveType("int") }); @@ -262,7 +262,7 @@ public void ExplicitOperatorWithParameterList() 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 @@ public void ExplicitOperatorWithParameterListAndDeclaringType() 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"), diff --git a/ICSharpCode.NRefactory.Tests/Documentation/IDStringTests.cs b/ICSharpCode.NRefactory.Tests/Documentation/IDStringTests.cs index 1c74df792..1f7178037 100644 --- a/ICSharpCode.NRefactory.Tests/Documentation/IDStringTests.cs +++ b/ICSharpCode.NRefactory.Tests/Documentation/IDStringTests.cs @@ -160,7 +160,7 @@ class Widget: IProcess }"; 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 @@ public void Process(MyList list) { } }"; 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 @@ public void NestedGenerics() Init("class A { class B { void M(A.B 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 @@ class Widget: IProcess }"; 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 @@ class Widget: IProcess }"; 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 @@ public static implicit operator long(Widget x) { } }"; 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] diff --git a/ICSharpCode.NRefactory.Tests/TypeSystem/GetAllBaseTypesTest.cs b/ICSharpCode.NRefactory.Tests/TypeSystem/GetAllBaseTypesTest.cs index d5a38efe6..c9088fb1e 100644 --- a/ICSharpCode.NRefactory.Tests/TypeSystem/GetAllBaseTypesTest.cs +++ b/ICSharpCode.NRefactory.Tests/TypeSystem/GetAllBaseTypesTest.cs @@ -158,8 +158,8 @@ public void ClassDerivingFromParameterizedVersionOfItself() { // class C : C> {} 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()); diff --git a/ICSharpCode.NRefactory.Tests/TypeSystem/GetMembersTests.cs b/ICSharpCode.NRefactory.Tests/TypeSystem/GetMembersTests.cs index 6398c5c61..41645472b 100644 --- a/ICSharpCode.NRefactory.Tests/TypeSystem/GetMembersTests.cs +++ b/ICSharpCode.NRefactory.Tests/TypeSystem/GetMembersTests.cs @@ -82,11 +82,11 @@ public void GetGenericNestedTypeOfBoundGenericClass() { // class A { class B { } } 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); diff --git a/ICSharpCode.NRefactory.Tests/TypeSystem/TypeParameterTests.cs b/ICSharpCode.NRefactory.Tests/TypeSystem/TypeParameterTests.cs index 20b79f2ac..7988b7157 100644 --- a/ICSharpCode.NRefactory.Tests/TypeSystem/TypeParameterTests.cs +++ b/ICSharpCode.NRefactory.Tests/TypeSystem/TypeParameterTests.cs @@ -32,9 +32,9 @@ public void TypeParameterDerivingFromOtherTypeParameterDoesNotInheritReferenceCo { // class C 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 @@ public void ValueTypeParameterDerivingFromReferenceTypeParameter() { // class C 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 @@ public void TypeParameterDerivingFromOtherTypeParameterInheritsEffectiveBaseClas { // class C where T : List 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).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 @@ public void ImportOpenGenericType() // class C { void M() {} } 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); diff --git a/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs b/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs index ae0c247b6..6ff2780bf 100644 --- a/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs +++ b/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs @@ -67,7 +67,7 @@ public void SimplePublicClassMethodTest() 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 @@ public void TypeForwardedTo_Attribute() 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 @@ public void TestMethod() 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 @@ public void GetIndex() 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 @@ public void GetIndexSpecializedTypeParameter() )); 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 @@ public void IndexerGetter() 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 @@ public void IndexerSetter() 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 @@ public void IndexerAccessorsShouldBeReportedAsImplementingTheCorrectInterfaceAcc 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)); diff --git a/ICSharpCode.NRefactory/Documentation/IdStringMemberReference.cs b/ICSharpCode.NRefactory/Documentation/IdStringMemberReference.cs index 4fb832b81..025e51a11 100644 --- a/ICSharpCode.NRefactory/Documentation/IdStringMemberReference.cs +++ b/ICSharpCode.NRefactory/Documentation/IdStringMemberReference.cs @@ -37,21 +37,21 @@ public IdStringMemberReference(ITypeReference declaringTypeReference, char membe 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()); } } diff --git a/ICSharpCode.NRefactory/Documentation/IdStringProvider.cs b/ICSharpCode.NRefactory/Documentation/IdStringProvider.cs index 1707e35de..9b275933c 100644 --- a/ICSharpCode.NRefactory/Documentation/IdStringProvider.cs +++ b/ICSharpCode.NRefactory/Documentation/IdStringProvider.cs @@ -38,19 +38,19 @@ public static class IdStringProvider 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 @@ public static string GetIdString(this IEntity entity) } 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 @@ static void AppendTypeName(StringBuilder b, IType type, bool explicitInterfaceIm 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 @@ static ITypeReference ParseTypeName(string typeName, ref int pos) // 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 diff --git a/ICSharpCode.NRefactory/Semantics/MemberResolveResult.cs b/ICSharpCode.NRefactory/Semantics/MemberResolveResult.cs index c06cc3ad2..2ad2e1855 100644 --- a/ICSharpCode.NRefactory/Semantics/MemberResolveResult.cs +++ b/ICSharpCode.NRefactory/Semantics/MemberResolveResult.cs @@ -39,7 +39,7 @@ public class MemberResolveResult : ResolveResult 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 @@ public MemberResolveResult(ResolveResult targetResult, IMember member, IType ret } 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; diff --git a/ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs b/ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs index 7b98deb24..a8b0c6b88 100644 --- a/ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs +++ b/ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs @@ -397,7 +397,7 @@ ITypeReference CreateType(TypeReference type, ICustomAttributeProvider typeAttri 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 @@ public string ReadSerString () public KeyValuePair 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 @@ public KeyValuePair ReadNamedArg(IType attributeType) 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 @@ static void InitTypeParameters(TypeDefinition typeDefinition, IList(); @@ -1912,17 +1912,17 @@ public ITypeResolveContext CreateResolveContext(ITypeResolveContext parentContex #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 @@ IUnresolvedMethod ReadMethod(MethodDefinition method, IUnresolvedTypeDefinition 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 @@ IUnresolvedMethod ReadMethod(MethodDefinition method, IUnresolvedTypeDefinition 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 @@ Accessibility MergePropertyAccessibility (Accessibility left, Accessibility righ } [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 @@ public IUnresolvedEvent ReadEvent(EventDefinition ev, IUnresolvedTypeDefinition 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); diff --git a/ICSharpCode.NRefactory/TypeSystem/EntityType.cs b/ICSharpCode.NRefactory/TypeSystem/EntityType.cs index e47b349fc..bfb7cac14 100644 --- a/ICSharpCode.NRefactory/TypeSystem/EntityType.cs +++ b/ICSharpCode.NRefactory/TypeSystem/EntityType.cs @@ -20,7 +20,7 @@ namespace ICSharpCode.NRefactory.TypeSystem { - public enum EntityType : byte + public enum SymbolKind : byte { None, /// diff --git a/ICSharpCode.NRefactory/TypeSystem/IEntity.cs b/ICSharpCode.NRefactory/TypeSystem/IEntity.cs index 147c65878..214d536c1 100644 --- a/ICSharpCode.NRefactory/TypeSystem/IEntity.cs +++ b/ICSharpCode.NRefactory/TypeSystem/IEntity.cs @@ -31,7 +31,7 @@ public interface IUnresolvedEntity : INamedElement, IHasAccessibility /// /// Gets the entity type. /// - EntityType EntityType { get; } + SymbolKind SymbolKind { get; } /// /// Gets the complete entity region (including header+body) diff --git a/ICSharpCode.NRefactory/TypeSystem/ISymbol.cs b/ICSharpCode.NRefactory/TypeSystem/ISymbol.cs index 44bd70d17..7ed3e2c62 100644 --- a/ICSharpCode.NRefactory/TypeSystem/ISymbol.cs +++ b/ICSharpCode.NRefactory/TypeSystem/ISymbol.cs @@ -29,7 +29,7 @@ public interface ISymbol /// This property returns an enum specifying which kind of symbol this is /// (which derived interfaces of ISymbol are implemented) /// - EntityType EntityType { get; } + SymbolKind SymbolKind { get; } /// /// Gets the short name of the symbol. diff --git a/ICSharpCode.NRefactory/TypeSystem/ITypeParameter.cs b/ICSharpCode.NRefactory/TypeSystem/ITypeParameter.cs index 53150cb33..e74af0557 100644 --- a/ICSharpCode.NRefactory/TypeSystem/ITypeParameter.cs +++ b/ICSharpCode.NRefactory/TypeSystem/ITypeParameter.cs @@ -31,8 +31,8 @@ public interface IUnresolvedTypeParameter : INamedElement /// /// Get the type of this type parameter's owner. /// - /// EntityType.TypeDefinition or EntityType.Method - EntityType OwnerType { get; } + /// SymbolKind.TypeDefinition or SymbolKind.Method + SymbolKind OwnerType { get; } /// /// Gets the index of the type parameter in the type parameter list of the owning method/class. @@ -65,8 +65,8 @@ public interface ITypeParameter : IType, ISymbol /// /// Get the type of this type parameter's owner. /// - /// EntityType.TypeDefinition or EntityType.Method - EntityType OwnerType { get; } + /// SymbolKind.TypeDefinition or SymbolKind.Method + SymbolKind OwnerType { get; } /// /// Gets the owning method/class. diff --git a/ICSharpCode.NRefactory/TypeSystem/IkvmLoader.cs b/ICSharpCode.NRefactory/TypeSystem/IkvmLoader.cs index 69926f503..9e20bd9a5 100644 --- a/ICSharpCode.NRefactory/TypeSystem/IkvmLoader.cs +++ b/ICSharpCode.NRefactory/TypeSystem/IkvmLoader.cs @@ -1,4 +1,4 @@ -// +// // IkvmLoader.cs // // Author: @@ -288,7 +288,7 @@ ITypeReference CreateTypeReference(IKVM.Reflection.Type type, IEnumerable 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 @@ public KeyValuePair ReadNamedArg(IType attributeType) 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 @@ static void InitTypeParameters(IKVM.Reflection.Type typeDefinition, ICollection< 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 @@ void InitMembers(IKVM.Reflection.Type typeDefinition, IUnresolvedTypeDefinition { 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 @@ void InitMembers(IKVM.Reflection.Type typeDefinition, IUnresolvedTypeDefinition 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 @@ void InitMembers(IKVM.Reflection.Type typeDefinition, IUnresolvedTypeDefinition 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 @@ static bool IsAccessor(MethodInfo methodInfo) #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 @@ IUnresolvedMethod ReadMethod(MethodInfo method, IUnresolvedTypeDefinition parent 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 @@ IUnresolvedMethod ReadMethod(MethodInfo method, IUnresolvedTypeDefinition parent 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 @@ void TranslateModifiers(MethodBase method, AbstractUnresolvedMember m) #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 @@ IUnresolvedMethod ReadConstructor(ConstructorInfo method, IUnresolvedTypeDefinit 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 @@ Accessibility MergePropertyAccessibility (Accessibility left, Accessibility righ } [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 @@ public IUnresolvedProperty ReadProperty(PropertyInfo property, IUnresolvedTypeDe 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 @@ public IUnresolvedEvent ReadEvent(EventInfo ev, IUnresolvedTypeDefinition parent 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); diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedEntity.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedEntity.cs index 99cd346ed..445aa3318 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedEntity.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedEntity.cs @@ -41,8 +41,8 @@ protected AbstractResolvedEntity(IUnresolvedEntity unresolved, ITypeResolveConte 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 @@ public ICompilation Compilation { public override string ToString() { - return "[" + this.EntityType.ToString() + " " + this.ReflectionName + "]"; + return "[" + this.SymbolKind.ToString() + " " + this.ReflectionName + "]"; } } } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs index 6102316de..1058f1d67 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs @@ -85,7 +85,7 @@ IList FindImplementedInterfaceMembers() .ToArray(); IEnumerable 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 @@ public virtual IMemberReference ToMemberReference() 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); } } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedTypeParameter.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedTypeParameter.cs index 7f42522f7..3bd392cd5 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedTypeParameter.cs +++ b/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 @@ protected AbstractTypeParameter(IEntity owner, int index, string name, VarianceM 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.Instance; this.region = region; this.variance = variance; } - protected AbstractTypeParameter(ICompilation compilation, EntityType ownerType, int index, string name, VarianceModifier variance, IList attributes, DomRegion region) + protected AbstractTypeParameter(ICompilation compilation, SymbolKind ownerType, int index, string name, VarianceModifier variance, IList 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.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 @@ string INamedElement.FullName { public string ReflectionName { get { - return (this.OwnerType == EntityType.Method ? "``" : "`") + index.ToString(CultureInfo.InvariantCulture); + return (this.OwnerType == SymbolKind.Method ? "``" : "`") + index.ToString(CultureInfo.InvariantCulture); } } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedEntity.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedEntity.cs index 692e2a6f3..a1cc4ce43 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedEntity.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedEntity.cs @@ -39,7 +39,7 @@ public abstract class AbstractUnresolvedEntity : IUnresolvedEntity, IFreezable internal RareFields rareFields; // 1 byte per enum + 2 bytes for flags - EntityType entityType; + SymbolKind symbolKind; Accessibility accessibility; internal BitVector16 flags; @@ -146,11 +146,11 @@ protected void ThrowIfFrozen() FreezableHelper.ThrowIfFrozen(this); } - public EntityType EntityType { - get { return entityType; } + public SymbolKind SymbolKind { + get { return symbolKind; } set { ThrowIfFrozen(); - entityType = value; + symbolKind = value; } } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedMember.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedMember.cs index 46a89a4c5..9b1094187 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedMember.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedMember.cs @@ -149,7 +149,7 @@ public virtual IMember Resolve(ITypeResolveContext context) 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 @@ protected static ITypeResolveContext ExtendContextForType(ITypeResolveContext as } public static IMember Resolve(ITypeResolveContext context, - EntityType entityType, + SymbolKind symbolKind, string name, ITypeReference explicitInterfaceTypeReference = null, IList typeParameterNames = null, @@ -184,7 +184,7 @@ public static IMember Resolve(ITypeResolveContext context, 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 @@ public static IMember Resolve(ITypeResolveContext context, 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 @@ public static IMember Resolve(ITypeResolveContext context, // 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 @@ public static IMember Resolve(ITypeResolveContext context, return null; } - static bool IsNonGenericMatch(IMember member, EntityType entityType, string name, IList parameterTypes) + static bool IsNonGenericMatch(IMember member, SymbolKind symbolKind, string name, IList parameterTypes) { - if (member.EntityType != entityType) + if (member.SymbolKind != symbolKind) return false; if (member.Name != name) return false; diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultMemberReference.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultMemberReference.cs index 0c4301560..6be899b18 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultMemberReference.cs +++ b/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 parameterTypes; - public DefaultMemberReference(EntityType entityType, ITypeReference typeReference, string name, int typeParameterCount = 0, IList parameterTypes = null) + public DefaultMemberReference(SymbolKind symbolKind, ITypeReference typeReference, string name, int typeParameterCount = 0, IList 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 @@ public IMember Resolve(ITypeResolveContext context) { IType type = typeReference.Resolve(context); IEnumerable 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 @@ public IMember Resolve(ITypeResolveContext context) 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; } } } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultParameter.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultParameter.cs index 29af6c5c4..98301d74f 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultParameter.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultParameter.cs @@ -62,8 +62,8 @@ public DefaultParameter(IType type, string name) this.defaultValue = defaultValue; } - EntityType ISymbol.EntityType { - get { return EntityType.Parameter; } + SymbolKind ISymbol.SymbolKind { + get { return SymbolKind.Parameter; } } public IList Attributes { diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedMethod.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedMethod.cs index b90a9464e..43a47c5f5 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedMethod.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedMethod.cs @@ -241,7 +241,7 @@ public override IMemberReference ToMemberReference() 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 @@ IMethod IMethod.Specialize(TypeParameterSubstitution substitution) 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); diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedProperty.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedProperty.cs index 6685fe949..dfeb73449 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedProperty.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedProperty.cs @@ -68,7 +68,7 @@ public override IMemberReference ToMemberReference() 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()); } } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs index 799d38892..9899c0edf 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs @@ -110,8 +110,8 @@ public IList Parts { 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 @@ MemberList GetMemberList() } 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 @@ public IEnumerable Fields { 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 @@ public IEnumerable Properties { 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 @@ public IEnumerable Events { 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]; } } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeParameter.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeParameter.cs index 771668d64..ea0968ce1 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeParameter.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeParameter.cs @@ -48,7 +48,7 @@ public DefaultTypeParameter( } public DefaultTypeParameter( - ICompilation compilation, EntityType ownerType, + ICompilation compilation, SymbolKind ownerType, int index, string name = null, VarianceModifier variance = VarianceModifier.Invariant, IList attributes = null, @@ -112,7 +112,7 @@ protected override void FreezeInternal() base.FreezeInternal(); } - public DefaultTypeParameter(EntityType ownerType, int index, string name) + public DefaultTypeParameter(SymbolKind ownerType, int index, string name) : base(ownerType, index, name) { } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAssembly.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAssembly.cs index 7264312ec..3bcb74c10 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAssembly.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAssembly.cs @@ -403,8 +403,8 @@ string INamespace.FullName { get { return ns.FullName; } } - EntityType ISymbol.EntityType { - get { return EntityType.Namespace; } + SymbolKind ISymbol.SymbolKind { + get { return SymbolKind.Namespace; } } public string Name { diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAttribute.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAttribute.cs index bf1c9d94f..ac30211de 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAttribute.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAttribute.cs @@ -101,7 +101,7 @@ public IList> NamedArguments { public void AddNamedFieldArgument(string fieldName, IConstantValue value) { this.NamedArguments.Add(new KeyValuePair( - new DefaultMemberReference(EntityType.Field, attributeType, fieldName), + new DefaultMemberReference(SymbolKind.Field, attributeType, fieldName), value )); } @@ -109,7 +109,7 @@ public void AddNamedFieldArgument(string fieldName, IConstantValue value) public void AddNamedPropertyArgument(string propertyName, IConstantValue value) { this.NamedArguments.Add(new KeyValuePair( - new DefaultMemberReference(EntityType.Property, attributeType, propertyName), + new DefaultMemberReference(SymbolKind.Property, attributeType, propertyName), value )); } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedEvent.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedEvent.cs index fe4c06d2e..f9abd1a6a 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedEvent.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedEvent.cs @@ -38,12 +38,12 @@ protected override void FreezeInternal() 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) diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedField.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedField.cs index 8c4ab5018..8182a5fcc 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedField.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedField.cs @@ -36,12 +36,12 @@ protected override void FreezeInternal() 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) diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedMethod.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedMethod.cs index 9cf06ac31..3e8c61c64 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedMethod.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedMethod.cs @@ -66,12 +66,12 @@ public override void ApplyInterningProvider(InterningProvider provider) 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 @@ public bool IsExtensionMethod { } 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 @@ public IUnresolvedMember AccessorOwner { 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 @@ public override IMember Resolve(ITypeResolveContext context) 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 @@ public static DefaultUnresolvedMethod CreateDefaultConstructor(IUnresolvedTypeDe 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 @@ public static IUnresolvedMethod DummyConstructor { static IUnresolvedMethod CreateDummyConstructor() { var m = new DefaultUnresolvedMethod { - EntityType = EntityType.Constructor, + SymbolKind = SymbolKind.Constructor, Name = ".ctor", Accessibility = Accessibility.Public, IsSynthetic = true, diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedParameter.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedParameter.cs index 6e0924464..c03d91acb 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedParameter.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedParameter.cs @@ -228,7 +228,7 @@ public ResolvedParameterWithDefaultValue(IConstantValue defaultValue, ITypeResol 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; } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedProperty.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedProperty.cs index d9b1feee6..d8113f36e 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedProperty.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedProperty.cs @@ -55,12 +55,12 @@ public override void ApplyInterningProvider(InterningProvider provider) 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 @@ public DefaultUnresolvedProperty(IUnresolvedTypeDefinition declaringType, string } public bool IsIndexer { - get { return this.EntityType == EntityType.Indexer; } + get { return this.SymbolKind == SymbolKind.Indexer; } } public IList Parameters { @@ -114,7 +114,7 @@ public override IMember Resolve(ITypeResolveContext context) 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()); } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeDefinition.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeDefinition.cs index 6fddd1e6e..0e841d4d3 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeDefinition.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeDefinition.cs @@ -38,7 +38,7 @@ public class DefaultUnresolvedTypeDefinition : AbstractUnresolvedEntity, IUnreso public DefaultUnresolvedTypeDefinition() { - this.EntityType = EntityType.TypeDefinition; + this.SymbolKind = SymbolKind.TypeDefinition; } public DefaultUnresolvedTypeDefinition(string fullName) @@ -54,21 +54,21 @@ public DefaultUnresolvedTypeDefinition(string fullName) 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; diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeParameter.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeParameter.cs index 4a79df380..31df0746b 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeParameter.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeParameter.cs @@ -36,7 +36,7 @@ public class DefaultUnresolvedTypeParameter : IUnresolvedTypeParameter, IFreezab string name; DomRegion region; - EntityType ownerType; + SymbolKind ownerType; VarianceModifier variance; BitVector16 flags; const ushort FlagFrozen = 0x0001; @@ -57,14 +57,14 @@ protected virtual void FreezeInternal() 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 @@ string INamedElement.Namespace { 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 @@ public virtual void ApplyInterningProvider(InterningProvider provider) 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) diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DummyTypeParameter.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DummyTypeParameter.cs index aa07c2995..bf1a0c663 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DummyTypeParameter.cs +++ b/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 @@ static ITypeParameter GetTypeParameter(ref ITypeParameter[] typeParameters, Enti 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 @@ sealed class NormalizeMethodTypeParametersVisitor : TypeVisitor { 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 @@ sealed class NormalizeClassTypeParametersVisitor : TypeVisitor { 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 @@ public static IType NormalizeAllTypeParameters(IType type) 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 @@ IList ITypeParameter.Attributes { get { return EmptyList.Instance; } } - EntityType ITypeParameter.OwnerType { + SymbolKind ITypeParameter.OwnerType { get { return ownerType; } } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/ExplicitInterfaceImplementationMemberReference.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/ExplicitInterfaceImplementationMemberReference.cs index 307fa834e..6297db3e4 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/ExplicitInterfaceImplementationMemberReference.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/ExplicitInterfaceImplementationMemberReference.cs @@ -60,13 +60,13 @@ public IMember Resolve(ITypeResolveContext context) if (interfaceMember == null) return null; IEnumerable 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])); diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/MergedNamespace.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/MergedNamespace.cs index 5524d64e0..97afebf4e 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/MergedNamespace.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/MergedNamespace.cs @@ -91,8 +91,8 @@ public IEnumerable Types { } } - public EntityType EntityType { - get { return EntityType.Namespace; } + public SymbolKind SymbolKind { + get { return SymbolKind.Namespace; } } public ICompilation Compilation { diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/MinimalCorlib.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/MinimalCorlib.cs index ee2070cc3..a28302b91 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/MinimalCorlib.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/MinimalCorlib.cs @@ -45,7 +45,7 @@ private MinimalCorlib() : base("corlib") 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]); } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs index b243ea47e..566ec7269 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs @@ -173,8 +173,8 @@ public bool IsOverridable { 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 @@ public SpecializedParameter(IParameter originalParameter, IType newType) this.newType = newType; } - EntityType ISymbol.EntityType { get { return EntityType.Parameter; } } + SymbolKind ISymbol.SymbolKind { get { return SymbolKind.Parameter; } } public IList Attributes { get { return originalParameter.Attributes; } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/TypeParameterReference.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/TypeParameterReference.cs index 3514b8ac0..8fdd096f5 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/TypeParameterReference.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/TypeParameterReference.cs @@ -32,10 +32,10 @@ public sealed class TypeParameterReference : ITypeReference /// Creates a type parameter reference. /// For common type parameter references, this method may return a shared instance. /// - 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 @@ public static TypeParameterReference Create(EntityType ownerType, int index) } } - readonly EntityType ownerType; + readonly SymbolKind ownerType; readonly int index; public int Index { @@ -55,7 +55,7 @@ public int Index { } } - public TypeParameterReference(EntityType ownerType, int index) + public TypeParameterReference(SymbolKind ownerType, int index) { this.ownerType = ownerType; this.index = index; @@ -63,13 +63,13 @@ public TypeParameterReference(EntityType ownerType, int index) 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 @@ public IType Resolve(ITypeResolveContext context) public override string ToString() { - if (ownerType == EntityType.Method) + if (ownerType == SymbolKind.Method) return "!!" + index.ToString(CultureInfo.InvariantCulture); else return "!" + index.ToString(CultureInfo.InvariantCulture); diff --git a/ICSharpCode.NRefactory/TypeSystem/InheritanceHelper.cs b/ICSharpCode.NRefactory/TypeSystem/InheritanceHelper.cs index fea5afdda..37f5129d2 100644 --- a/ICSharpCode.NRefactory/TypeSystem/InheritanceHelper.cs +++ b/ICSharpCode.NRefactory/TypeSystem/InheritanceHelper.cs @@ -72,7 +72,7 @@ public static IEnumerable GetBaseMembers(IMember member, bool includeIm continue; IEnumerable 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); diff --git a/ICSharpCode.NRefactory/TypeSystem/ParameterListComparer.cs b/ICSharpCode.NRefactory/TypeSystem/ParameterListComparer.cs index 8346e57d3..a4f14f3fb 100644 --- a/ICSharpCode.NRefactory/TypeSystem/ParameterListComparer.cs +++ b/ICSharpCode.NRefactory/TypeSystem/ParameterListComparer.cs @@ -111,7 +111,7 @@ public bool Equals(IMember x, IMember y) { 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 @@ public bool Equals(IMember x, IMember y) 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; diff --git a/ICSharpCode.NRefactory/TypeSystem/ReflectionHelper.cs b/ICSharpCode.NRefactory/TypeSystem/ReflectionHelper.cs index 575ade61d..3352650a2 100644 --- a/ICSharpCode.NRefactory/TypeSystem/ReflectionHelper.cs +++ b/ICSharpCode.NRefactory/TypeSystem/ReflectionHelper.cs @@ -95,9 +95,9 @@ public static ITypeReference ToTypeReference(this Type type) 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 @@ static ITypeReference ParseReflectionName(string reflectionTypeName, ref int pos // 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 diff --git a/ICSharpCode.NRefactory/TypeSystem/TypeParameterSubstitution.cs b/ICSharpCode.NRefactory/TypeSystem/TypeParameterSubstitution.cs index a59ab5680..28b4abb37 100644 --- a/ICSharpCode.NRefactory/TypeSystem/TypeParameterSubstitution.cs +++ b/ICSharpCode.NRefactory/TypeSystem/TypeParameterSubstitution.cs @@ -148,12 +148,12 @@ static int TypeListHashCode(IList obj) 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