Update to NRefactory commit b880fc60.

b880fc6 Fix possible NullReferenceException in XmlDocIssue.GatherVisitor.CheckXmlDoc()
9f6b757 Fix potential NullReferenceException in RedundantExtendsListEntryIssue
f73c7c0 Fix NullReferenceException in RedundantThisQualifierIssue.
3d2fb77 Fix possible ArgumentNullException in CS0169FieldIsNeverUsedIssue and related issues.
e8e5240 Fix ArgumentOutOfRangeException in ResolveVisitor.VisitArrayCreateExpression().
3082317 Fix NullReferenceException in AddArgumentNameAction.
b92f505 Fix NullReferenceException in NullAnalysisVisitor.VisitObjectCreateExpression
72d62f6 Guard ikvm loader against null namespaces.
ef6b76e Fix NullReferenceException in OwnedParameterReference.Resolve.
dcaa3a2 Fix constant folding for binary operators on enum values if mscorlib isn't loaded.
2c8646d Suppress ExplicitConversionInForEachIssue if variable has unknown type.
1ae6ba2 Fixed bug in CopyCommentsFromInterface
9deefa8 Fixed potiental crash in ConvertImplicitToExplicitImplementationAction
c5ca3ac Fixed add imports bug.
721ce12 Filter out synthetic types in import items.
909088b Ignored failing unit test.
75c6ad3 AlignEmbeddedIf/Using statement is now AlignEmbeddedStatements & works now with embedded lock statements as well.

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/AddArgumentNameAction.cs

@@ -23,12 +23,13 @@
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
 using ICSharpCode.NRefactory.TypeSystem;
 using ICSharpCode.NRefactory.CSharp;
 using ICSharpCode.NRefactory.Semantics;
-using ICSharpCode.NRefactory.Refactoring;
 using System.Linq;
-using System.Text;
 using ICSharpCode.NRefactory.CSharp.Resolver;
 
 namespace ICSharpCode.NRefactory.CSharp.Refactoring
@@ -36,9 +37,6 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 	/// <summary>
 	///  Add name for argument
 	/// </summary>
