add ISymbolReference implementation

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs

@@ -232,6 +232,16 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			{
 				throw new NotSupportedException();
 			}
+			
+			ISymbolReference ISymbol.ToReference()
+			{
+				throw new NotSupportedException();
+			}
+			
+			IMemberReference IMember.ToReference()
+			{
+				throw new NotSupportedException();
+			}
 
 			TypeParameterSubstitution IMember.Substitution {
 				get {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Resolver/ReducedExtensionMethod.cs

@@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	/// <summary>
 	/// An invocated extension method hides the extension parameter in its parameter list.
-	/// It's used to hide the internals of extension method invocation in certain situation to simulate the 
+	/// It's used to hide the internals of extension method invocation in certain situation to simulate the
 	/// syntactic way of writing extension methods on semantic level.
 	/// </summary>
 	public class ReducedExtensionMethod : IMethod
@@ -77,24 +77,37 @@ namespace ICSharpCode.NRefactory.CSharp
 				this.baseMethod = baseMethod;
 			}
 
-			#region IMemberReference implementation
 			public IMember Resolve(ITypeResolveContext context)
 			{
-				return new ReducedExtensionMethod ((IMethod)baseMethod.ToMemberReference ().Resolve (context));
+				return new ReducedExtensionMethod ((IMethod)baseMethod.ToReference ().Resolve (context));
+			}
+			
+			ISymbol ISymbolReference.Resolve(ITypeResolveContext context)
+			{
+				return Resolve(context);
 			}
 
 			public ITypeReference DeclaringTypeReference {
 				get {
-					return baseMethod.ToMemberReference ().DeclaringTypeReference;
+					return baseMethod.ToReference ().DeclaringTypeReference;
 				}
 			}
-			#endregion
 		}
 
 		public IMemberReference ToMemberReference()
 		{
 			return new ReducedExtensionMethodMemberReference (baseMethod);
 		}
+		
+		public IMemberReference ToReference()
+		{
+			return new ReducedExtensionMethodMemberReference (baseMethod);
+		}
+		
+		ISymbolReference ISymbol.ToReference()
+		{
+			return ToReference();
+		}
 
 		public IMember MemberDefinition {
 			get {
@@ -240,10 +253,10 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 
-		public IMethod ReducedFrom { 
+		public IMethod ReducedFrom {
 			get {
 				return baseMethod;
-			} 
+			}
 		}
 
 		public IList<IType> TypeArguments {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

@@ -3170,6 +3170,11 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			{
 				return type.ToString() + " " + name + ";";
 			}
+
+			public ISymbolReference ToReference()
+			{
+				return new VariableReference(type.ToTypeReference(), name, region, IsConst, ConstantValue);
+			}
 		}
 		
 		sealed class SimpleConstant : SimpleVariable

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/TypeSystem/CSharpAssembly.cs

@@ -328,6 +328,11 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 					return assembly.GetTypeDefinition(key);
 				}
 			}
+
+			public ISymbolReference ToReference()
+			{
+				return new NamespaceReference(new DefaultAssemblyReference(assembly.AssemblyName), fullName);
+			}
 		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/TypeSystem/ResolvedUsingScope.cs

@@ -21,6 +21,7 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
+using ICSharpCode.NRefactory.TypeSystem.Implementation;
 using ICSharpCode.NRefactory.CSharp.Resolver;
 using ICSharpCode.NRefactory.Semantics;
 using ICSharpCode.NRefactory.TypeSystem;
@@ -199,6 +200,11 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			{
 				return null;
 			}
+
+			public ISymbolReference ToReference()
+			{
+				return new MergedNamespaceReference(ExternAlias, ((INamespace)this).FullName);
+			}
 		}
 	}
 }

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

@@ -141,7 +141,7 @@ class TestClass {
 }";
 			var result = Resolve<InvocationResolveResult>(program);
 			IProperty prop = result.Type.GetProperties().Single();
