Make IdentifierExpression.Identifier return the identifier string.

ResolveVisitor: associate declarations with the resolved entity

ICSharpCode.NRefactory.Demo/MainForm.Designer.cs

@@ -106,6 +106,7 @@ namespace ICSharpCode.NRefactory.Demo
 			this.csharpCodeTextBox.Text = "using System;\r\nclass Test\r\n{\r\n    public void Main(string[] args)\r\n    {\r\n       " +
 			"  Console.WriteLine(\"Hello, World\");\r\n    }\r\n}";
 			this.csharpCodeTextBox.WordWrap = false;
+			this.csharpCodeTextBox.TextChanged += new System.EventHandler(this.CsharpCodeTextBoxTextChanged);
 			this.csharpCodeTextBox.KeyDown += new System.Windows.Forms.KeyEventHandler(this.CSharpCodeTextBoxKeyDown);
 			// 
 			// resolveButton

ICSharpCode.NRefactory.Demo/MainForm.cs

@@ -217,5 +217,10 @@ namespace ICSharpCode.NRefactory.Demo
 				csharpCodeTextBox.SelectAll();
 			}
 		}
+		
+		void CsharpCodeTextBoxTextChanged(object sender, EventArgs e)
+		{
+			resolveButton.Enabled = false;
+		}
 	}
 }

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IdentifierExpressionTests.cs

@@ -12,7 +12,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		void CheckIdentifier(string sourceCode, string identifier)
 		{
 			IdentifierExpression ident = ParseUtilCSharp.ParseExpression<IdentifierExpression>(sourceCode);
-			Assert.AreEqual(identifier, ident.Identifier.Name);
+			Assert.AreEqual(identifier, ident.Identifier);
 		}
 		
 		[Test]

ICSharpCode.NRefactory/CSharp/Dom/Expressions/IdentifierExpression.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // IdentifierExpression.cs
 //  
 // Author:
@@ -31,12 +31,19 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class IdentifierExpression : AbstractNode
 	{
-		public Identifier Identifier {
+		public Identifier IdentifierToken {
 			get {
 				return (Identifier)GetChildByRole (Roles.Identifier);
 			}
 		}
 		
+		public string Identifier {
+			get {
+				Identifier i = this.IdentifierToken;
+				return i != null ? i.Name : null;
+			}
+		}
+		
 		public override S AcceptVisitor<T, S> (IDomVisitor<T, S> visitor, T data)
 		{
 			return visitor.VisitIdentifierExpression (this, data);

ICSharpCode.NRefactory/CSharp/Dom/Expressions/IsExpression.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // TypeOfIsExpression.cs
 //  
 // Author:
@@ -30,8 +30,8 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class IsExpression : AbstractNode
 	{
-		public FullTypeName TypeReference {
-			get { return (FullTypeName)GetChildByRole (Roles.ReturnType); }
+		public INode TypeReference {
+			get { return GetChildByRole (Roles.ReturnType); }
 		}
 		
 		public INode Expression {

ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs

@@ -71,7 +71,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				if (parsedFile != null) {
 					resolver.UsingScope = parsedFile.GetUsingScope(namespaceDeclaration.StartLocation);
 				}
-				return base.VisitNamespaceDeclaration(namespaceDeclaration, data);
+				base.VisitNamespaceDeclaration(namespaceDeclaration, data);
+				return new NamespaceResolveResult(resolver.UsingScope.NamespaceName);
 			} finally {
 				resolver.UsingScope = previousUsingScope;
 			}
@@ -83,17 +84,21 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			ITypeDefinition previousTypeDefinition = resolver.CurrentTypeDefinition;
 			try {
+				ITypeDefinition newTypeDefinition = null;
 				if (resolver.CurrentTypeDefinition != null) {
 					foreach (ITypeDefinition innerClass in resolver.CurrentTypeDefinition.InnerClasses) {
 						if (innerClass.Region.IsInside(typeDeclaration.StartLocation.Line, typeDeclaration.StartLocation.Column)) {
-							resolver.CurrentTypeDefinition = innerClass;
+							newTypeDefinition = innerClass;
 							break;
 						}
 					}
 				} else if (parsedFile != null) {
-					resolver.CurrentTypeDefinition = parsedFile.GetTopLevelTypeDefinition(typeDeclaration.StartLocation);
+					newTypeDefinition = parsedFile.GetTopLevelTypeDefinition(typeDeclaration.StartLocation);
 				}
-				return base.VisitTypeDeclaration(typeDeclaration, data);
+				if (newTypeDefinition != null)
+					resolver.CurrentTypeDefinition = newTypeDefinition;
+				base.VisitTypeDeclaration(typeDeclaration, data);
+				return newTypeDefinition != null ? new TypeResolveResult(newTypeDefinition) : errorResult;
 			} finally {
 				resolver.CurrentTypeDefinition = previousTypeDefinition;
 			}
@@ -245,7 +250,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public override ResolveResult VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
 		{
 			// TODO: type arguments?
-			return resolver.ResolveSimpleName(identifierExpression.Identifier.Name, EmptyList<IType>.Instance,
+			return resolver.ResolveSimpleName(identifierExpression.Identifier, EmptyList<IType>.Instance,
 			                                  IsTargetOfInvocation(identifierExpression));
 		}
 		
@@ -278,8 +283,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		public override ResolveResult VisitIsExpression(IsExpression isExpression, object data)
 		{
-			if (FullyResolveSubExpressions)
+			if (FullyResolveSubExpressions) {
+				Resolve(isExpression.Expression);
 				ResolveType(isExpression.TypeReference);
+			}
 			return new ResolveResult(TypeCode.Boolean.ToTypeReference().Resolve(resolver.Context));
 		}