-	using System;
-	using System.Collections.Generic;
-	
 	[ContextAction("Add name for argument", Description = "Add name for argument including method, indexer invocation and Attibute Usage")]
 	public class AddArgumentNameAction : SpecializedCodeAction<Expression>
 	{
@@ -73,12 +71,13 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			if (!(parent is CSharp.Attribute) && !(parent is IndexerExpression) && !(parent is InvocationExpression))
 				return null;
 
-			if (parent is CSharp.Attribute) {
+			var attribute = parent as CSharp.Attribute;
-				var resolvedResult = context.Resolve(parent as CSharp.Attribute);
+			if (attribute != null) {
-				if (resolvedResult.IsError)
+				var resolvedResult = context.Resolve(attribute) as CSharpInvocationResolveResult;
+				if (resolvedResult == null || resolvedResult.IsError)
 					return null;
-				var arguments = (parent as CSharp.Attribute).Arguments;
+				var arguments = attribute.Arguments;
-				IMember member = (resolvedResult as CSharpInvocationResolveResult).Member;
+				IMember member = resolvedResult.Member;
 
 				int index = 0;
 				int temp = 0; 
@@ -97,17 +96,17 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				if (method == null || method.Parameters.Count == 0 || method.Parameters.Last().IsParams)
 					return null;
 
-				var parameterMap = (resolvedResult as CSharpInvocationResolveResult).GetArgumentToParameterMap();
+				var parameterMap = resolvedResult.GetArgumentToParameterMap();
 				var parameters = method.Parameters;
 				if (index >= parameterMap.Count)
 					return null;
-				var name = parameters.ElementAt(parameterMap [index]).Name;
+				var name = parameters[parameterMap[index]].Name;
 				return new CodeAction(string.Format(context.TranslateString("Add argument name '{0}'"), name), script => {
 					for (int i = 0; i < nodes.Count; i++) {
 						int p = index + i;
 						if (p >= parameterMap.Count)
 							break;
-						name = parameters.ElementAt(parameterMap [p]).Name;
+						name = parameters[parameterMap[p]].Name;
 						var namedArgument = new NamedArgumentExpression(name, arguments.ElementAt(p).Clone());
 						script.Replace(arguments.ElementAt(p), namedArgument);
 					}}, 
@@ -115,12 +114,13 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				);
 			} 
 
-			if (parent is IndexerExpression) {
+			var indexerExpression = parent as IndexerExpression;
-				var resolvedResult = context.Resolve(parent as IndexerExpression);
+			if (indexerExpression != null) {
-				if (resolvedResult.IsError)
+				var resolvedResult = context.Resolve(indexerExpression) as CSharpInvocationResolveResult;
+				if (resolvedResult == null || resolvedResult.IsError)
 					return null;
-				var arguments = (parent as IndexerExpression).Arguments;
+				var arguments = indexerExpression.Arguments;
-				IMember member = (resolvedResult as CSharpInvocationResolveResult).Member;
+				IMember member = resolvedResult.Member;
 				
 				int index = 0;
 				int temp = 0; 
@@ -139,17 +139,17 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				if (property == null || property.Parameters.Count == 0 || property.Parameters.Last().IsParams) {
 					return null;
 				}
-				var parameterMap = (resolvedResult as CSharpInvocationResolveResult).GetArgumentToParameterMap();
+				var parameterMap = resolvedResult.GetArgumentToParameterMap();
 				var parameters = property.Parameters;
 				if (index >= parameterMap.Count)
 					return null;
-				var name = parameters.ElementAt(parameterMap [index]).Name;
+				var name = parameters[parameterMap[index]].Name;
 				return new CodeAction(string.Format(context.TranslateString("Add argument name '{0}'"), name), script => {
 					for (int i = 0; i< nodes.Count; i++) {
 						int p = index + i;
 						if (p >= parameterMap.Count)
 							break;
-						name = parameters.ElementAt(parameterMap [p]).Name;
+						name = parameters[parameterMap[p]].Name;
 						var namedArgument = new NamedArgumentExpression(name, arguments.ElementAt(p).Clone());
 						script.Replace(arguments.ElementAt(p), namedArgument);
 					}}, 
@@ -157,12 +157,13 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				);
 			} 
 
-			if (parent is InvocationExpression) {
+			var invocationExpression = parent as InvocationExpression;
-				var resolvedResult = context.Resolve(parent as InvocationExpression);
+			if (invocationExpression != null) {
-				if (resolvedResult.IsError)
+				var resolvedResult = context.Resolve(invocationExpression) as CSharpInvocationResolveResult;
+				if (resolvedResult == null || resolvedResult.IsError)
 					return null;
-				var arguments = (parent as InvocationExpression).Arguments;
+				var arguments = invocationExpression.Arguments;
-				IMember member = (resolvedResult as CSharpInvocationResolveResult).Member;
+				IMember member = resolvedResult.Member;
 				
 				int index = 0;
 				int temp = 0; 
@@ -186,13 +187,13 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				var parameters = method.Parameters;
 				if (index >= parameterMap.Count)
 					return null;
-				var name = parameters.ElementAt(parameterMap [index]).Name;
+				var name = parameters[parameterMap[index]].Name;
 				return new CodeAction(string.Format(context.TranslateString("Add argument name '{0}'"), name), script => {
 					for (int i = 0; i< nodes.Count; i++) {
 						int p = index + i;
 						if (p >= parameterMap.Count)
 							break;
-						name = parameters.ElementAt(parameterMap [p]).Name;
+						name = parameters[parameterMap[p]].Name;
 						var namedArgument = new NamedArgumentExpression(name, arguments.ElementAt(p).Clone());
 						script.Replace(arguments.ElementAt(p), namedArgument);
 					}}, 

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/ConvertImplicitToExplicitImplementationAction.cs

@@ -41,8 +41,11 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			if (!node.NameToken.Contains (context.Location))
 				return null;
 
-			var method = (IMethod)((MemberResolveResult)context.Resolve (node)).Member;
+			var memberResolveResult = context.Resolve(node) as MemberResolveResult;
-			if (method.ImplementedInterfaceMembers.Count != 1 || method.DeclaringType.Kind == TypeKind.Interface)
+			if (memberResolveResult == null)
+				return null;
+			var method = memberResolveResult.Member as IMethod;
+			if (method == null || method.ImplementedInterfaceMembers.Count != 1 || method.DeclaringType.Kind == TypeKind.Interface)
 				return null;
 
 			return new CodeAction (context.TranslateString ("Convert implict to explicit implementation"),

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/CopyCommentsFromInterface.cs

@@ -46,9 +46,11 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			if (!node.NameToken.Contains(context.Location))
 				return null;
 			
-			var method = (IMethod)((MemberResolveResult)context.Resolve(node)).Member;
+			var memberResolveResult = context.Resolve(node) as MemberResolveResult;
-			
+			if (memberResolveResult == null)
-			if (method.Documentation != null)
+				return null;
+			var method = memberResolveResult.Member as IMethod;
+			if (method == null || method.Documentation != null)
 				return null;
 			
 			IList<IMember> interfaceMethods = method.ImplementedInterfaceMembers;

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Custom/CompilerErrors/CS0169FieldIsNeverUsedIssue.cs

@@ -85,16 +85,16 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						if (def != null && def.KnownTypeCode == KnownTypeCode.None) {
 							// user-defined value type -- might be mutable
 							continue;
-						} else if (ctx.Resolve (variable.Initializer) is ConstantResolveResult) {
+						} else if (ctx.Resolve (variable.Initializer).IsCompileTimeConstant) {
 							// handled by ConvertToConstantIssue
 							continue;
 						}
 					}
 
 					var mr = ctx.Resolve(variable) as MemberResolveResult;
-					if (mr == null)
+					if (mr == null || !(mr.Member is IVariable))
 						continue;
-					list.Add(Tuple.Create(variable, mr.Member as IVariable)); 
+					list.Add(Tuple.Create(variable, (IVariable)mr.Member)); 
 				}
 				base.VisitTypeDeclaration(typeDeclaration);
 				Collect();

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Custom/XmlDocIssue.cs

@@ -168,7 +168,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 								var name = el.Attributes.FirstOrDefault(attr => attr.Name == "name");
 								if (name == null)
 									break;
-								if (member.SymbolKind == SymbolKind.TypeDefinition) {
+								if (member != null && member.SymbolKind == SymbolKind.TypeDefinition) {
 									var type = (ITypeDefinition)member;
 									if (!type.TypeArguments.Any(arg => arg.Name == name.Value)) {
 										AddXmlIssue(name.ValueSegment.Offset - firstline.Length + 1, name.ValueSegment.Length - 2, string.Format(ctx.TranslateString("Type parameter '{0}' not found"), name.Value));
@@ -183,7 +183,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 								var m = member as IParameterizedMember;
 								if (m != null && m.Parameters.Any(p => p.Name == name.Value))
 									break;
-								if (name.Value == "value" && (member.SymbolKind == SymbolKind.Property || member.SymbolKind == SymbolKind.Indexer || member.SymbolKind == SymbolKind.Event) && el.Name == "paramref")
+								if (name.Value == "value" && member != null && (member.SymbolKind == SymbolKind.Property || member.SymbolKind == SymbolKind.Indexer || member.SymbolKind == SymbolKind.Event) && el.Name == "paramref")
 									break;
 								AddXmlIssue(name.ValueSegment.Offset - firstline.Length + 1, name.ValueSegment.Length - 2, string.Format(ctx.TranslateString("Parameter '{0}' not found"), name.Value));
 								break;

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/PracticesAndImprovements/ConvertToConstantIssue.cs

@@ -148,7 +148,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						continue;
 					if (fieldDeclaration.HasModifier(Modifiers.Public) || fieldDeclaration.HasModifier(Modifiers.Protected) || fieldDeclaration.HasModifier(Modifiers.Internal))
 						continue;
-					if (fieldDeclaration.Variables.Any (v => !(ctx.Resolve (v.Initializer) is ConstantResolveResult)))
+					if (fieldDeclaration.Variables.Any (v => !ctx.Resolve (v.Initializer).IsCompileTimeConstant))
 						continue;
 					var rr = ctx.Resolve(fieldDeclaration.ReturnType);
 					if (!IsValidConstType(rr.Type))
@@ -157,9 +157,9 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						continue;
 					var variable = fieldDeclaration.Variables.First();
 					var mr = ctx.Resolve(variable) as MemberResolveResult;
-					if (mr == null)
+					if (mr == null || !(mr.Member is IVariable))
 						continue;
-					list.Add(Tuple.Create(variable, mr.Member as IVariable)); 
+					list.Add(Tuple.Create(variable, (IVariable)mr.Member)); 
 				}
 				base.VisitTypeDeclaration(typeDeclaration);
 				Collect();
@@ -173,7 +173,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					return;
 				if (varDecl.Variables.Count () > 1)
 					return;
-				if (varDecl.Variables.Any (v => !(ctx.Resolve (v.Initializer) is ConstantResolveResult)))
+				if (varDecl.Variables.Any (v => !ctx.Resolve (v.Initializer).IsCompileTimeConstant))
 					return;
 				var containingBlock = varDecl.GetParent<BlockStatement> ();
 				if (containingBlock == null)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/PracticesAndImprovements/FieldCanBeMadeReadOnlyIssue.cs

@@ -96,16 +96,16 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						if (def != null && def.KnownTypeCode == KnownTypeCode.None) {
 							// user-defined value type -- might be mutable
 							continue;
-						} else if (ctx.Resolve (variable.Initializer) is ConstantResolveResult) {
+						} else if (ctx.Resolve (variable.Initializer).IsCompileTimeConstant) {
 							// handled by ConvertToConstantIssue
 							continue;
 						}
 					}
 
 					var mr = ctx.Resolve(variable) as MemberResolveResult;
-					if (mr == null)
+					if (mr == null || !(mr.Member is IVariable))
 						continue;
-					list.Add(Tuple.Create(variable, mr.Member as IVariable, VariableState.None)); 
+					list.Add(Tuple.Create(variable, (IVariable)mr.Member, VariableState.None)); 
 				}
 				base.VisitTypeDeclaration(typeDeclaration);
 				Collect();

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/RedundanciesInCode/RedundantBaseQualifierIssue.cs

@@ -107,7 +107,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				if (member == null)
 					return;
 
-				if (declarationsSpaceVisitor.GetDeclarationSpace(baseReferenceExpression).IsNameUsed(member.Name))
+				var localDeclarationSpace = declarationsSpaceVisitor.GetDeclarationSpace(baseReferenceExpression);
+				if (localDeclarationSpace == null || localDeclarationSpace.IsNameUsed(member.Name))
 					return;
 
 				var result = state.LookupSimpleNameOrTypeName(memberReference.MemberName, EmptyList<IType>.Instance, NameLookupMode.Expression);

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/RedundanciesInCode/RedundantExtendsListEntryIssue.cs

@@ -65,7 +65,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				List<AstNode> redundantBase = new List<AstNode>();
 				var type = ctx.Resolve(typeDeclaration).Type;
 
-				if (typeDeclaration.HasModifier(Modifiers.Partial)) {
+				if (typeDeclaration.HasModifier(Modifiers.Partial) && type.GetDefinition() != null) {
 					var parts = type.GetDefinition().Parts;
 					foreach (var node in typeDeclaration.BaseTypes) {
 						int count = 0;

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/RedundanciesInCode/RedundantThisQualifierIssue.cs

@@ -172,7 +172,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					return;
 				}
 
-				if (declarationsSpaceVisitor.GetDeclarationSpace(thisReferenceExpression).IsNameUsed(member.Name))
+				var localDeclarationSpace = declarationsSpaceVisitor.GetDeclarationSpace(thisReferenceExpression);
+				if (localDeclarationSpace == null || localDeclarationSpace.IsNameUsed(member.Name))
 					return;
 
 				var result = state.LookupSimpleNameOrTypeName(memberReference.MemberName, EmptyList<IType>.Instance, NameLookupMode.Expression);

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Uncategorized/ExplicitConversionInForEachIssue.cs

@@ -50,7 +50,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				var rr = ctx.Resolve(foreachStatement) as ForEachResolveResult;
 				if (rr == null)
 					return;
-				if (rr.ElementType.Kind == TypeKind.Unknown)
+				if (rr.ElementType.Kind == TypeKind.Unknown || rr.ElementVariable.Type.Kind == TypeKind.Unknown)
 					return;
 				if (ReflectionHelper.GetTypeCode(rr.ElementType) == TypeCode.Object)
 					return;

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Analysis/NullValueAnalysis.cs

@@ -1702,8 +1702,6 @@ namespace ICSharpCode.NRefactory.CSharp.Analysis
 
 			public override VisitorResult VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, VariableStatusInfo data)
 			{
-				var constructorResolveResult = analysis.context.Resolve(objectCreateExpression) as CSharpInvocationResolveResult;
-
 				foreach (var argumentToHandle in objectCreateExpression.Arguments.Select((argument, parameterIndex) => new { argument, parameterIndex })) {
 					var argument = argumentToHandle.argument;
 					var parameterIndex = argumentToHandle.parameterIndex;
@@ -1717,7 +1715,9 @@ namespace ICSharpCode.NRefactory.CSharp.Analysis
 							//out and ref parameters do *NOT* capture the variable (since they must stop changing it by the time they return)
 							data = data.Clone();
 
-							FixParameter(argument, constructorResolveResult.Member.Parameters, parameterIndex, identifier, data);
+							var constructorResolveResult = analysis.context.Resolve(objectCreateExpression) as CSharpInvocationResolveResult;
+							if (constructorResolveResult != null)
+								FixParameter(argument, constructorResolveResult.Member.Parameters, parameterIndex, identifier, data);
 						}
 						continue;
 					}

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@@ -1989,7 +1989,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 					// flatten usings
 					var importList = new List<ICompletionData>();
 					var dict = new Dictionary<string, Dictionary<string, ICompletionData>>();
-					foreach (var type in Compilation.GetAllTypeDefinitions ()) {
+					foreach (var type in Compilation.GetTopLevelTypeDefinitons ()) {
 						if (!lookup.IsAccessible(type, false))
 							continue;
 						if (namespaces.Any(n => n.FullName == type.Namespace))

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Formatter/CSharpFormattingOptions.cs

@@ -150,12 +150,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			set;
 		}
 
-		public bool AlignEmbeddedUsingStatements { // tested
+		public bool AlignEmbeddedStatements { // tested
-			get;
-			set;
-		}
-
-		public bool AlignEmbeddedIfStatements { // tested
 			get;
 			set;
 		}

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Formatter/FormattingOptionsFactory.cs

@@ -150,8 +150,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				SpaceAfterForSemicolon = true,
 				SpaceAfterTypecast = false,
 				
-				AlignEmbeddedIfStatements = true,
+				AlignEmbeddedStatements = true,
-				AlignEmbeddedUsingStatements = true,
 				SimplePropertyFormatting = PropertyFormatting.AllowOneLine,
 				AutoPropertyFormatting = PropertyFormatting.AllowOneLine,
 				EmptyLineFormatting = EmptyLineFormatting.DoNotIndent,
@@ -323,8 +322,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				SpaceAfterForSemicolon = true,
 				SpaceAfterTypecast = false,
 				
-				AlignEmbeddedIfStatements = true,
+				AlignEmbeddedStatements = true,
-				AlignEmbeddedUsingStatements = true,
 				SimplePropertyFormatting = PropertyFormatting.AllowOneLine,
 				AutoPropertyFormatting = PropertyFormatting.AllowOneLine,
 				EmptyLineFormatting = EmptyLineFormatting.DoNotIndent,

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Formatter/FormattingVisitor_Statements.cs

@@ -143,8 +143,9 @@ namespace ICSharpCode.NRefactory.CSharp
 			bool pushed = false;
 
 			if (policy.IndentBlocks && !(
-					policy.AlignEmbeddedIfStatements && node is IfElseStatement && node.Parent is IfElseStatement || 
+				policy.AlignEmbeddedStatements && node is IfElseStatement && node.Parent is IfElseStatement || 
-					policy.AlignEmbeddedUsingStatements && node is UsingStatement && node.Parent is UsingStatement)) { 
+				policy.AlignEmbeddedStatements && node is UsingStatement && node.Parent is UsingStatement || 
+				policy.AlignEmbeddedStatements && node is LockStatement && node.Parent is LockStatement)) { 
 				curIndent.Push(IndentType.Block);
 				pushed = true;
 			}

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/IndentEngine/IndentState.cs

@@ -752,7 +752,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 
 				// OPTION: CSharpFormattingOptions.AlignEmbeddedIfStatements
-				if (Engine.formattingOptions.AlignEmbeddedIfStatements &&
+				if (Engine.formattingOptions.AlignEmbeddedStatements &&
 					previousStatement == Statement.If &&
 					CurrentStatement == Statement.If)
 				{
@@ -760,8 +760,17 @@ namespace ICSharpCode.NRefactory.CSharp
 					NextLineIndent.PopIf(IndentType.Continuation);
 				}
 
+				// OPTION: CSharpFormattingOptions.AlignEmbeddedStatements
+				if (Engine.formattingOptions.AlignEmbeddedStatements &&
+					previousStatement == Statement.Lock &&
+					CurrentStatement == Statement.Lock)
+				{
+					ThisLineIndent.PopIf(IndentType.Continuation);
+					NextLineIndent.PopIf(IndentType.Continuation);
+				}
+
 				// OPTION: CSharpFormattingOptions.AlignEmbeddedUsingStatements
-				if (Engine.formattingOptions.AlignEmbeddedUsingStatements &&
+				if (Engine.formattingOptions.AlignEmbeddedStatements &&
 					previousStatement == Statement.Using &&
 					CurrentStatement == Statement.Using)
 				{

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

@@ -478,10 +478,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 							// evaluate as (E)(~(U)x);
 							var U = compilation.FindType(expression.ConstantValue.GetType());
 							var unpackedEnum = new ConstantResolveResult(U, expression.ConstantValue);
-							return CheckErrorAndResolveUncheckedCast(expression.Type, ResolveUnaryOperator(op, unpackedEnum));
+							var rr = ResolveUnaryOperator(op, unpackedEnum);
-						} else {
+							rr = WithCheckForOverflow(false).ResolveCast(type, rr);
-							return UnaryOperatorResolveResult(expression.Type, op, expression, isNullable);
+							if (rr.IsCompileTimeConstant)
-						}
+								return rr;
+						} 
+						return UnaryOperatorResolveResult(expression.Type, op, expression, isNullable);
 					} else {
 						methodGroup = operators.BitwiseComplementOperators;
 						break;
@@ -943,14 +945,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			// evaluate as ((U)x op (U)y)
 			IType elementType = GetEnumUnderlyingType(enumType);
-			if (lhs.IsCompileTimeConstant && rhs.IsCompileTimeConstant && !isNullable) {
+			if (lhs.IsCompileTimeConstant && rhs.IsCompileTimeConstant && !isNullable && elementType.Kind != TypeKind.Enum) {
-				lhs = ResolveCast(elementType, lhs);
+				var rr = ResolveBinaryOperator(op, ResolveCast(elementType, lhs), ResolveCast(elementType, rhs));
-				if (lhs.IsError)
+				if (rr.IsCompileTimeConstant)
-					return lhs;
+					return rr;
-				rhs = ResolveCast(elementType, rhs);
-				if (rhs.IsError)
-					return rhs;
-				return ResolveBinaryOperator(op, lhs, rhs);
 			}
 			IType resultType = compilation.FindType(KnownTypeCode.Boolean);
 			return BinaryOperatorResolveResult(resultType, lhs, op, rhs, isNullable);
@@ -964,14 +962,11 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			// evaluate as (U)((U)x – (U)y)
 			IType elementType = GetEnumUnderlyingType(enumType);
-			if (lhs.IsCompileTimeConstant && rhs.IsCompileTimeConstant && !isNullable) {
+			if (lhs.IsCompileTimeConstant && rhs.IsCompileTimeConstant && !isNullable && elementType.Kind != TypeKind.Enum) {
-				lhs = ResolveCast(elementType, lhs);
+				var rr = ResolveBinaryOperator(BinaryOperatorType.Subtract, ResolveCast(elementType, lhs), ResolveCast(elementType, rhs));
-				if (lhs.IsError)
+				rr = WithCheckForOverflow(false).ResolveCast(elementType, rr);
-					return lhs;
+				if (rr.IsCompileTimeConstant)
-				rhs = ResolveCast(elementType, rhs);
+					return rr;
-				if (rhs.IsError)
-					return rhs;
-				return CheckErrorAndResolveUncheckedCast(elementType, ResolveBinaryOperator(BinaryOperatorType.Subtract, lhs, rhs));
 			}
 			IType resultType = MakeNullable(elementType, isNullable);
 			return BinaryOperatorResolveResult(resultType, lhs, BinaryOperatorType.Subtract, rhs, isNullable);
@@ -991,13 +986,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			// evaluate as (E)((U)x op (U)y)
 			if (lhs.IsCompileTimeConstant && rhs.IsCompileTimeConstant && !isNullable) {
 				IType elementType = GetEnumUnderlyingType(enumType);
-				lhs = ResolveCast(elementType, lhs);
+				if (elementType.Kind != TypeKind.Enum) {
-				if (lhs.IsError)
+					var rr = ResolveBinaryOperator(op, ResolveCast(elementType, lhs), ResolveCast(elementType, rhs));
-					return lhs;
+					rr = WithCheckForOverflow(false).ResolveCast(enumType, rr);
-				rhs = ResolveCast(elementType, rhs);
+					if (rr.IsCompileTimeConstant) // only report result if it's a constant; use the regular OperatorResolveResult codepath otherwise
-				if (rhs.IsError)
+						return rr;
-					return rhs;
+				}
-				return CheckErrorAndResolveUncheckedCast(enumType, ResolveBinaryOperator(op, lhs, rhs));
 			}
 			IType resultType = MakeNullable(enumType, isNullable);
 			return BinaryOperatorResolveResult(resultType, lhs, op, rhs, isNullable);
@@ -1399,14 +1393,6 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			return Utils.CSharpPrimitiveCast.Cast(targetType, input, this.CheckForOverflow);
 		}
-		
-		ResolveResult CheckErrorAndResolveUncheckedCast(IType targetType, ResolveResult expression)
-		{
-			if (expression.IsError)
-				return expression;
-			else
-				return WithCheckForOverflow(false).ResolveCast(targetType, expression);
-		}
 		#endregion
 		
 		#region ResolveSimpleName

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

@@ -37,7 +37,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		// and then pass it into CSharpResolver.ResolveBinaryOperator().
 		// That method normally wraps input arguments into another conversion
 		// (the implicit conversion applied by the operator).
-		// However, identity conversions do not cause the creation ConversionResolveResult instances,
+		// However, identity conversions do not cause the creation of ConversionResolveResult instances,
 		// so the OperatorResolveResult's argument will be the CastResolveResult
 		// of the cast.
 		// Without this class (and instead using ConversionResolveResult for both purposes),

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

@@ -1229,7 +1229,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					dimensions = firstSpecifier.Dimensions;
 					additionalArraySpecifiers = arrayCreateExpression.AdditionalArraySpecifiers.Skip(1);
 				} else {
-					dimensions = 0;
+					// No array specifiers (neither with nor without size) - can happen if there are syntax errors.
+					// Dimensions must be at least one; otherwise 'new ArrayType' will crash.
+					dimensions = 1;
 					additionalArraySpecifiers = arrayCreateExpression.AdditionalArraySpecifiers;
 				}
 				sizeArguments = null;

src/Libraries/NRefactory/ICSharpCode.NRefactory.IKVM/IkvmLoader.cs

@@ -143,7 +143,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			foreach (var type in assembly.ManifestModule.__GetExportedTypes ()) {
 				if (type.Assembly != assembly) {
 					int typeParameterCount;
-					string ns = type.Namespace;
+					string ns = type.Namespace ?? "";
 					string name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(type.Name, out typeParameterCount);
 					ns = interningProvider.Intern(ns);
 					name = interningProvider.Intern(name);

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeIssues/ExplicitConversionInForEachIssueTests.cs

@@ -59,14 +59,16 @@ namespace ICSharpCode.NRefactory.CSharp.CodeIssues
 		[Test]
 		public void WarningOnExplicitConversionBetweenInterfaces ()
 		{
-			var input = @"using System.Collections.Generic;
+			var input = @"using System;
+using System.Collections.Generic;
 class Foo {
 	void Bar (IList<IList<IDisposable>> c)
 	{
 		foreach (IDisposable element in c) { }
 	}
 }";
-			string output = @"using System.Collections.Generic;
+			string output = @"using System;
+using System.Collections.Generic;
 class Foo {
 	void Bar (IList<IList<IDisposable>> c)
 	{
@@ -76,5 +78,21 @@ class Foo {
 			
 			Test<ExplicitConversionInForEachIssue>(input, output);
 		}
+		
+		[Test]
+		public void NoWarningOnMissingUsing ()
+		{
+			var input = @"class Foo {
+	void Bar (System.Collections.Generic.List<System.Text.StringBuilder> c)
+	{
+		foreach (StringBuilder b in c) { }
+	}
+}";
+
+			TestRefactoringContext context;
+			var issues = GetIssues (new ExplicitConversionInForEachIssue (), input, out context);
+			Assert.AreEqual (0, issues.Count);
+		}
+		
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeIssues/RedundantBaseQualifierTests.cs

@@ -207,5 +207,15 @@ class Foo : Base
 			var issues = GetIssues(new RedundantBaseQualifierIssue(), input, out context);
 			Assert.AreEqual(2, issues.Count);
 		}
+		
+		[Test]
+		public void InvalidUseOfBaseInFieldInitializer()
+		{
+			var input = @"class Foo
+{
+	int a = base.a;
+}";
+			TestWrongContext<RedundantBaseQualifierIssue>(input);
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeIssues/RedundantThisQualifierIssueTests.cs

@@ -373,5 +373,15 @@ class Foo
 	}
 }");
 		}
+		
+		[Test]
+		public void InvalidUseOfThisInFieldInitializer()
+		{
+			var input = @"class Foo
+{
+	int a = this.a;
+}";
+			TestWrongContextWithSubIssue<RedundantThisQualifierIssue>(input, RedundantThisQualifierIssue.EverywhereElse);
+		}
 	}
 }

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

@@ -17,8 +17,10 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System;
+using ICSharpCode.NRefactory.CSharp.TypeSystem;
 using ICSharpCode.NRefactory.Semantics;
 using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.NRefactory.TypeSystem.Implementation;
 using NUnit.Framework;
 
 namespace ICSharpCode.NRefactory.CSharp.Resolver
@@ -893,5 +895,23 @@ class C
 			Assert.IsTrue(c.IsUserDefined);
 			Assert.AreEqual("E", c.Method.ReturnType.ReflectionName);
 		}
+		
+		ITypeDefinition enumWithMissingBaseType = TypeSystemHelper.CreateCompilationWithoutCorlibAndResolve(
+			new DefaultUnresolvedTypeDefinition("MyEnum") {
+				Kind = TypeKind.Enum,
+				BaseTypes = { KnownTypeReference.Int32 }
+			}
+		);
+		
+		[Test]
+		public void EnumBitwiseOrWithMissingBaseType()
+		{
+			var resolver = new CSharpResolver(enumWithMissingBaseType.Compilation);
+			var lhs = new ConstantResolveResult(enumWithMissingBaseType, 1);
+			var rhs = new ConstantResolveResult(enumWithMissingBaseType, 2);
+			var rr = (ConstantResolveResult)resolver.ResolveBinaryOperator(BinaryOperatorType.BitwiseOr, lhs, rhs);
+			Assert.AreEqual(enumWithMissingBaseType, rr.Type);
+			Assert.AreEqual(3, rr.ConstantValue);
+		}
 	}
 }

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

@@ -400,6 +400,7 @@ class Activator {
 			Assert.AreEqual("Testnamespace.Activator", result.Type.FullName);
 		}
 
+		[Ignore("Fixme")]
 		[Test]
 		public void NamespaceDefinitionOverwritesTypeName ()
 		{

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/FormattingTests/TestStatementIndentation.cs

@@ -576,7 +576,7 @@ using (var o = new MyObj ()) {
 		public void TestUsingAlignment()
 		{
 			CSharpFormattingOptions policy = FormattingOptionsFactory.CreateMono();
-			policy.AlignEmbeddedUsingStatements = true;
+			policy.AlignEmbeddedStatements = true;
 			policy.ClassBraceStyle = BraceStyle.EndOfLine;
 			
 			var adapter = Test(policy, @"class Test {
@@ -595,7 +595,7 @@ using (var o = new MyObj ()) {
 		}
 	}
 }");
-			policy.AlignEmbeddedUsingStatements = false;
+			policy.AlignEmbeddedStatements = false;
 			Continue(policy, adapter, @"class Test {
 	Test TestMethod ()
 	{
@@ -973,7 +973,7 @@ do FooBar(); while (true);
 		public void TestIfAlignment()
 		{
 			CSharpFormattingOptions policy = FormattingOptionsFactory.CreateMono();
-			policy.AlignEmbeddedIfStatements = true;
+			policy.AlignEmbeddedStatements = true;
 			policy.ClassBraceStyle = BraceStyle.EndOfLine;
 			
 			var adapter = Test(policy, @"class Test {
@@ -992,7 +992,7 @@ if (b) {
 		}
 	}
 }");
-			policy.AlignEmbeddedIfStatements = false;
+			policy.AlignEmbeddedStatements = false;
 			Continue(policy, adapter, @"class Test {
 	Test TestMethod ()
 	{
@@ -1003,6 +1003,40 @@ if (b) {
 }");
 		}
 
+		[Test]
+		public void TestLockAlignment()
+		{
+			CSharpFormattingOptions policy = FormattingOptionsFactory.CreateMono();
+			policy.AlignEmbeddedStatements = true;
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+
+			var adapter = Test(policy, @"class Test {
+	Test TestMethod ()
+	{
+lock (a)
+lock (b) {
+}
+	}
+}",
+				@"class Test {
+	Test TestMethod ()
+	{
+		lock (a)
+		lock (b) {
+		}
+	}
+}");
+			policy.AlignEmbeddedStatements = false;
+			Continue(policy, adapter, @"class Test {
+	Test TestMethod ()
+	{
+		lock (a)
+			lock (b) {
+			}
+	}
+}");
+		}
+
 		[Test]
 		public void TestElseWithPreprocessorDirective()
 		{

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/IndentationTests/AlignmentTests.cs

@@ -130,7 +130,7 @@ class Foo
 		public void AlignEmbeddedIfStatements()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = true;
+			fmt.AlignEmbeddedStatements = true;
 			var indent = Helper.CreateEngine(@"
 class Foo
 {
@@ -147,7 +147,7 @@ class Foo
 		public void UnalignEmbeddedIfStatements()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo
 {
@@ -164,7 +164,7 @@ class Foo
 		public void AlignEmbeddedUsingStatements()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedUsingStatements = true;
+			fmt.AlignEmbeddedStatements = true;
 			var indent = Helper.CreateEngine(@"
 class Foo
 {
@@ -177,11 +177,27 @@ class Foo
 			Assert.AreEqual("\t\t\t", indent.NextLineIndent);
 		}
 
+		[Test]
+		public void AlignEmbeddedLockStatements()
+		{
+			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
+			fmt.AlignEmbeddedStatements = true;
+			var indent = Helper.CreateEngine(@"
+class Foo
+{
+	void Test (IDisposable a, IDisposable b)
+	{
+		lock (a)
+		lock (a)
+		lock (b) $", fmt);
+			Assert.AreEqual("\t\t", indent.ThisLineIndent);
+			Assert.AreEqual("\t\t\t", indent.NextLineIndent);
+		}
 		[Test]
 		public void UnalignEmbeddedUsingStatements()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedUsingStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo
 {

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/IndentationTests/BlockTest.cs

@@ -544,7 +544,7 @@ class Foo {
 		public void TestBrackets_StackedIfElse_AlignElseToCorrectIf()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			fmt.AlignElseInIfStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
@@ -562,7 +562,7 @@ class Foo {
 		public void TestBrackets_StackedIfElse_AlignElseToCorrectIf2()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			fmt.AlignElseInIfStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
@@ -584,7 +584,7 @@ class Foo {
 		public void TestBrackets_StackedIfElse_BreakNestedStatementsOnSemicolon()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -604,7 +604,7 @@ class Foo {
 		public void TestBrackets_StackedIfElse_ElseIf()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			fmt.AlignElseInIfStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
@@ -627,7 +627,7 @@ class Foo {
 		public void TestBrackets_StackedIfElse_BreakNestedStatementsOnIf()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = true;
+			fmt.AlignEmbeddedStatements = true;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -656,7 +656,7 @@ class Foo {
 		public void TestBrackets_StackedIfElse_BreakNestedStatementsOnAnyStatement()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = true;
+			fmt.AlignEmbeddedStatements = true;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -683,7 +683,7 @@ class Foo {
 		public void TestBrackets_StackedIfElse_BreakNestedStatementsOnAnonymousBlock()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -703,7 +703,7 @@ class Foo {
 		public void TestBrackets_StackedIfElseIf_IfInNewLine()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -722,7 +722,7 @@ class Foo {
 		public void TestBrackets_RemoveStatementContinuationWhenNoSemicolon()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -741,7 +741,7 @@ class Foo {
 		public void TestBrackets_CustomIndent()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -759,7 +759,7 @@ class Foo {
 		public void TestBrackets_CustomIndent2()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -776,7 +776,7 @@ class Foo {
 		public void TestBrackets_CustomIndent3()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -792,7 +792,7 @@ class Foo {
 		public void TestBrackets_CustomIndent4()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -810,7 +810,7 @@ class Foo {
 		public void TestBrackets_CustomIndent5()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()
@@ -826,7 +826,7 @@ if (true)
 		public void TestBrackets_CustomIndent6()
 		{
 			CSharpFormattingOptions fmt = FormattingOptionsFactory.CreateMono();
-			fmt.AlignEmbeddedIfStatements = false;
+			fmt.AlignEmbeddedStatements = false;
 			var indent = Helper.CreateEngine(@"
 class Foo {
 	void Test ()

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

@@ -50,5 +50,25 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			var compilation = CreateCompilation(unresolvedTypeDefinition);
 			return compilation.MainAssembly.GetTypeDefinition(unresolvedTypeDefinition.FullTypeName);
 		}
+		
+		public static ICompilation CreateCompilationWithoutCorlib(params IUnresolvedTypeDefinition[] unresolvedTypeDefinitions)
+		{
+			var unresolvedFile = new CSharpUnresolvedFile();
+			foreach (var typeDef in unresolvedTypeDefinitions)
+				unresolvedFile.TopLevelTypeDefinitions.Add(typeDef);
+			return CreateCompilation(unresolvedFile);
+		}
+		
+		public static ICompilation CreateCompilationWithoutCorlib(params IUnresolvedFile[] unresolvedFiles)
+		{
+			var pc = new CSharpProjectContent().AddOrUpdateFiles(unresolvedFiles);
+			return pc.CreateCompilation();
+		}
+		
+		public static ITypeDefinition CreateCompilationWithoutCorlibAndResolve(IUnresolvedTypeDefinition unresolvedTypeDefinition)
+		{
+			var compilation = CreateCompilationWithoutCorlib(unresolvedTypeDefinition);
+			return compilation.MainAssembly.GetTypeDefinition(unresolvedTypeDefinition.FullTypeName);
+		}
 	}
 }

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

@@ -162,8 +162,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public ISymbol Resolve(ITypeResolveContext context)
 		{
-			IParameterizedMember member = (IParameterizedMember)memberReference.Resolve(context);
+			IParameterizedMember member = memberReference.Resolve(context) as IParameterizedMember;
-			return member.Parameters[index];
+			if (member != null && index >= 0 && index < member.Parameters.Count)
+				return member.Parameters[index];
+			else
+				return null;
 		}
 	}
 	

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

@@ -424,6 +424,15 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			return compilation.Assemblies.SelectMany(a => a.GetAllTypeDefinitions());
 		}
+
+		/// <summary>
+		/// Gets all top level type definitions in the compilation.
+		/// This may include types from referenced assemblies that are not accessible in the main assembly.
+		/// </summary>
+		public static IEnumerable<ITypeDefinition> GetTopLevelTypeDefinitons (this ICompilation compilation)
+		{
+			return compilation.Assemblies.SelectMany(a => a.TopLevelTypeDefinitions);
+		}
 		
 		/// <summary>
 		/// Gets the type (potentially a nested type) defined at the specified location.