-			IProperty propAfterRoundtrip = (IProperty)prop.ToMemberReference().Resolve(result.Member.Compilation.TypeResolveContext);
+			IProperty propAfterRoundtrip = (IProperty)prop.ToReference().Resolve(result.Member.Compilation.TypeResolveContext);
 			Assert.AreEqual(prop, propAfterRoundtrip);
 		}
 		
@@ -156,7 +156,7 @@ class TestClass {
 }";
 			var result = Resolve<InvocationResolveResult>(program);
 			IMethod getter = result.Type.GetProperties().Single().Getter;
-			IMethod getterAfterRoundtrip = (IMethod)getter.ToMemberReference().Resolve(result.Member.Compilation.TypeResolveContext);
+			IMethod getterAfterRoundtrip = (IMethod)getter.ToReference().Resolve(result.Member.Compilation.TypeResolveContext);
 			Assert.AreEqual(getter, getterAfterRoundtrip);
 		}
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs

@@ -266,7 +266,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Assert.IsInstanceOf<SpecializedMethod>(method);
 			Assert.IsFalse(method.IsParameterized); // the method itself is not specialized
 			Assert.AreEqual(method.TypeParameters, method.TypeArguments);
-			var methodReference = method.ToMemberReference();
+			var methodReference = method.ToReference();
 			var resolvedMethod = methodReference.Resolve(compilation.TypeResolveContext);
 			Assert.AreEqual(method, resolvedMethod);
 		}
@@ -1082,7 +1082,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			ITypeDefinition type = GetTypeDefinition(typeof(ClassThatImplementsProperty));
 			var prop = type.Properties.Single(p => p.Name == "Prop");
-			var mr = prop.Getter.ToMemberReference();
+			var mr = prop.Getter.ToReference();
 			Assert.AreEqual(prop.Getter, mr.Resolve(compilation.TypeResolveContext));
 		}
 		
@@ -1130,7 +1130,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			ITypeDefinition type = GetTypeDefinition(typeof(ClassThatImplementsPropertyExplicitly));
 			var prop = type.Properties.Single();
-			var mr = prop.Getter.ToMemberReference();
+			var mr = prop.Getter.ToReference();
 			Assert.AreEqual(prop.Getter, mr.Resolve(compilation.TypeResolveContext));
 		}
 		
@@ -1167,7 +1167,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			IType type = compilation.FindType(typeof(ExplicitGenericInterfaceImplementationWithUnifiableMethods<int, int>));
 			Assert.AreEqual(2, type.GetMethods(m => m.IsExplicitInterfaceImplementation).Count());
 			foreach (IMethod method in type.GetMethods(m => m.IsExplicitInterfaceImplementation)) {
-				IMethod resolvedMethod = (IMethod)method.ToMemberReference().Resolve(compilation.TypeResolveContext);
+				IMethod resolvedMethod = (IMethod)method.ToReference().Resolve(compilation.TypeResolveContext);
 				Assert.AreEqual(method, resolvedMethod);
 			}
 		}

src/Libraries/NRefactory/ICSharpCode.NRefactory/Documentation/IdStringMemberReference.cs

@@ -68,5 +68,10 @@ namespace ICSharpCode.NRefactory.Documentation
 			}
 			return null;
 		}
+		
+		ISymbol ISymbolReference.Resolve(ITypeResolveContext context)
+		{
+			return Resolve(context);
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/IField.cs

@@ -93,5 +93,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// If this is true, then ConstantValue contains the size of the buffer.
 		/// </summary>
 		bool IsFixed { get; }
+		
+		new IMemberReference ToReference(); // solve ambiguity between IMember.ToReference() and IVariable.ToReference()
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/IMember.cs

@@ -82,7 +82,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		IMember CreateResolved(ITypeResolveContext context);
 	}
 	
