Simplify CSharp.Dom.

Add delegate support to TypeSystemConvertVisitor.cs.
Add support for resolving object creation (constructor calls).

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.KeyDown += new System.Windows.Forms.KeyEventHandler(this.CSharpCodeTextBoxKeyDown);
 			// 
 			// resolveButton
 			// 

ICSharpCode.NRefactory.Demo/MainForm.cs

@@ -30,6 +30,7 @@ namespace ICSharpCode.NRefactory.Demo
 			//
 			InitializeComponent();
 			
+			csharpCodeTextBox.SelectAll();
 			CSharpParseButtonClick(null, null);
 			resolveButton.UseWaitCursor = true;
 			ThreadPool.QueueUserWorkItem(
@@ -208,5 +209,13 @@ namespace ICSharpCode.NRefactory.Demo
 				ShowResolveResultsInTree(t.Nodes, v);
 			}
 		}
+		
+		void CSharpCodeTextBoxKeyDown(object sender, KeyEventArgs e)
+		{
+			if (e.Control && e.KeyCode == Keys.A) {
+				e.Handled = true;
+				csharpCodeTextBox.SelectAll();
+			}
+		}
 	}
 }

ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj

@@ -106,6 +106,7 @@
     <Compile Include="TypeSystem\TestInterningProvider.cs" />
     <Compile Include="TypeSystem\TypeSystemTests.cs" />
     <Compile Include="TypeSystem\TypeSystemTests.TestCase.cs" />
+    <EmbeddedResource Include="TypeSystem\TypeSystemTests.TestCase.cs" />
     <Compile Include="Untested.cs" />
     <Compile Include="Utils\CSharpPrimitiveCastTests.cs" />
     <Compile Include="Utils\TreeTraversalTests.cs" />

ICSharpCode.NRefactory/CSharp/Dom/AbstractDomVisitor.cs

@@ -77,15 +77,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		public virtual S VisitTypeDeclaration (TypeDeclaration typeDeclaration, T data) 
 		{
-			foreach (INode node in typeDeclaration.GetChildrenByRole (TypeDeclaration.Roles.Member)) {
-				node.AcceptVisitor (this, data);
-			}
-			return default (S);
-		}
-		
-		public virtual S VisitEnumDeclaration (EnumDeclaration enumDeclaration, T data) 
-		{
-			return VisitChildren (enumDeclaration, data);
+			return VisitChildren (typeDeclaration, data);
 		}
 		
 		public virtual S VisitEnumMemberDeclaration (EnumMemberDeclaration enumMemberDeclaration, T data) 

ICSharpCode.NRefactory/CSharp/Dom/CSharpModifierToken.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // CSharpModifierToken.cs
 //  
 // Author:
@@ -46,7 +46,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		static CSharpModifierToken ()
 		{
 			lengthTable[Modifiers.New] = "new".Length;
-			lengthTable[Modifiers.Public] = "new".Length;
+			lengthTable[Modifiers.Public] = "public".Length;
 			lengthTable[Modifiers.Protected] = "protected".Length;
 			lengthTable[Modifiers.Private] = "private".Length;
 			lengthTable[Modifiers.Internal] = "internal".Length;
@@ -61,7 +61,6 @@ namespace ICSharpCode.NRefactory.CSharp
 			lengthTable[Modifiers.Extern] = "extern".Length;
 			lengthTable[Modifiers.Volatile] = "volatile".Length;
 			lengthTable[Modifiers.Unsafe] = "unsafe".Length;
-			lengthTable[Modifiers.Overloads] = "override".Length; 
 		}
 		
 		public CSharpModifierToken (DomLocation location, Modifiers modifier) : base (location, 0)

ICSharpCode.NRefactory/CSharp/Dom/GeneralScope/DelegateDeclaration.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // DelegateDeclaration.cs
 //  
 // Author:
@@ -31,7 +31,7 @@ using System.Collections.Generic;
 
 namespace ICSharpCode.NRefactory.CSharp
 {
-	public class DelegateDeclaration : AbstractNode
+	public class DelegateDeclaration : AbstractMemberBase
 	{
 		public string Name {
 			get {
@@ -58,18 +58,6 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
-		public IEnumerable<AttributeSection> Attributes { 
-			get {
-				return base.GetChildrenByRole (Roles.Attribute).Cast <AttributeSection>();
-			}
-		}
-		
-		public IEnumerable<INode> Modifiers { 
-			get {
-				return base.GetChildrenByRole (Roles.Modifier);
-			}
-		}
-		
 		public override S AcceptVisitor<T, S> (IDomVisitor<T, S> visitor, T data)
 		{
 			return visitor.VisitDelegateDeclaration (this, data);

ICSharpCode.NRefactory/CSharp/Dom/GeneralScope/EnumDeclaration.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // EnumDeclaration.cs
 //  
 // Author:
@@ -31,36 +31,8 @@ using System.Collections.Generic;
 
 namespace ICSharpCode.NRefactory.CSharp
 {
-	public class EnumDeclaration : TypeDeclaration
+	public class EnumMemberDeclaration : AbstractMemberBase
 	{
-		const int EnumMemberDeclarationRole = 100;
-		
-		public IEnumerable<EnumMemberDeclaration> Members { 
-			get {
-				return base.GetChildrenByRole (EnumMemberDeclarationRole).Cast <EnumMemberDeclaration>();
-			}
-		}
-		
-		public override ClassType ClassType {
-			get {
-				return ClassType.Enum;
-			}
-		}
-		
-		public override S AcceptVisitor<T, S> (IDomVisitor<T, S> visitor, T data)
-		{
-			return visitor.VisitEnumDeclaration (this, data);
-		}
-	}
-	
-	public class EnumMemberDeclaration : AbstractNode
-	{
-		public IEnumerable<AttributeSection> Attributes { 
-			get {
-				return base.GetChildrenByRole (Roles.Attribute).Cast <AttributeSection>();
-			}
-		}
-		
 		public string Name {
 			get {
 				return NameIdentifier.Name;

ICSharpCode.NRefactory/CSharp/Dom/GeneralScope/TypeDeclaration.cs

@@ -47,6 +47,12 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
+		public IEnumerable<AbstractMemberBase> Members {
+			get {
+				return GetChildrenByRole (Roles.Member).Cast<AbstractMemberBase> ();
+			}
+		}
+		
 		// TODO: rename to TypeParameters, more specific return type
 		public IEnumerable<INode> TypeArguments {
 			get {

ICSharpCode.NRefactory/CSharp/Dom/IDomVisitor.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // IDomVisitor.cs
 //  
 // Author:
@@ -38,7 +38,6 @@ namespace ICSharpCode.NRefactory.CSharp
 		S VisitDelegateDeclaration (DelegateDeclaration delegateDeclaration, T data);
 		S VisitNamespaceDeclaration (NamespaceDeclaration namespaceDeclaration, T data);
 		S VisitTypeDeclaration (TypeDeclaration typeDeclaration, T data);
-		S VisitEnumDeclaration (EnumDeclaration enumDeclaration, T data);
 		S VisitEnumMemberDeclaration (EnumMemberDeclaration enumMemberDeclaration, T data);
 		S VisitUsingDeclaration (UsingDeclaration usingDeclaration, T data);
 		S VisitUsingAliasDeclaration (UsingAliasDeclaration usingDeclaration, T data);

ICSharpCode.NRefactory/CSharp/Dom/Modifiers.cs

@@ -1,4 +1,4 @@
-//
+//
 // Modifiers.cs
 //
 // Author:
@@ -32,7 +32,8 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	// For compatibility with nrefactory - same flags.
 	[Flags]
-	public enum Modifiers : uint {
+	public enum Modifiers
+	{
 		None       = 0,
 		
 		Private   = 0x0001,
@@ -40,13 +41,13 @@ namespace ICSharpCode.NRefactory.CSharp
 		Protected = 0x0004,
 		Public    = 0x0008,
 		
-		Abstract  = 0x0010, 
+		Abstract  = 0x0010,
 		Virtual   = 0x0020,
 		Sealed    = 0x0040,
 		Static    = 0x0080,
 		Override  = 0x0100,
 		Readonly  = 0x0200,
-		Const	  = 0X0400,
+		Const     = 0x0400,
 		New       = 0x0800,
 		Partial   = 0x1000,
 		
@@ -54,15 +55,15 @@ namespace ICSharpCode.NRefactory.CSharp
 		Volatile  = 0x4000,
 		Unsafe    = 0x8000,
 		
-		Overloads  = 0x10000,
-		WithEvents = 0x20000,
-		Default    = 0x40000,
+		//Overloads  = 0x10000,
+		//WithEvents = 0x20000,
+		//Default    = 0x40000,
 		Fixed      = 0x80000,
 		
-		ProtectedOrInternal  = Internal | Protected,
-		ProtectedAndInternal = 0x100000,
-		SpecialName          = 0x200000,
-		Final                = 0x400000,
-		Literal              = 0x800000,
+		//ProtectedOrInternal  = Internal | Protected,
+		//ProtectedAndInternal = 0x100000, (not supported in C#)
+		//SpecialName          = 0x200000,
+		//Final                = 0x400000,
+		//Literal              = 0x800000,
 		VisibilityMask = Private | Internal | Protected | Public,
 	}}

ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/AbstractMemberBase.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // AbstractMemberBase.cs
 //  
 // Author:
@@ -33,9 +33,19 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public abstract class AbstractMemberBase : AbstractNode
 	{
-		public IEnumerable<INode> Modifiers { 
+		public IEnumerable<CSharpModifierToken> ModifierTokens { 
+			get {
+				return base.GetChildrenByRole (Roles.Modifier).Cast <CSharpModifierToken>();
+			}
+		}
+		
+		public Modifiers Modifiers {
 			get {
-				return base.GetChildrenByRole (Roles.Modifier);
+				Modifiers m = 0;
+				foreach (CSharpModifierToken t in this.ModifierTokens) {
+					m |= t.Modifier;
+				}
+				return m;
 			}
 		}
 		

ICSharpCode.NRefactory/CSharp/Parser/CSharpParser.cs

@@ -599,12 +599,11 @@ namespace ICSharpCode.NRefactory.CSharp
 				modifierTable[Mono.CSharp.Modifiers.STATIC] = Modifiers.Static;
 				modifierTable[Mono.CSharp.Modifiers.OVERRIDE] = Modifiers.Override;
 				modifierTable[Mono.CSharp.Modifiers.READONLY] = Modifiers.Readonly;
-//				modifierTable[Mono.CSharp.Modifiers.] = Modifiers.Const;
+				//modifierTable[Mono.CSharp.Modifiers.] = Modifiers.Const;
 				modifierTable[Mono.CSharp.Modifiers.PARTIAL] = Modifiers.Partial;
 				modifierTable[Mono.CSharp.Modifiers.EXTERN] = Modifiers.Extern;
 				modifierTable[Mono.CSharp.Modifiers.VOLATILE] = Modifiers.Volatile;
 				modifierTable[Mono.CSharp.Modifiers.UNSAFE] = Modifiers.Unsafe;
-				modifierTable[Mono.CSharp.Modifiers.OVERRIDE] = Modifiers.Overloads;
 			}
 			
 			void AddModifiers (AbstractNode parent, LocationsBag.MemberLocations location)

ICSharpCode.NRefactory/CSharp/Parser/TypeSystemConvertVisitor.cs

@@ -6,11 +6,12 @@ using System.Collections.Generic;
 using ICSharpCode.NRefactory.CSharp.Resolver;
 using ICSharpCode.NRefactory.TypeSystem;
 using ICSharpCode.NRefactory.TypeSystem.Implementation;
+using ICSharpCode.NRefactory.Utils;
 
 namespace ICSharpCode.NRefactory.CSharp
 {
 	/// <summary>
-	/// Produces type and member declarations.
+	/// Produces type and member definitions from the DOM.
 	/// </summary>
 	public class TypeSystemConvertVisitor : AbstractDomVisitor<object, IEntity>
 	{
@@ -33,6 +34,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			return new DomRegion(parsedFile.FileName, start.Line, start.Column, end.Line, end.Column);
 		}
 		
+		#region Using Declarations
 		// TODO: extern aliases
 		
 		public override IEntity VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
@@ -55,7 +57,9 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			throw new NotImplementedException();
 		}
+		#endregion
 		
+		#region Namespace Declaration
 		public override IEntity VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
 		{
 			DomRegion region = MakeRegion(namespaceDeclaration.StartLocation, namespaceDeclaration.EndLocation);
@@ -69,18 +73,22 @@ namespace ICSharpCode.NRefactory.CSharp
 			usingScope = previousUsingScope;
 			return null;
 		}
+		#endregion
 		
 		// TODO: assembly attributes
 		
+		#region Type Definitions
 		DefaultTypeDefinition CreateTypeDefinition(string name)
 		{
+			DefaultTypeDefinition newType;
 			if (currentTypeDefinition != null) {
-				return new DefaultTypeDefinition(currentTypeDefinition, name);
+				newType = new DefaultTypeDefinition(currentTypeDefinition, name);
+				currentTypeDefinition.InnerClasses.Add(newType);
 			} else {
-				DefaultTypeDefinition newType = new DefaultTypeDefinition(usingScope.ProjectContent, usingScope.NamespaceName, name);
+				newType = new DefaultTypeDefinition(usingScope.ProjectContent, usingScope.NamespaceName, name);
 				parsedFile.TopLevelTypeDefinitions.Add(newType);
-				return newType;
 			}
+			return newType;
 		}
 		
 		public override IEntity VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
@@ -92,28 +100,141 @@ namespace ICSharpCode.NRefactory.CSharp
 			td.AddDefaultConstructorIfRequired = true;
 			
 			ConvertAttributes(td.Attributes, typeDeclaration.Attributes);
-			// TODO: modifiers
+			ApplyModifiers(td, typeDeclaration.Modifiers);
+			if (td.ClassType == ClassType.Interface)
+				td.IsAbstract = true; // interfaces are implicitly abstract
+			else if (td.ClassType == ClassType.Enum || td.ClassType == ClassType.Struct)
+				td.IsSealed = true; // enums/structs are implicitly sealed
 			
-			//ConvertTypeParameters(td.TypeParameters, typeDeclaration.TypeArguments, typeDeclaration.Constraints, td);
+			//TODO ConvertTypeParameters(td.TypeParameters, typeDeclaration.TypeArguments, typeDeclaration.Constraints, td);
 			
 			// TODO: base type references?
 			
-			// TODO: members
+			foreach (AbstractMemberBase member in typeDeclaration.Members) {
+				member.AcceptVisitor(this, data);
+			}
 			
 			currentTypeDefinition = (DefaultTypeDefinition)currentTypeDefinition.DeclaringTypeDefinition;
 			return td;
 		}
 		
-		public override IEntity VisitEnumDeclaration(EnumDeclaration enumDeclaration, object data)
+		public override IEntity VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data)
+		{
+			var td = CreateTypeDefinition(delegateDeclaration.Name);
+			td.ClassType = ClassType.Delegate;
+			td.Region = MakeRegion(delegateDeclaration.StartLocation, delegateDeclaration.EndLocation);
+			td.BaseTypes.Add(multicastDelegateReference);
+			
+			ConvertAttributes(td.Attributes, delegateDeclaration.Attributes);
+			ApplyModifiers(td, delegateDeclaration.Modifiers);
+			td.IsSealed = true; // delegates are implicitly sealed
+			
+			// TODO: convert return type, convert parameters
+			AddDefaultMethodsToDelegate(td, SharedTypes.UnknownType, EmptyList<IParameter>.Instance);
+			
+			return td;
+		}
+		
+		static readonly ITypeReference multicastDelegateReference = typeof(MulticastDelegate).ToTypeReference();
+		static readonly IParameter delegateObjectParameter = MakeParameter(TypeCode.Object.ToTypeReference(), "object");
+		static readonly IParameter delegateIntPtrMethodParameter = MakeParameter(typeof(IntPtr).ToTypeReference(), "method");
+		static readonly IParameter delegateAsyncCallbackParameter = MakeParameter(typeof(AsyncCallback).ToTypeReference(), "callback");
+		static readonly IParameter delegateResultParameter = MakeParameter(typeof(IAsyncResult).ToTypeReference(), "result");
+		
+		static IParameter MakeParameter(ITypeReference type, string name)
+		{
+			DefaultParameter p = new DefaultParameter(type, name);
+			p.Freeze();
+			return p;
+		}
+		
+		/// <summary>
+		/// Adds the 'Invoke', 'BeginInvoke', 'EndInvoke' methods, and a constructor, to the <see cref="delegateType"/>.
+		/// </summary>
+		public static void AddDefaultMethodsToDelegate(DefaultTypeDefinition delegateType, ITypeReference returnType, IEnumerable<IParameter> parameters)
 		{
-			return VisitTypeDeclaration(enumDeclaration, data);
+			if (delegateType == null)
+				throw new ArgumentNullException("delegateType");
+			if (returnType == null)
+				throw new ArgumentNullException("returnType");
+			if (parameters == null)
+				throw new ArgumentNullException("parameters");
+			
+			DomRegion region = new DomRegion(delegateType.Region.FileName, delegateType.Region.BeginLine, delegateType.Region.BeginColumn);
+			
+			DefaultMethod invoke = new DefaultMethod(delegateType, "Invoke");
+			invoke.Accessibility = Accessibility.Public;
+			invoke.IsSynthetic = true;
+			invoke.Parameters.AddRange(parameters);
+			invoke.ReturnType = returnType;
+			invoke.Region = region;
+			delegateType.Methods.Add(invoke);
+			
+			DefaultMethod beginInvoke = new DefaultMethod(delegateType, "BeginInvoke");
+			beginInvoke.Accessibility = Accessibility.Public;
+			beginInvoke.IsSynthetic = true;
+			beginInvoke.Parameters.AddRange(invoke.Parameters);
+			beginInvoke.Parameters.Add(delegateAsyncCallbackParameter);
+			beginInvoke.Parameters.Add(delegateObjectParameter);
+			beginInvoke.ReturnType = delegateResultParameter.Type;
+			beginInvoke.Region = region;
+			delegateType.Methods.Add(beginInvoke);
+			
+			DefaultMethod endInvoke = new DefaultMethod(delegateType, "EndInvoke");
+			endInvoke.Accessibility = Accessibility.Public;
+			endInvoke.IsSynthetic = true;
+			endInvoke.Parameters.Add(delegateResultParameter);
+			endInvoke.ReturnType = invoke.ReturnType;
+			endInvoke.Region = region;
+			delegateType.Methods.Add(endInvoke);
+			
+			DefaultMethod ctor = new DefaultMethod(delegateType, ".ctor");
+			ctor.EntityType = EntityType.Constructor;
+			ctor.Accessibility = Accessibility.Public;
+			ctor.IsSynthetic = true;
+			ctor.Parameters.Add(delegateObjectParameter);
+			ctor.Parameters.Add(delegateIntPtrMethodParameter);
+			ctor.ReturnType = delegateType;
+			ctor.Region = region;
+			delegateType.Methods.Add(ctor);
+		}
+		#endregion
+		
+		#region Modifiers
+		static void ApplyModifiers(DefaultTypeDefinition td, Modifiers modifiers)
+		{
+			td.Accessibility = GetAccessibility(modifiers) ?? (td.DeclaringTypeDefinition != null ? Accessibility.Private : Accessibility.Internal);
+			td.IsAbstract = (modifiers & (Modifiers.Abstract | Modifiers.Static)) != 0;
+			td.IsSealed = (modifiers & (Modifiers.Sealed | Modifiers.Static)) != 0;
+			td.IsShadowing = (modifiers & Modifiers.New) != 0;
+		}
+		
+		static Accessibility? GetAccessibility(Modifiers modifiers)
+		{
+			switch (modifiers & Modifiers.VisibilityMask) {
+				case Modifiers.Private:
+					return Accessibility.Private;
+				case Modifiers.Internal:
+					return Accessibility.Internal;
+				case Modifiers.Protected | Modifiers.Internal:
+					return Accessibility.ProtectedOrInternal;
+				case Modifiers.Protected:
+					return Accessibility.Protected;
+				case Modifiers.Public:
+					return Accessibility.Public;
+				default:
+					return null;
+			}
 		}
+		#endregion
 		
+		#region Attributes
 		void ConvertAttributes(IList<IAttribute> outputList, IEnumerable<AttributeSection> attributes)
 		{
 			foreach (AttributeSection section in attributes) {
 				throw new NotImplementedException();
 			}
 		}
+		#endregion
 	}
 }

ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs

@@ -1677,6 +1677,24 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		}
 		#endregion
 		
+		#region ResolveObjectCreation
+		public ResolveResult ResolveObjectCreation(IType type, ResolveResult[] arguments, string[] argumentNames = null)
+		{
+			OverloadResolution or = new OverloadResolution(context, arguments, argumentNames, new IType[0]);
+			MemberLookup lookup = CreateMemberLookup();
+			bool allowProtectedAccess = lookup.AllowProtectedAccess(type);
+			var constructors = type.GetConstructors(context, m => lookup.IsAccessible(m, allowProtectedAccess));
+			foreach (IMethod ctor in constructors) {
+				or.AddCandidate(ctor);
+			}
+			if (or.BestCandidate != null) {
+				return new MemberResolveResult(or.BestCandidate, type);
+			} else {
+				return new ErrorResolveResult(type);
+			}
+		}
+		#endregion
+		
 		#region ResolveSizeOf
 		/// <summary>
 		/// Resolves 'sizeof(type)'.

ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs

@@ -98,11 +98,6 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				resolver.CurrentTypeDefinition = previousTypeDefinition;
 			}
 		}
-		
-		public override ResolveResult VisitEnumDeclaration(EnumDeclaration enumDeclaration, object data)
-		{
-			return VisitTypeDeclaration(enumDeclaration, data);
-		}
 		#endregion
 		
 		#region Track CheckForOverflow
@@ -254,28 +249,31 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			                                  IsTargetOfInvocation(identifierExpression));
 		}
 		
+		ResolveResult[] GetArguments(IEnumerable<INode> argumentExpressions, out string[] argumentNames)
+		{
+			argumentNames = null; // TODO: add support for named arguments
+			ResolveResult[] arguments = new ResolveResult[argumentExpressions.Count()];
+			int i = 0;
+			foreach (INode argument in argumentExpressions) {
+				arguments[i++] = Resolve(argument);
+			}
+			return arguments;
+		}
+		
 		public override ResolveResult VisitIndexerExpression(IndexerExpression indexerExpression, object data)
 		{
 			ResolveResult target = Resolve(indexerExpression.Target);
-			// TODO: add support for named arguments
-			var argumentExpressions = indexerExpression.Arguments.ToList();
-			ResolveResult[] arguments = new ResolveResult[argumentExpressions.Count];
-			for (int i = 0; i < arguments.Length; i++) {
-				arguments[i] = Resolve(argumentExpressions[i]);
-			}
-			return resolver.ResolveIndexer(target, arguments);
+			string[] argumentNames;
+			ResolveResult[] arguments = GetArguments(indexerExpression.Arguments, out argumentNames);
+			return resolver.ResolveIndexer(target, arguments, argumentNames);
 		}
 		
 		public override ResolveResult VisitInvocationExpression(InvocationExpression invocationExpression, object data)
 		{
 			ResolveResult target = Resolve(invocationExpression.Target);
-			// TODO: add support for named arguments
-			var argumentExpressions = invocationExpression.Arguments.ToList();
-			ResolveResult[] arguments = new ResolveResult[argumentExpressions.Count];
-			for (int i = 0; i < arguments.Length; i++) {
-				arguments[i] = Resolve(argumentExpressions[i]);
-			}
-			return resolver.ResolveInvocation(target, arguments);
+			string[] argumentNames;
+			ResolveResult[] arguments = GetArguments(invocationExpression.Arguments, out argumentNames);
+			return resolver.ResolveInvocation(target, arguments, argumentNames);
 		}
 		
 		public override ResolveResult VisitIsExpression(IsExpression isExpression, object data)
@@ -307,7 +305,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		public override ResolveResult VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
 		{
-			throw new NotImplementedException();
+			IType type = ResolveType(objectCreateExpression.Type);
+			string[] argumentNames;
+			ResolveResult[] arguments = GetArguments(objectCreateExpression.Arguments, out argumentNames);
+			return resolver.ResolveObjectCreation(type, arguments, argumentNames);
 		}
 		
 		public override ResolveResult VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)

ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj

@@ -299,6 +299,7 @@
     <Compile Include="Utils\CacheManager.cs" />
     <Compile Include="Utils\CSharpPrimitiveCast.cs" />
     <Compile Include="Utils\EmptyList.cs" />
+    <Compile Include="Utils\ExtensionMethods.cs" />
     <Compile Include="Utils\TreeTraversal.cs" />
     <Compile Include="CSharp\Dom\ComposedType.cs" />
     <Compile Include="CSharp\Dom\Expressions\DirectionExpression.cs" />

ICSharpCode.NRefactory/TypeSystem/Accessibility.cs

@@ -35,10 +35,12 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// <summary>
 		/// The entity is accessible both everywhere in the project content, and in all derived classes.
 		/// </summary>
+		/// <remarks>This corresponds to C# 'protected internal'.</remarks>
 		ProtectedOrInternal,
 		/// <summary>
 		/// The entity is accessible in derived classes within the same project content.
 		/// </summary>
+		/// <remarks>C# does not support this accessibility.</remarks>
 		ProtectedAndInternal,
 	}
 }

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultMethod.cs

@@ -122,7 +122,6 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				Accessibility = typeDefinition.IsAbstract ? Accessibility.Protected : Accessibility.Public,
 				IsSynthetic = true,
 				Region = region,
-				BodyRegion = region,
 				ReturnType = typeDefinition
 			};
 		}

ICSharpCode.NRefactory/Utils/ExtensionMethods.cs

@@ -0,0 +1,20 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+
+namespace ICSharpCode.NRefactory.Utils
+{
+	/// <summary>
+	/// Contains extension methods for use within NRefactory.
+	/// </summary>
+	internal static class ExtensionMethods
+	{
+		public static void AddRange<T>(this ICollection<T> target, IEnumerable<T> input)
+		{
+			foreach (T item in input)
+				target.Add(item);
+		}
+	}
+}