resolveresult.cs

SharpDevelop2.0.0 c#开发免费工具

		}
		
		/// <summary>
		/// Gets if the variable is a parameter (true) or a local variable (false).
		/// </summary>
		public bool IsParameter {
			get {
				return isParameter;
			}
		}
		
		public override FilePosition GetDefinitionPosition()
		{
			ICompilationUnit cu = this.CallingClass.CompilationUnit;
			if (cu == null) {
				return null;
			}
			if (cu.FileName == null || cu.FileName.Length == 0) {
				return null;
			}
			DomRegion reg = field.Region;
			if (!reg.IsEmpty) {
				return new FilePosition(cu.FileName, new Point(reg.BeginLine, reg.BeginColumn));
			} else {
				LoggingService.Warn("GetDefinitionPosition: field.Region is empty");
				return new FilePosition(cu.FileName, Point.Empty);
			}
		}
	}
	#endregion
	
	#region NamespaceResolveResult
	/// <summary>
	/// The NamespaceResolveResult is used when an expression was the name of a namespace.
	/// <see cref="ResolveResult.ResolvedType"/> is always null on a NamespaceReturnType.
	/// </summary>
	/// <example>
	/// Example expressions:
	/// "System"
	/// "System.Windows.Forms"
	/// "using Win = System.Windows;  Win.Forms"
	/// </example>
	public class NamespaceResolveResult : ResolveResult
	{
		string name;
		
		public NamespaceResolveResult(IClass callingClass, IMember callingMember, string name)
			: base(callingClass, callingMember, null)
		{
			if (name == null)
				throw new ArgumentNullException("name");
			this.name = name;
		}
		
		/// <summary>
		/// Gets the name of the namespace.
		/// </summary>
		public string Name {
			get {
				return name;
			}
		}
		
		public override ArrayList GetCompletionData(IProjectContent projectContent)
		{
			return projectContent.GetNamespaceContents(name);
		}
	}
	#endregion
	
	#region IntegerLiteralResolveResult
	/// <summary>
	/// The IntegerLiteralResolveResult is used when an expression was an integer literal.
	/// It is a normal ResolveResult with a type of "int", but does not provide
	/// any code completion data.
	/// </summary>
	public class IntegerLiteralResolveResult : ResolveResult
	{
		public IntegerLiteralResolveResult(IClass callingClass, IMember callingMember)
			: base(callingClass, callingMember, ReflectionReturnType.Int)
		{
		}
		
		public override ArrayList GetCompletionData(IProjectContent projectContent)
		{
			return null;
		}
	}
	#endregion
	
	#region TypeResolveResult
	/// <summary>
	/// The TypeResolveResult is used when an expression was the name of a type.
	/// This resolve result makes code completion show the static members instead
	/// of the instance members.
	/// </summary>
	/// <example>
	/// Example expressions:
	/// "System.EventArgs"
	/// "using System;  EventArgs"
	/// </example>
	public class TypeResolveResult : ResolveResult
	{
		IClass resolvedClass;
		
		public TypeResolveResult(IClass callingClass, IMember callingMember, IClass resolvedClass)
			: base(callingClass, callingMember, resolvedClass.DefaultReturnType)
		{
			this.resolvedClass = resolvedClass;
		}
		
		public TypeResolveResult(IClass callingClass, IMember callingMember, IReturnType resolvedType, IClass resolvedClass)
			: base(callingClass, callingMember, resolvedType)
		{
			this.resolvedClass = resolvedClass;
		}
		
		public TypeResolveResult(IClass callingClass, IMember callingMember, IReturnType resolvedType)
			: base(callingClass, callingMember, resolvedType)
		{
			this.resolvedClass = resolvedType.GetUnderlyingClass();
		}
		
		/// <summary>
		/// Gets the class corresponding to the resolved type.
		/// This property can be null when the type has no class (for example a type parameter).
		/// </summary>
		public IClass ResolvedClass {
			get {
				return resolvedClass;
			}
		}
		
		public override ArrayList GetCompletionData(IProjectContent projectContent)
		{
			ArrayList ar = GetCompletionData(projectContent.Language, true);
			if (resolvedClass != null) {
				foreach (IClass baseClass in resolvedClass.ClassInheritanceTree) {
					ar.AddRange(baseClass.InnerClasses);
				}
			}
			return ar;
		}
		
		public override FilePosition GetDefinitionPosition()
		{
			if (resolvedClass == null) {
				return null;
			}
			ICompilationUnit cu = resolvedClass.CompilationUnit;
			if (cu == null || cu.FileName == null || cu.FileName.Length == 0) {
				return null;
			}
			DomRegion reg = resolvedClass.Region;
			if (!reg.IsEmpty)
				return new FilePosition(cu.FileName, new Point(reg.BeginLine, reg.BeginColumn));
			else
				return new FilePosition(cu.FileName, Point.Empty);
		}
	}
	#endregion
	
	#region MemberResolveResult
	/// <summary>
	/// The TypeResolveResult is used when an expression was a member
	/// (field, property, event or method call).
	/// </summary>
	/// <example>
	/// Example expressions:
	/// "(any expression).fieldName"
	/// "(any expression).eventName"
	/// "(any expression).propertyName"
	/// "(any expression).methodName(arguments)" (methods only when method parameters are part of expression)
	/// "using System;  EventArgs.Empty"
	/// "fieldName" (when fieldName is a field in the current class)
	/// "new System.Windows.Forms.Button()" (constructors are also methods)
	/// "SomeMethod()" (when SomeMethod is a method in the current class)
	/// "System.Console.WriteLine(text)"
	/// </example>
	public class MemberResolveResult : ResolveResult
	{
		IMember resolvedMember;
		
		public MemberResolveResult(IClass callingClass, IMember callingMember, IMember resolvedMember)
			: base(callingClass, callingMember, resolvedMember.ReturnType)
		{
			if (resolvedMember == null)
				throw new ArgumentNullException("resolvedMember");
			this.resolvedMember = resolvedMember;
		}
		
		/// <summary>
		/// Gets the member that was resolved.
		/// </summary>
		public IMember ResolvedMember {
			get {
				return resolvedMember;
			}
		}
		
		public override FilePosition GetDefinitionPosition()
		{
			return GetDefinitionPosition(resolvedMember);
		}
		
		public static FilePosition GetDefinitionPosition(IMember resolvedMember)
		{
			IClass declaringType = resolvedMember.DeclaringType;
			if (declaringType == null) {
				return null;
			}
			ICompilationUnit cu = declaringType.CompilationUnit;
			if (cu == null) {
				return null;
			}
			if (cu.FileName == null || cu.FileName.Length == 0) {
				return null;
			}
			DomRegion reg = resolvedMember.Region;
			if (!reg.IsEmpty)
				return new FilePosition(cu.FileName, new Point(reg.BeginLine, reg.BeginColumn));
			else
				return new FilePosition(cu.FileName, Point.Empty);
		}
	}
	#endregion
	
	#region MethodResolveResult
	/// <summary>
	/// The MethodResolveResult is used when an expression was the name of a method,
	/// but there were no parameters specified so the exact overload could not be found.
	/// <see cref="ResolveResult.ResolvedType"/> is always null on a MethodReturnType.
	/// </summary>
	/// <example>
	/// Example expressions:
	/// "System.Console.WriteLine"
	/// "a.Add"      (where a is List&lt;string&gt;)
	/// "SomeMethod" (when SomeMethod is a method in the current class)
	/// </example>
	public class MethodResolveResult : ResolveResult
	{
		string name;
		IReturnType containingType;
		
		public MethodResolveResult(IClass callingClass, IMember callingMember, IReturnType containingType, string name)
			: base(callingClass, callingMember, null)
		{
			if (containingType == null)
				throw new ArgumentNullException("containingType");
			if (name == null)
				throw new ArgumentNullException("name");
			this.containingType = containingType;
			this.name = name;
		}
		
		/// <summary>
		/// Gets the name of the method.
		/// </summary>
		public string Name {
			get {
				return name;
			}
		}
		
		/// <summary>
		/// Gets the class that contains the method.
		/// </summary>
		public IReturnType ContainingType {
			get {
				return containingType;
			}
		}
		
		public IMethod GetMethodIfSingleOverload()
		{
			List<IMethod> methods = containingType.GetMethods();
			methods = methods.FindAll(delegate(IMethod m) { return m.Name == this.Name; });
			if (methods.Count == 1)
				return methods[0];
			else
				return null;
		}
		
		public override FilePosition GetDefinitionPosition()
		{
			IMethod m = GetMethodIfSingleOverload();
			if (m != null)
				return MemberResolveResult.GetDefinitionPosition(m);
			else
				return base.GetDefinitionPosition();
		}
	}
	#endregion
}