-	public interface IMemberReference
+	public interface IMemberReference : ISymbolReference
 	{
 		/// <summary>
 		/// Gets the declaring type reference for the member.
@@ -101,7 +101,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// <returns>
 		/// Returns the resolved member, or <c>null</c> if the member could not be found.
 		/// </returns>
-		IMember Resolve(ITypeResolveContext context);
+		new IMember Resolve(ITypeResolveContext context);
 	}
 	
 	/// <summary>
@@ -167,7 +167,17 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// If this member is specialized using open generic types, the resulting member reference will need to be looked up in an appropriate generic context.
 		/// Otherwise, the main resolve context of a compilation is sufficient.
 		/// </remarks>
+		[Obsolete("Use the ToReference method instead.")]
 		IMemberReference ToMemberReference();
+		
+				/// <summary>
+		/// Creates a member reference that can be used to rediscover this member in another compilation.
+		/// </summary>
+		/// <remarks>
+		/// If this member is specialized using open generic types, the resulting member reference will need to be looked up in an appropriate generic context.
+		/// Otherwise, the main resolve context of a compilation is sufficient.
+		/// </remarks>
+		new IMemberReference ToReference();
 
 		/// <summary>
 		/// Gets the substitution belonging to this specialized member.

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/ISymbol.cs

@@ -86,5 +86,15 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// Gets the short name of the symbol.
 		/// </summary>
 		string Name { get; }
+		
+		/// <summary>
+		/// Creates a symbol reference that can be used to rediscover this symbol in another compilation.
+		/// </summary>
+		ISymbolReference ToReference();
+	}
+	
+	public interface ISymbolReference
+	{
+		ISymbol Resolve(ITypeResolveContext context);
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedEntity.cs

@@ -90,6 +90,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			else
 				return null;
 		}
+
+		public abstract ISymbolReference ToReference();
 		
 		public bool IsStatic { get { return unresolved.IsStatic; } }
 		public bool IsAbstract { get { return unresolved.IsAbstract; } }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs

@@ -126,17 +126,27 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 
 		public abstract IMember Specialize(TypeParameterSubstitution substitution);
-
-		public virtual IMemberReference ToMemberReference()
+		
+		IMemberReference IMember.ToReference()
+		{
+			return (IMemberReference)ToReference();
+		}
+		
+		public override ISymbolReference ToReference()
 		{
 			var declTypeRef = this.DeclaringType.ToTypeReference();
 			if (IsExplicitInterfaceImplementation && ImplementedInterfaceMembers.Count == 1) {
-				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToMemberReference());
+				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToReference());
 			} else {
 				return new DefaultMemberReference(this.SymbolKind, declTypeRef, this.Name);
 			}
 		}
 		
+		public virtual IMemberReference ToMemberReference()
+		{
+			return (IMemberReference)ToReference();
+		}
+		
 		internal IMethod GetAccessor(ref IMethod accessorField, IUnresolvedMethod unresolvedAccessor)
 		{
 			if (unresolvedAccessor == null)

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedTypeParameter.cs

@@ -372,10 +372,41 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		{
 			return this == other; // use reference equality for type parameters
 		}
+
+		public virtual ISymbolReference ToReference()
+		{
+			if (owner == null)
+				return TypeParameterReference.Create(ownerType, index);
+			return new OwnedTypeParameterReference(owner.ToReference(), index);
+		}
 		
 		public override string ToString()
 		{
 			return this.ReflectionName + " (owner=" + owner + ")";
 		}
 	}
+	
+	public sealed class OwnedTypeParameterReference : ISymbolReference
+	{
+		ISymbolReference owner;
+		int index;
+		
+		public OwnedTypeParameterReference(ISymbolReference owner, int index)
+		{
+			if (owner == null)
+				throw new ArgumentNullException("owner");
+			this.owner = owner;
+			this.index = index;
+		}
+		
+		public ISymbol Resolve(ITypeResolveContext context)
+		{
+			var entity = owner.Resolve(context) as IEntity;
+			if (entity is ITypeDefinition)
+				return ((ITypeDefinition)entity).TypeParameters[index];
+			if (entity is IMethod)
+				return ((IMethod)entity).TypeParameters[index];
+			return null;
+		}
+	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedMember.cs

@@ -152,6 +152,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			return Resolve(ExtendContextForType(context, this.DeclaringTypeDefinition), this.SymbolKind, this.Name, interfaceTypeReference);
 		}
 		
