/// <summary>
/// Compare two property references
/// </summary>
/// <param name="ipr1">First property reference</param>
/// <param name="ipr2">Second property reference</param>
/// <returns>-1, 0 or 1</returns>
internal static int ComparePropertyReferences(IPropertyReference ipr1, IPropertyReference ipr2)
{
int ret = ipr1.DeclaringType.CompareTo(ipr2.DeclaringType);
if (ret != 0)
{
return(ret);
}
if ((ret = String.Compare(ipr1.Name, ipr2.Name, StringComparison.InvariantCulture)) != 0)
{
return(ret);
}
if ((ret = ipr1.PropertyType.CompareTo(ipr2.PropertyType)) != 0)
{
return(ret);
}
if ((ret = ipr1.Parameters.Count.CompareTo(ipr2.Parameters.Count)) != 0)
{
return(ret);
}
for (int i = 0; i < ipr1.Parameters.Count; i++)
{
if ((ret = ipr1.Parameters[i].ParameterType.CompareTo(ipr1.Parameters[i].ParameterType)) != 0)
{
return(ret);
}
}
return(0);
}
public static MethodVisibility GetVisibility(IPropertyReference value)
{
IMethodDeclaration getMethod = Helper.GetGetMethod(value);
IMethodDeclaration setMethod = Helper.GetSetMethod(value);
MethodVisibility visibility = MethodVisibility.Public;
if ((setMethod != null) && (getMethod != null))
{
if (getMethod.Visibility == setMethod.Visibility)
{
visibility = getMethod.Visibility;
}
}
else if (setMethod != null)
{
visibility = setMethod.Visibility;
}
else if (getMethod != null)
{
visibility = getMethod.Visibility;
}
return(visibility);
}
public static string GetName(IPropertyReference value)
{
IParameterDeclarationCollection parameters = value.Parameters;
if (parameters.Count > 0)
{
using (StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture))
{
for (int i = 0; i < parameters.Count; i++)
{
if (i != 0)
{
stringWriter.Write(", ");
}
stringWriter.Write(parameters[i].ParameterType.ToString());
}
return(string.Concat(new string[]
{
value.Name,
"[",
stringWriter.ToString(),
"] : ",
value.PropertyType.ToString()
}));
}
}
return(value.Name + " : " + value.PropertyType.ToString());
}
public static MethodVisibility GetVisibility(IPropertyReference value)
{
MethodVisibility result = MethodVisibility.Public;
IPropertyDeclaration propertyDeclaration = value.Resolve();
if (propertyDeclaration != null)
{
IMethodReference setMethod = propertyDeclaration.SetMethod;
IMethodDeclaration methodDeclaration = setMethod?.Resolve();
IMethodReference getMethod = propertyDeclaration.GetMethod;
IMethodDeclaration methodDeclaration2 = getMethod?.Resolve();
if (methodDeclaration != null && methodDeclaration2 != null)
{
if (methodDeclaration2.Visibility == methodDeclaration.Visibility)
{
result = methodDeclaration2.Visibility;
}
}
else if (methodDeclaration != null)
{
result = methodDeclaration.Visibility;
}
else if (methodDeclaration2 != null)
{
result = methodDeclaration2.Visibility;
}
}
return(result);
}
public static bool IsVisible(IPropertyReference value, IVisibilityConfiguration visibility)
{
if (IsVisible(value.DeclaringType, visibility))
{
switch (GetVisibility(value))
{
case MethodVisibility.PrivateScope:
case MethodVisibility.Private:
return(visibility.Private);
case MethodVisibility.FamilyAndAssembly:
return(visibility.FamilyAndAssembly);
case MethodVisibility.Assembly:
return(visibility.Assembly);
case MethodVisibility.Family:
return(visibility.Family);
case MethodVisibility.FamilyOrAssembly:
return(visibility.FamilyOrAssembly);
case MethodVisibility.Public:
return(visibility.Public);
}
throw new NotSupportedException();
}
return(false);
}
public static MethodVisibility GetVisibility(IPropertyReference value)
{
MethodVisibility visibility = MethodVisibility.Public;
IPropertyDeclaration propertyDeclaration = value.Resolve();
if (propertyDeclaration != null)
{
IMethodReference setMethodReference = propertyDeclaration.SetMethod;
IMethodDeclaration setMethod = (setMethodReference == null) ? null : setMethodReference.Resolve();
IMethodReference getMethodReference = propertyDeclaration.GetMethod;
IMethodDeclaration getMethod = (getMethodReference == null) ? null : getMethodReference.Resolve();
if ((setMethod != null) && (getMethod != null))
{
if (getMethod.Visibility == setMethod.Visibility)
{
visibility = getMethod.Visibility;
}
}
else if (setMethod != null)
{
visibility = setMethod.Visibility;
}
else if (getMethod != null)
{
visibility = getMethod.Visibility;
}
}
return(visibility);
}
public override IReference Visit(IPropertyReference eventRef, int context)
{
return(new PropertyReference
{
Reference = Anonymize(eventRef.Reference),
PropertyName = eventRef.PropertyName.ToAnonymousName()
});
}
public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
{
base.GetPropertyHeight(property, label);
reference = property.GetValue <IPropertyReference>();
return(property.isExpanded ? (lineHeight + 2f) * 3f : lineHeight + 2f);
}
public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
{
base.GetPropertyHeight(property, label);
reference = property.GetValue<IPropertyReference>();
return property.isExpanded ? (lineHeight + 2f) * 3f : lineHeight + 2f;
}
public static bool IsStatic(IPropertyReference value)
{
IMethodDeclaration setMethod = GetSetMethod(value);
IMethodDeclaration getMethod = GetGetMethod(value);
bool flag = false;
flag |= (setMethod != null) && setMethod.Static;
return(flag | ((getMethod != null) && getMethod.Static));
}
public static bool IsStatic(IPropertyReference value)
{
IMethodDeclaration setMethod = Helper.GetSetMethod(value);
IMethodDeclaration getMethod = Helper.GetGetMethod(value);
bool isStatic = false;
isStatic |= ((setMethod != null) && (setMethod.Static));
isStatic |= ((getMethod != null) && (getMethod.Static));
return(isStatic);
}
public static IMethodDeclaration GetGetMethod(IPropertyReference value)
{
IPropertyDeclaration declaration2 = value.Resolve();
if (declaration2.GetMethod != null)
{
return(declaration2.GetMethod.Resolve());
}
return(null);
}
public override void Visit(IPropertyReference propRef, ContextStatistics stats)
{
var p = propRef.PropertyName;
if (!p.IsUnknown && !p.DeclaringType.Assembly.IsLocalProject)
{
stats.NumAsmPropertyRead++;
stats.UniqueAsmProperties.Add(p.RemoveGenerics());
stats.UniqueAssemblies.Add(p.DeclaringType.Assembly);
}
}
public static IMethodDeclaration GetSetMethod(IPropertyReference value)
{
IPropertyDeclaration propertyDeclaration = value.Resolve();
if (propertyDeclaration.SetMethod != null)
{
return(propertyDeclaration.SetMethod.Resolve());
}
return(null);
}
public int CompareTo(object obj)
{
IPropertyReference reference = obj as IPropertyReference;
if (reference == null)
{
throw new NotSupportedException();
}
return(CompareItems.ComparePropertyReferences(this, reference));
}
public void Visit(IPropertyReference propertyRef, SSTPrintingContext c)
{
if (propertyRef.PropertyName.IsStatic)
{
c.Type(propertyRef.PropertyName.DeclaringType);
}
else
{
c.Text(propertyRef.Reference.Identifier);
}
c.Text(".").Text(propertyRef.PropertyName.Name);
}
/// <summary>
/// Determines if this method reference is equal to another (representing the method declaration)
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (this == obj)
{
return(true);
}
IPropertyReference that = obj as IPropertyReference;
if (that == null)
{
return(false);
}
return(CompareItems.PropertyReferencesAreEqual(this, that));
}
private string GetPropertyReferenceText(IPropertyReference value)
{
using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
{
writer.Write(value.Name);
if (value.Parameters.Count > 0)
{
writer.Write("(");
writer.Write(this.GetParameterDeclarationListText(value.Parameters, MethodCallingConvention.Default));
writer.Write(")");
}
writer.Write(":");
writer.Write(this.GetTypeText(value.PropertyType));
return(writer.ToString());
}
}
public static bool IsVisible(IPropertyReference value, IVisibilityConfiguration visibility)
{
bool result;
if (IsVisible(value.DeclaringType, visibility))
{
switch (GetVisibility(value))
{
case MethodVisibility.PrivateScope:
case MethodVisibility.Private:
result = visibility.Private;
break;
case MethodVisibility.FamilyAndAssembly:
result = visibility.FamilyAndAssembly;
break;
case MethodVisibility.Assembly:
result = visibility.Assembly;
break;
case MethodVisibility.Family:
result = visibility.Family;
break;
case MethodVisibility.FamilyOrAssembly:
result = visibility.FamilyOrAssembly;
break;
case MethodVisibility.Public:
result = visibility.Public;
break;
default:
throw new NotSupportedException();
}
}
else
{
result = false;
}
return(result);
}
/// <summary>
/// Determine if two property references are equal
/// </summary>
/// <param name="ipr1">Property reference 1</param>
/// <param name="ipr2">Property reference 2</param>
/// <returns>true if equal</returns>
internal static bool PropertyReferencesAreEqual(IPropertyReference ipr1, IPropertyReference ipr2)
{
// Names must be the same
if ((!ipr1.Name.Equals(ipr2.Name)) ||
(!ipr1.PropertyType.Equals(ipr2.PropertyType)) ||
(!ipr1.DeclaringType.Equals(ipr2.DeclaringType)) ||
ipr1.Parameters.Count != ipr2.Parameters.Count)
{
return(false);
}
for (int i = 0; i < ipr1.Parameters.Count; i++)
{
if (!ipr1.Parameters[i].Equals(ipr2.Parameters[i]))
{
return(false);
}
}
return(true);
}
public static MethodVisibility GetVisibility(IPropertyReference value)
{
IMethodDeclaration getMethod = GetGetMethod(value);
IMethodDeclaration setMethod = GetSetMethod(value);
MethodVisibility @public = MethodVisibility.Public;
if ((setMethod != null) && (getMethod != null))
{
if (getMethod.Visibility == setMethod.Visibility)
{
@public = getMethod.Visibility;
}
return(@public);
}
if (setMethod != null)
{
return(setMethod.Visibility);
}
if (getMethod != null)
{
@public = getMethod.Visibility;
}
return(@public);
}
public static string GetNameWithDeclaringType(IPropertyReference value)
{
return GetNameWithResolutionScope(value.DeclaringType as ITypeReference) + "." + GetName(value);
}
/// <summary>
/// Determines whether the specified value is visible.
/// </summary>
/// <param name="value">The property reference value.</param>
/// <param name="visibility">The visibility.</param>
/// <returns>
/// <c>true</c> if the specified value is visible; otherwise, <c>false</c>.
/// </returns>
internal static bool IsVisible(IPropertyReference value, IVisibilityConfiguration visibility)
{
if (ReflectorHelper.IsVisible(value.DeclaringType, visibility))
{
switch (ReflectorHelper.GetVisibility(value))
{
case MethodVisibility.Public:
return visibility.Public;
case MethodVisibility.Assembly:
return visibility.Assembly;
case MethodVisibility.FamilyOrAssembly:
return visibility.FamilyOrAssembly;
case MethodVisibility.Family:
return visibility.Family;
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
return visibility.Private;
case MethodVisibility.FamilyAndAssembly:
return visibility.FamilyAndAssembly;
}
throw new InvalidOperationException();
}
return false;
}
private TreeNode FindNode(IMemberReference memberReference)
{
if (memberReference is IAssemblyReference)
{
foreach (TreeNode node in _assembliesTree.Nodes)
{
if (node.Tag == memberReference)
{
return(node);
}
}
return(null);
}
if (memberReference is IResourceReference)
{
IResourceReference resourceReference = (IResourceReference)memberReference;
TreeNode assemblyNode = FindNode(resourceReference.Resolve().Assembly);
TreeNode resourcesNode = null;
foreach (TreeNode childNode in assemblyNode.Nodes)
{
if (childNode.Text == "Resources")
{
resourcesNode = childNode;
}
}
return(FindNode(memberReference, resourcesNode));
}
if (memberReference is IModuleReference)
{
IModuleReference moduleReference = (IModuleReference)memberReference;
return(FindNode(memberReference, FindNode(moduleReference.Resolve().Assembly)));
}
if (memberReference is ITypeReference)
{
ITypeReference typeReference = (ITypeReference)memberReference;
if (typeReference.Resolve().DeclaringType != null)
{
TreeNode declaringTypeNode = FindNode(typeReference.Resolve().DeclaringType);
return(FindNode(memberReference, declaringTypeNode));
}
else
{
TreeNode moduleNode = FindNode(typeReference.Resolve().Module);
foreach (TreeNode namespaceNode in moduleNode.Nodes)
{
if (((namespaceNode.Text == "-") && (typeReference.Namespace == null)) ||
(namespaceNode.Text == typeReference.Namespace))
{
return(FindNode(memberReference, namespaceNode));
}
}
}
return(null);
}
if (memberReference is IMethodReference)
{
IMethodReference methodReference = (IMethodReference)memberReference;
TreeNode typeNode = FindNode(methodReference.Resolve().DeclaringType);
if (typeNode == null)
{
return(null);
}
foreach (TreeNode node in typeNode.Nodes)
{
if (node.Tag == memberReference)
{
return(node);
}
if ((node.Tag is IPropertyReference) || (node.Tag is IEventReference))
{
TreeNode nestedEventNode = FindNode(memberReference, node);
if (nestedEventNode != null)
{
return(nestedEventNode);
}
}
}
return(null);
}
if (memberReference is IFieldReference)
{
IFieldReference fieldReference = (IFieldReference)memberReference;
return(FindNode(memberReference, FindNode(fieldReference.Resolve().DeclaringType)));
}
if (memberReference is IPropertyReference)
{
IPropertyReference propertyReference = (IPropertyReference)memberReference;
return(FindNode(memberReference, FindNode(propertyReference.Resolve().DeclaringType)));
}
if (memberReference is IEventReference)
{
IEventReference eventReference = (IEventReference)memberReference;
return(FindNode(memberReference, FindNode(eventReference.Resolve().DeclaringType)));
}
return(null);
}
public virtual void VisitPropertyReference(IPropertyReference value)
{
VisitType(value.PropertyType);
}
public virtual void Visit(IPropertyReference propertyRef, TContext context)
{
propertyRef.Reference.Accept(this, context);
}
public override void Visit(IPropertyReference propertyRef, IKaVESet <IName> context)
{
context.Add(propertyRef.PropertyName);
base.Visit(propertyRef, context);
}
public override void Visit(IPropertyReference propertyRef, StringBuilder sb)
{
sb.Append("TODO: IPropertyReference");
}
public PropertyReferenceExpression(IPropertyReference property, IExpression target)
{
_property = property;
_target = target;
}
public static IMethodDeclaration GetGetMethod(IPropertyReference value)
{
IPropertyDeclaration propertyDeclaration = value.Resolve();
if (propertyDeclaration.GetMethod != null)
{
return propertyDeclaration.GetMethod.Resolve();
}
return null;
}
private void WritePropertyReference(IPropertyReference propertyReference, IFormatter formatter)
{
// TODO Escape?
this.WriteReference(propertyReference.Name, formatter, this.GetPropertyReferenceDescription(propertyReference), propertyReference);
}
internal static int GetColor(IMemberReference memberReference)
{
IFieldReference fieldReference = memberReference as IFieldReference;
if (fieldReference != null)
{
IFieldDeclaration fieldDeclaration = fieldReference.Resolve();
if (fieldDeclaration == null)
{
return(ColorInformation.Error);
}
switch (fieldDeclaration.Visibility)
{
case FieldVisibility.Private:
case FieldVisibility.PrivateScope:
case FieldVisibility.Assembly:
case FieldVisibility.FamilyAndAssembly:
return(ColorInformation.Hidden);
case FieldVisibility.Public:
case FieldVisibility.Family:
case FieldVisibility.FamilyOrAssembly:
return(ColorInformation.Normal);
}
}
IMethodReference methodReference = memberReference as IMethodReference;
if (methodReference != null)
{
IArrayType arrayType = methodReference.DeclaringType as IArrayType;
if (arrayType != null)
{
return(IconHelper.GetColor(arrayType.ElementType as ITypeReference));
}
IMethodDeclaration methodDeclaration = methodReference.Resolve();
if (methodDeclaration == null)
{
return(ColorInformation.Error);
}
switch (methodDeclaration.Visibility)
{
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
case MethodVisibility.Assembly:
case MethodVisibility.FamilyAndAssembly:
return(ColorInformation.Hidden);
case MethodVisibility.Public:
case MethodVisibility.Family:
case MethodVisibility.FamilyOrAssembly:
return(ColorInformation.Normal);
}
}
IPropertyReference propertyReference = memberReference as IPropertyReference;
if (propertyReference != null)
{
switch (Helper.GetVisibility(propertyReference))
{
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
case MethodVisibility.Assembly:
case MethodVisibility.FamilyAndAssembly:
return(ColorInformation.Hidden);
case MethodVisibility.Public:
case MethodVisibility.Family:
case MethodVisibility.FamilyOrAssembly:
return(ColorInformation.Normal);
}
}
IEventReference eventReference = memberReference as IEventReference;
if (eventReference != null)
{
switch (Helper.GetVisibility(eventReference))
{
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
case MethodVisibility.Assembly:
case MethodVisibility.FamilyAndAssembly:
return(ColorInformation.Hidden);
case MethodVisibility.Public:
case MethodVisibility.Family:
case MethodVisibility.FamilyOrAssembly:
return(ColorInformation.Normal);
}
}
throw new NotSupportedException();
}
public string GetNameWithDeclaringType(IPropertyReference value)
{
return(this.GetNameWithResolutionScope(value.DeclaringType as ITypeReference) + "." + this.GetName(value));
}
public static string GetName( IPropertyReference value)
{
IParameterDeclarationCollection parameters = value.Parameters;
if (parameters.Count > 0)
{
using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
{
for (int i = 0; i < parameters.Count; i++)
{
if (i != 0)
{
writer.Write(", ");
}
writer.Write(parameters[i].ParameterType.ToString());
}
return value.Name + "[" + writer.ToString() + "] : " + value.PropertyType.ToString();
}
}
return value.Name + " : " + value.PropertyType.ToString();
}
public int Visit(IPropertyReference propertyRef, int context)
{
throw new NotImplementedException();
}
private string GetPropertyReferenceText(IPropertyReference value)
{
using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
{
writer.Write(value.Name);
if (value.Parameters.Count > 0)
{
writer.Write("(");
writer.Write(this.GetParameterDeclarationListText(value.Parameters, MethodCallingConvention.Default));
writer.Write(")");
}
writer.Write(":");
writer.Write(this.GetTypeText(value.PropertyType));
return writer.ToString();
}
}
public virtual void VisitPropertyReference(IPropertyReference value)
{
this.VisitType(value.PropertyType);
}
public static MethodVisibility GetVisibility(IPropertyReference value)
{
IMethodDeclaration getMethod = GetGetMethod(value);
IMethodDeclaration setMethod = GetSetMethod(value);
MethodVisibility visibility = MethodVisibility.Public;
if ((setMethod != null) && (getMethod != null))
{
if (getMethod.Visibility == setMethod.Visibility)
{
visibility = getMethod.Visibility;
}
}
else if (setMethod != null)
{
visibility = setMethod.Visibility;
}
else if (getMethod != null)
{
visibility = getMethod.Visibility;
}
return visibility;
}
public static bool IsStatic(IPropertyReference value)
{
IMethodDeclaration setMethod = GetSetMethod(value);
IMethodDeclaration getMethod = GetGetMethod(value);
bool isStatic = false;
isStatic |= ((setMethod != null) && (setMethod.Static));
isStatic |= ((getMethod != null) && (getMethod.Static));
return isStatic;
}
private string GetPropertyReferenceDescription(IPropertyReference propertyReference)
{
IFormatter formatter = new TextFormatter();
this.WriteType(propertyReference.PropertyType, formatter);
formatter.Write(" ");
// Name
string propertyName = propertyReference.Name;
if (propertyName == "Item")
{
propertyName = "this";
}
formatter.Write(this.GetTypeReferenceDescription(propertyReference.DeclaringType as ITypeReference));
formatter.Write(".");
this.WriteDeclaration(propertyName, formatter);
// Parameters
IParameterDeclarationCollection parameters = propertyReference.Parameters;
if (parameters.Count > 0)
{
formatter.Write("(");
this.WriteParameterDeclarationList(parameters, formatter, null);
formatter.Write(")");
}
formatter.Write(" ");
formatter.Write("{ ... }");
return formatter.ToString();
}
public static bool IsVisible(IPropertyReference value, IVisibilityConfiguration visibility)
{
if (IsVisible(value.DeclaringType, visibility))
{
switch (GetVisibility(value))
{
case MethodVisibility.Public:
return visibility.Public;
case MethodVisibility.Assembly:
return visibility.Assembly;
case MethodVisibility.FamilyOrAssembly:
return visibility.FamilyOrAssembly;
case MethodVisibility.Family:
return visibility.Family;
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
return visibility.Private;
case MethodVisibility.FamilyAndAssembly:
return visibility.FamilyAndAssembly;
}
throw new NotSupportedException();
}
return false;
}
public virtual IPropertyReference TransformPropertyReference(IPropertyReference value)
{
return value;
}
internal static int GetImageIndex(IMemberReference memberReference)
{
IFieldReference fieldReference = memberReference as IFieldReference;
if (fieldReference != null)
{
IFieldDeclaration fieldDeclaration = fieldReference.Resolve();
if (fieldDeclaration == null)
{
return(BrowserResource.Error);
}
int icon = BrowserResource.Field;
if (IsEnumerationElement(fieldReference))
{
icon = BrowserResource.EnumerationElement;
}
else
{
if (fieldDeclaration.Static)
{
icon += 6;
}
}
switch (fieldDeclaration.Visibility)
{
case FieldVisibility.Public:
return(icon);
case FieldVisibility.Assembly:
return(icon + 1);
case FieldVisibility.FamilyOrAssembly:
return(icon + 2);
case FieldVisibility.Family:
return(icon + 3);
case FieldVisibility.Private:
case FieldVisibility.PrivateScope:
return(icon + 4);
case FieldVisibility.FamilyAndAssembly:
return(icon + 5);
}
}
IMethodReference methodReference = memberReference as IMethodReference;
if (methodReference != null)
{
IArrayType arrayType = methodReference.DeclaringType as IArrayType;
if (arrayType != null)
{
return(BrowserResource.Method);
}
IMethodDeclaration methodDeclaration = methodReference.Resolve();
if (methodDeclaration == null)
{
return(BrowserResource.Error);
}
int icon = BrowserResource.Method;
string methodName = methodReference.Name;
if ((methodName == ".ctor") || (methodName == ".cctor"))
{
icon = BrowserResource.Constructor;
}
else if ((methodDeclaration.Virtual) && (!methodDeclaration.Abstract))
{
icon += 12;
}
if (methodDeclaration.Static)
{
icon += 6;
}
switch (methodDeclaration.Visibility)
{
case MethodVisibility.Public:
return(icon);
case MethodVisibility.Assembly:
return(icon + 1);
case MethodVisibility.FamilyOrAssembly:
return(icon + 2);
case MethodVisibility.Family:
return(icon + 3);
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
return(icon + 4);
case MethodVisibility.FamilyAndAssembly:
return(icon + 5);
}
}
IPropertyReference propertyReference = memberReference as IPropertyReference;
if (propertyReference != null)
{
IPropertyDeclaration propertyDeclaration = propertyReference.Resolve();
if (propertyDeclaration != null)
{
IMethodReference getMethodReference = propertyDeclaration.GetMethod;
IMethodDeclaration getMethod = (getMethodReference == null) ? null : getMethodReference.Resolve();
IMethodReference setMethodReference = propertyDeclaration.SetMethod;
IMethodDeclaration setMethod = (setMethodReference == null) ? null : setMethodReference.Resolve();
int index = BrowserResource.Property;
if ((setMethod != null) && (getMethod != null))
{
index = BrowserResource.Property;
}
else if (setMethod != null)
{
index = BrowserResource.PropertyWrite;
}
else if (getMethod != null)
{
index = BrowserResource.PropertyRead;
}
if (Helper.IsStatic(propertyReference))
{
index += 6;
}
switch (Helper.GetVisibility(propertyReference))
{
case MethodVisibility.Public:
return(index + 0);
case MethodVisibility.Assembly:
return(index + 1);
case MethodVisibility.FamilyOrAssembly:
return(index + 2);
case MethodVisibility.Family:
return(index + 3);
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
return(index + 4);
case MethodVisibility.FamilyAndAssembly:
return(index + 5);
}
}
}
IEventReference eventReference = memberReference as IEventReference;
if (eventReference != null)
{
int index = BrowserResource.Event;
if (Helper.IsStatic(eventReference))
{
index += 6;
}
switch (Helper.GetVisibility(eventReference))
{
case MethodVisibility.Public:
return(index + 0);
case MethodVisibility.Assembly:
return(index + 1);
case MethodVisibility.FamilyOrAssembly:
return(index + 2);
case MethodVisibility.Family:
return(index + 3);
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
return(index + 4);
case MethodVisibility.FamilyAndAssembly:
return(index + 5);
}
}
throw new NotSupportedException();
}