+		ISymbol ISymbolReference.Resolve(ITypeResolveContext context)
+		{
+			return ((IUnresolvedMember)this).Resolve(context);
+		}
+		
 		protected static ITypeResolveContext ExtendContextForType(ITypeResolveContext assemblyContext, IUnresolvedTypeDefinition typeDef)
 		{
 			if (typeDef == null)

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/AccessorOwnerMemberReference.cs

@@ -47,5 +47,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			else
 				return null;
 		}
+		
+		ISymbol ISymbolReference.Resolve(ITypeResolveContext context)
+		{
+			return ((IMemberReference)this).Resolve(context);
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultMemberReference.cs

@@ -99,6 +99,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			return null;
 		}
 		
+		ISymbol ISymbolReference.Resolve(ITypeResolveContext context)
+		{
+			return ((IMemberReference)this).Resolve(context);
+		}
+		
 		int ISupportsInterning.GetHashCodeForInterning()
 		{
 			return (int)symbolKind ^ typeReference.GetHashCode() ^ name.GetHashCode() ^ parameterTypes.GetHashCode();

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultParameter.cs

@@ -138,5 +138,63 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 			return b.ToString();
 		}
+
+		public ISymbolReference ToReference()
+		{
+			if (owner == null)
+				return new ParameterReference(type.ToTypeReference(), name, region, isRef, isOut, isParams, isOptional, defaultValue);
+			return new OwnedParameterReference(owner.ToReference(), owner.Parameters.IndexOf(this));
+		}
+	}
+	
+	sealed class OwnedParameterReference : ISymbolReference
+	{
+		readonly IMemberReference memberReference;
+		readonly int index;
+		
+		public OwnedParameterReference(IMemberReference member, int index)
+		{
+			if (member == null)
+				throw new ArgumentNullException("member");
+			this.memberReference = member;
+			this.index = index;
+		}
+		
+		public ISymbol Resolve(ITypeResolveContext context)
+		{
+			IParameterizedMember member = (IParameterizedMember)memberReference.Resolve(context);
+			return member.Parameters[index];
+		}
+	}
+	
+	public sealed class ParameterReference : ISymbolReference
+	{
+		readonly ITypeReference type;
+		readonly string name;
+		readonly DomRegion region;
+		readonly bool isRef, isOut, isParams, isOptional;
+		readonly object defaultValue;
+		readonly IMemberReference owner;
+		
+		public ParameterReference(ITypeReference type, string name, DomRegion region, bool isRef, bool isOut, bool isParams, bool isOptional, object defaultValue)
+		{
+			if (type == null)
+				throw new ArgumentNullException("type");
+			if (name == null)
+				throw new ArgumentNullException("name");
+			this.type = type;
+			this.name = name;
+			this.region = region;
+			this.isRef = isRef;
+			this.isOut = isOut;
+			this.isParams = isParams;
+			this.isOptional = isOptional;
+			this.defaultValue = defaultValue;
+		}
+
+		public ISymbol Resolve(ITypeResolveContext context)
+		{
+			return new DefaultParameter(type.Resolve(context), name, region: region, isRef: isRef, isOut: isOut, isParams: isParams, isOptional: isOptional, defaultValue: defaultValue);
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedField.cs

@@ -78,5 +78,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				return this;
 			return new SpecializedField(this, substitution);
 		}
+		
+		IMemberReference IField.ToReference()
+		{
+			return (IMemberReference)ToReference();
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedMethod.cs

@@ -234,11 +234,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
-		public override IMemberReference ToMemberReference()
+		public override ISymbolReference ToReference()
 		{
 			var declTypeRef = this.DeclaringType.ToTypeReference();
 			if (IsExplicitInterfaceImplementation && ImplementedInterfaceMembers.Count == 1) {
-				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToMemberReference());
+				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToReference());
 			} else {
 				return new DefaultMemberReference(
 					this.SymbolKind, declTypeRef, this.Name, this.TypeParameters.Count,
@@ -246,6 +246,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
+		public override IMemberReference ToMemberReference()
+		{
+			return (IMemberReference)ToReference();
+		}
+		
 		public override IMember Specialize(TypeParameterSubstitution substitution)
 		{
 			if (TypeParameterSubstitution.Identity.Equals(substitution))

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedProperty.cs

@@ -61,11 +61,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return unresolved.IsIndexer; }
 		}
 		
-		public override IMemberReference ToMemberReference()
+		public override ISymbolReference ToReference()
 		{
 			var declTypeRef = this.DeclaringType.ToTypeReference();
 			if (IsExplicitInterfaceImplementation && ImplementedInterfaceMembers.Count == 1) {
-				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToMemberReference());
+				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToReference());
 			} else {
 				return new DefaultMemberReference(
 					this.SymbolKind, declTypeRef, this.Name, 0,

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs

@@ -706,6 +706,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
+		ISymbolReference ISymbol.ToReference()
+		{
+			return (ISymbolReference)ToTypeReference();
+		}
+		
 		public IEnumerable<IType> GetNestedTypes(Predicate<ITypeDefinition> filter = null, GetMemberOptions options = GetMemberOptions.None)
 		{
 			const GetMemberOptions opt = GetMemberOptions.IgnoreInheritedMembers | GetMemberOptions.ReturnMemberDefinitions;

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedAssembly.cs

@@ -462,7 +462,68 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 					else
 						return null;
 				}
+				
+				public ISymbolReference ToReference()
+				{
+					return new NamespaceReference(new DefaultAssemblyReference(assembly.AssemblyName), ns.FullName);
+				}
+			}
+		}
+	}
+	
+	public sealed class NamespaceReference : ISymbolReference
+	{
+		IAssemblyReference assemblyReference;
+		string fullName;
+		
+		public NamespaceReference(IAssemblyReference assemblyReference, string fullName)
+		{
+			if (assemblyReference == null)
+				throw new ArgumentNullException("assemblyReference");
+			this.assemblyReference = assemblyReference;
+			this.fullName = fullName;
+		}
+		
+		public ISymbol Resolve(ITypeResolveContext context)
+		{
+			IAssembly assembly = assemblyReference.Resolve(context);
+			INamespace parent = assembly.RootNamespace;
+			
+			string[] parts = fullName.Split('.');
+			
+			int i = 0;
+			while (i < parts.Length && parent != null) {
+				parent = parent.GetChildNamespace(parts[i]);
+				i++;
 			}
+			
+			return parent;
+		}
+	}
+	
+	public sealed class MergedNamespaceReference : ISymbolReference
+	{
+		string externAlias;
+		string fullName;
+		
+		public MergedNamespaceReference(string externAlias, string fullName)
+		{
+			this.externAlias = externAlias;
+			this.fullName = fullName;
+		}
+		
+		public ISymbol Resolve(ITypeResolveContext context)
+		{
+			string[] parts = fullName.Split('.');
+			INamespace parent = context.Compilation.GetNamespaceForExternAlias(externAlias);
+			
+			int i = 0;
+			while (i < parts.Length && parent != null) {
+				parent = parent.GetChildNamespace(parts[i]);
+				i++;
+			}
+			
+			return parent;
 		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedParameter.cs

@@ -263,6 +263,13 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			{
 				return DefaultParameter.ToString(this);
 			}
+
+			public ISymbolReference ToReference()
+			{
+				if (Owner == null)
+					return new ParameterReference(Type.ToTypeReference(), Name, Region, IsRef, IsOut, IsParams, true, ConstantValue);
+				return new OwnedParameterReference(Owner.ToReference(), Owner.Parameters.IndexOf(this));
+			}
 		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultVariable.cs

@@ -73,5 +73,39 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public SymbolKind SymbolKind {
 			get { return SymbolKind.Variable; }
 		}
+
+		public ISymbolReference ToReference()
+		{
+			return new VariableReference(type.ToTypeReference(), name, region, isConst, constantValue);
+		}
+	}
+	
+	public sealed class VariableReference : ISymbolReference
+	{
+		ITypeReference variableTypeReference;
+		string name;
+		DomRegion region;
+		bool isConst;
+		object constantValue;
+		
+		public VariableReference(ITypeReference variableTypeReference, string name, DomRegion region, bool isConst, object constantValue)
+		{
+			if (variableTypeReference == null)
+				throw new ArgumentNullException("variableTypeReference");
+			if (name == null)
+				throw new ArgumentNullException("name");
+			if (constantValue == null)
+				throw new ArgumentNullException("constantValue");
+			this.variableTypeReference = variableTypeReference;
+			this.name = name;
+			this.region = region;
+			this.isConst = isConst;
+			this.constantValue = constantValue;
+		}
+		
+		public ISymbol Resolve(ITypeResolveContext context)
+		{
+			return new DefaultVariable(variableTypeReference.Resolve(context), name, region, isConst, constantValue);
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DummyTypeParameter.cs

@@ -208,5 +208,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		bool ITypeParameter.HasValueTypeConstraint {
 			get { return false; }
 		}
+
+		public ISymbolReference ToReference()
+		{
+			return new TypeParameterReference(ownerType, index);
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/ExplicitInterfaceImplementationMemberReference.cs

@@ -71,5 +71,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 			return members.FirstOrDefault(m => m.ImplementedInterfaceMembers.Count == 1 && interfaceMember.Equals(m.ImplementedInterfaceMembers[0]));
 		}
+		
+		ISymbol ISymbolReference.Resolve(ITypeResolveContext context)
+		{
+			return Resolve(context);
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/GetClassTypeReference.cs

@@ -25,7 +25,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 	/// Type Reference used when the fully qualified type name is known.
 	/// </summary>
 	[Serializable]
-	public sealed class GetClassTypeReference : ITypeReference, ISupportsInterning
+	public sealed class GetClassTypeReference : ITypeReference, ISymbolReference, ISupportsInterning
 	{
 		readonly IAssemblyReference assembly;
 		readonly FullTypeName fullTypeName;
@@ -115,6 +115,14 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			return type ?? new UnknownType(fullTypeName);
 		}
 		
+		ISymbol ISymbolReference.Resolve(ITypeResolveContext context)
+		{
+			var type = Resolve(context);
+			if (type is ITypeDefinition)
+				return (ISymbol)type;
+			return null;
+		}
+		
 		public override string ToString()
 		{
 			return fullTypeName.ToString() + (assembly != null ? ", " + assembly.ToString() : null);

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/MergedNamespace.cs

@@ -155,5 +155,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			return string.Format(CultureInfo.InvariantCulture, "[MergedNamespace {0}{1} (from {2} assemblies)]",
 			                     externAlias != null ? externAlias + "::" : null, this.FullName, this.namespaces.Length);
 		}
+
+		public ISymbolReference ToReference()
+		{
+			return new MergedNamespaceReference(externAlias, FullName);
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/NestedTypeReference.cs

@@ -24,7 +24,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 	/// Type reference used to reference nested types.
 	/// </summary>
 	[Serializable]
-	public sealed class NestedTypeReference : ITypeReference, ISupportsInterning
+	public sealed class NestedTypeReference : ITypeReference, ISymbolReference, ISupportsInterning
 	{
 		readonly ITypeReference declaringTypeRef;
 		readonly string name;
@@ -76,6 +76,14 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			return new UnknownType(null, name, additionalTypeParameterCount);
 		}
 		
+		ISymbol ISymbolReference.Resolve(ITypeResolveContext context)
+		{
+			var type = Resolve(context);
+			if (type is ITypeDefinition)
+				return (ISymbol)type;
+			return null;
+		}
+		
 		public override string ToString()
 		{
 			if (additionalTypeParameterCount == 0)

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs

@@ -70,13 +70,23 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		public virtual IMemberReference ToMemberReference()
+		{
+			return ToReference();
+		}
+		
+		public virtual IMemberReference ToReference()
 		{
 			return new SpecializingMemberReference(
-				baseMember.ToMemberReference(),
+				baseMember.ToReference(),
 				ToTypeReference(substitution.ClassTypeArguments),
 				null);
 		}
 		
+		ISymbolReference ISymbol.ToReference()
+		{
+			return ToReference();
+		}
+		
 		internal static IList<ITypeReference> ToTypeReference(IList<IType> typeArguments)
 		{
 			if (typeArguments == null)

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMethod.cs

@@ -154,7 +154,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 
-		public override IMemberReference ToMemberReference()
+		public override IMemberReference ToReference()
 		{
 			// Pass the MethodTypeArguments to the SpecializingMemberReference only if
 			// the generic method itself is parameterized, not if the generic method is only
@@ -169,14 +169,19 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			// in the resulting member reference.
 			if (isParameterized) {
 				return new SpecializingMemberReference(
-					baseMember.ToMemberReference(),
+					baseMember.ToReference(),
 					ToTypeReference(base.Substitution.ClassTypeArguments),
 					ToTypeReference(base.Substitution.MethodTypeArguments));
 			} else {
-				return base.ToMemberReference();
+				return base.ToReference();
 			}
 		}
 		
+		public override IMemberReference ToMemberReference()
+		{
+			return ToReference();
+		}
+		
 		public override bool Equals(object obj)
 		{
 			SpecializedMethod other = obj as SpecializedMethod;

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializingMemberReference.cs

@@ -50,6 +50,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			);
 		}
 		
+		ISymbol ISymbolReference.Resolve(ITypeResolveContext context)
+		{
+			return Resolve(context);
+		}
+		
 		public ITypeReference DeclaringTypeReference {
 			get {
 				if (classTypeArgumentReferences != null)

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/TypeParameterReference.cs

@@ -23,7 +23,7 @@ using ICSharpCode.NRefactory.Utils;
 namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 {
 	[Serializable]
-	public sealed class TypeParameterReference : ITypeReference
+	public sealed class TypeParameterReference : ITypeReference, ISymbolReference
 	{
 		static readonly TypeParameterReference[] classTypeParameterReferences = new TypeParameterReference[8];
 		static readonly TypeParameterReference[] methodTypeParameterReferences = new TypeParameterReference[8];
@@ -80,6 +80,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
+		ISymbol ISymbolReference.Resolve(ITypeResolveContext context)
+		{
+			return Resolve(context) as ISymbol;
+		}
+		
 		public override string ToString()
 		{
 			if (ownerType == SymbolKind.Method)

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/TypeSystemExtensions.cs

@@ -301,7 +301,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			if (entity.Compilation == compilation)
 				return entity;
 			if (entity is IMember)
-				return ((IMember)entity).ToMemberReference().Resolve(compilation.TypeResolveContext);
+				return ((IMember)entity).ToReference().Resolve(compilation.TypeResolveContext);
 			else if (entity is ITypeDefinition)
 				return ((ITypeDefinition)entity).ToTypeReference().Resolve(compilation.TypeResolveContext).GetDefinition();
 			else
@@ -319,7 +319,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				return null;
 			if (member.Compilation == compilation)
 				return member;
-			return member.ToMemberReference().Resolve(compilation.TypeResolveContext);
+			return member.ToReference().Resolve(compilation.TypeResolveContext);
 		}
 		
 		/// <summary>