Merge branch 'master' into newresolver

Conflicts:
	main/contrib/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/AstNode.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/CSharpModifierToken.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/Expressions/IdentifierExpression.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/Expressions/MemberReferenceExpression.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/Expressions/PointerReferenceExpression.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/Expressions/QueryExpression.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/Constraint.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/DelegateDeclaration.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/ExternAliasDeclaration.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/NamespaceDeclaration.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/TypeDeclaration.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/TypeParameterDeclaration.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/UsingAliasDeclaration.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/Identifier.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/MemberType.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/SimpleType.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/Statements/ForeachStatement.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/Statements/GotoStatement.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/Statements/LabelStatement.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/Statements/TryCatchStatement.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EnumMemberDeclaration.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FixedVariableInitializer.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/MemberDeclaration.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/ParameterDeclaration.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/VariableInitializer.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Formatter/AstFormattingVisitor.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/TypeSystemConvertVisitor.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/anonymous.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/async.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/cs-parser.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/cs-tokenizer.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/ecore.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/expression.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/flowanalysis.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/method.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/report.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Refactoring/ContextAction/GenerateSwitchLabels.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Refactoring/ContextAction/InsertAnonymousMethodSignature.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Refactoring/ContextAction/RemoveBackingStore.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Refactoring/RefactoringContext.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/CSharpAttribute.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/ConstantValues.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/OverloadResolution.cs
	main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/TypeInference.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Analysis/MinimalResolveContext.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Ast/Expressions/NamedArgumentExpression.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Ast/Expressions/TypeReferenceExpression.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Formatter/ITextEditorAdapter.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/OutputVisitor/IOutputFormatter.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/OutputVisitor/TextWriterOutputFormatter.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Parser/ParsedFile.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-parser.jay
	main/contrib/ICSharpCode.NRefactory/CSharp/Refactoring/TypeSystemAstBuilder.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/AliasNamespaceReference.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/AmbiguousResolveResult.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/ByReferenceResolveResult.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/ConstantResolveResult.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/Conversions.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/ErrorResolveResult.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/IResolveVisitorNavigator.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/ITypeOrNamespaceReference.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/LocalResolveResult.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/MapTypeIntoNewContext.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/MemberLookup.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/MemberResolveResult.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/MemberTypeOrNamespaceReference.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/MethodGroupResolveResult.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/NamespaceResolveResult.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/NodeListResolveVisitorNavigator.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/ResolveResult.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/SimpleTypeOrNamespaceReference.cs
	main/contrib/ICSharpCode.NRefactory/CSharp/Resolver/TypeResolveResult.cs
	main/contrib/ICSharpCode.NRefactory/Documentation/IDStringProvider.cs
	main/contrib/ICSharpCode.NRefactory/Documentation/XmlDocumentationProvider.cs
	main/contrib/ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj
	main/contrib/ICSharpCode.NRefactory/Makefile.am
	main/contrib/ICSharpCode.NRefactory/PatternMatching/IPatternAstVisitor.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/ArrayType.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/ByReferenceType.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/DomRegion.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Error.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/ExtensionMethods.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/IAnnotatable.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/IParsedFile.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/IProjectContent.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/ITypeResolveContext.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractType.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/CompositeTypeResolveContext.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/CompoundTypeDefinition.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeDefinition.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeParameter.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/GetClassTypeReference.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/ProxyTypeResolveContext.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/SimpleProjectContent.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/TypeStorage.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/ParameterizedType.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/PointerType.cs
	main/contrib/ICSharpCode.NRefactory/TypeSystem/SharedTypes.cs
	main/contrib/ICSharpCode.NRefactory/Utils/DotNet35Compat.cs
	main/contrib/ICSharpCode.NRefactory/Utils/EmptyList.cs
	main/contrib/ICSharpCode.NRefactory/Utils/Platform.cs
	main/src/addins/CSharpBinding/CSharpBinding.csproj
	main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/CSharpTextEditorCompletion.cs
	main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/MemberCompletionData.cs
	main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/MethodParameterDataProvider.cs
	main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/NewOverrideCompletionData.cs
	main/src/addins/CSharpBinding/MonoDevelop.CSharp.ContextAction/MDRefactoringContext.cs
	main/src/addins/CSharpBinding/MonoDevelop.CSharp.Formatting/CSharpFormatter.cs
	main/src/addins/CSharpBinding/MonoDevelop.CSharp.Highlighting/CSharpSyntaxMode.cs
	main/src/addins/CSharpBinding/MonoDevelop.CSharp.Refactoring/CSharpCodeGenerator.cs
	main/src/addins/CSharpBinding/MonoDevelop.CSharp.Refactoring/CreateMethod/CreateMethodCodeGenerator.cs
	main/src/addins/CSharpBinding/MonoDevelop.CSharp.Resolver/NRefactoryResolver.cs
	main/src/addins/CSharpBinding/MonoDevelop.CSharp/CSharpAmbience.cs
	main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyBrowserWidget.cs
	main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/ColoredCSharpFormatter.cs
	main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/DomEventNodeBuilder.cs
	main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/DomFieldNodeBuilder.cs
	main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/DomMethodNodeBuilder.cs
	main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/DomPropertyNodeBuilder.cs
	main/src/addins/MonoDevelop.CodeMetrics/MonoDevelop.CodeMetrics.csproj
	main/src/addins/MonoDevelop.MacDev/ObjCIntegration/NSObjectInfoService.cs
	main/src/addins/MonoDevelop.MacDev/ObjCIntegration/NSObjectProjectInfo.cs
	main/src/addins/MonoDevelop.MacDev/ObjCIntegration/NSObjectTypeInfo.cs
	main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring/FindDerivedClassesHandler.cs
	main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring/FindReferencesHandler.cs
	main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring/GotoDeclarationHandler.cs
	main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring/RefactoryCommands.cs
	main/src/addins/MonoDevelop.SourceEditor2/MonoDevelop.SourceEditor/SourceEditorWidget.cs
	main/src/core/Mono.Texteditor/Mono.TextEditor/CodeSegmentPreviewWindow.cs
	main/src/core/Mono.Texteditor/Mono.TextEditor/Document.cs
	main/src/core/MonoDevelop.Core/MonoDevelop.Projects.Dom.Parser/ProjectDom.cs
	main/src/core/MonoDevelop.Core/MonoDevelop.Projects.Dom.Serialization/CodeCompletionDatabase.cs
	main/src/core/MonoDevelop.Core/MonoDevelop.Projects.Dom.Serialization/DatabaseProjectDom.cs
	main/src/core/MonoDevelop.Core/MonoDevelop.Projects.Dom.Serialization/ProjectCodeCompletionDatabase.cs
	main/src/core/MonoDevelop.Core/MonoDevelop.Projects.Dom/DomCecilType.cs
	main/src/core/MonoDevelop.Core/MonoDevelop.Projects.Dom/DomType.cs
	main/src/core/MonoDevelop.Core/MonoDevelop.Projects/HelpService.cs
	main/src/core/MonoDevelop.Ide/ExtensionModel/MonoDevelop.Ide.addin.xml
	main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Dialogs/AboutMonoDevelopTabPage.cs
	main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Dialogs/CommonAboutDialog.cs
	main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Dialogs/VersionInformationTabPage.cs
	main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.csproj
	main/src/core/MonoDevelop.Ide/MonoDevelop.Ide/Ide.cs
	main/src/core/MonoDevelop.Ide/MonoDevelop.TypeSystem/AmbienceService.cs
	main/src/core/MonoDevelop.Ide/MonoDevelop.TypeSystem/CodeGenerator.cs
	main/src/core/MonoDevelop.Ide/MonoDevelop.TypeSystem/OutputFlags.cs
	main/src/core/MonoDevelop.Ide/MonoDevelop.TypeSystem/OutputSettings.cs
	main/src/core/MonoDevelop.Ide/MonoDevelop.TypeSystem/ParsedDocument.cs
	main/tests/UnitTests/MonoDevelop.CSharpBinding/TopLevelTests.cs

8 files changed, 571 insertions, 268 deletions

diff --git a/main/tests/UnitTests/Mono.TextEditor.Tests/FoldingTests.cs b/main/tests/UnitTests/Mono.TextEditor.Tests/FoldingTests.cs
index c2623c096e..220e22db3d 100644
--- a/main/tests/UnitTests/Mono.TextEditor.Tests/FoldingTests.cs
+++ b/main/tests/UnitTests/Mono.TextEditor.Tests/FoldingTests.cs
@@ -537,5 +537,36 @@ AAAAAAAA$
 			Assert.AreEqual (true, data.Document.FoldSegments.First ().IsFolded);
 			Assert.AreEqual (new DocumentLocation (3, 3), data.Caret.Location);
 		}
+		
+		/// <summary>
+		/// Bug 1134 - Visually corrupted text when changing line
+		/// </summary>
+		[Test()]
+		public void TestBug1134 ()
+		{
+			var data = CaretMoveActionTests.Create (
+@"0
+1
+-[2
+3
+4]
+5
+-[6
+7
++[8
+9]
+10]
+11");
+			var segments = GetFoldSegments (data.Document);
+			var seg = segments[0];
+			segments.RemoveAt (0);
+			data.Document.UpdateFoldSegments (segments, false);
+			Assert.AreEqual (2, data.Document.FoldSegments.Count ());
+			
+			segments.Insert (0, seg);
+			data.Document.UpdateFoldSegments (segments, false);
+			Assert.AreEqual (3, data.Document.FoldSegments.Count ());
+			
+		}	
 	}
 }
diff --git a/main/tests/UnitTests/Mono.TextEditor.Tests/SyntaxHighlightingTests.cs b/main/tests/UnitTests/Mono.TextEditor.Tests/SyntaxHighlightingTests.cs
index a109fb0522..dc03de3f48 100644
--- a/main/tests/UnitTests/Mono.TextEditor.Tests/SyntaxHighlightingTests.cs
+++ b/main/tests/UnitTests/Mono.TextEditor.Tests/SyntaxHighlightingTests.cs
@@ -107,5 +107,15 @@ namespace Mono.TextEditor.Tests
 			            "application/xml");
 		}
 		
+		
+		///<summary>
+		/// Bug 603 - Last token in doc comment has wrong color 
+		///</summary>
+		[Test]
+		public void TestBug603 ()
+		{
+			TestOutput ("///<summary>foo bar</summary>",
+		                "<span foreground=\"#4D9A06\">///&lt;summary&gt;foo bar&lt;/summary&gt;</span>");
+		}
 	}
 }
diff --git a/main/tests/UnitTests/MonoDevelop.CSharpBinding/TopLevelTests.cs b/main/tests/UnitTests/MonoDevelop.CSharpBinding/TopLevelTests.cs
index 5b6986412a..2106d83472 100644
--- a/main/tests/UnitTests/MonoDevelop.CSharpBinding/TopLevelTests.cs
+++ b/main/tests/UnitTests/MonoDevelop.CSharpBinding/TopLevelTests.cs
@@ -1,254 +1,443 @@
-////
-//// ParserTest.cs
-////
-//// Author:
-////   Mike Krüger <mkrueger@novell.com>
-////
-//// Copyright (C) 2008 Novell, Inc (http://www.novell.com)
-////
-//// Permission is hereby granted, free of charge, to any person obtaining
-//// a copy of this software and associated documentation files (the
-//// "Software"), to deal in the Software without restriction, including
-//// without limitation the rights to use, copy, modify, merge, publish,
-//// distribute, sublicense, and/or sell copies of the Software, and to
-//// permit persons to whom the Software is furnished to do so, subject to
-//// the following conditions:
-//// 
-//// The above copyright notice and this permission notice shall be
-//// included in all copies or substantial portions of the Software.
-//// 
-//// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-//// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-//// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-//// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-//// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 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.
-////
+/*
+// Copyright (C) 2008 Novell, Inc (http://www.novell.com)
 //
-//using System;
-//using System.CodeDom;
-//using System.Collections.Generic;
-//using NUnit.Framework;
-//using MonoDevelop.CSharpBinding;
-//using MonoDevelop.CSharp.Parser;
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 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.
 //
-//namespace MonoDevelop.CSharpBinding.Tests
-//{
-//	[TestFixture]
-//	public class TopLevelTests
-//	{
-//		void DoTestUsings (IParser parser)
-//		{
-//			ICompilationUnit unit = parser.Parse (null, "a.cs", 
-//@"using System;
-//using NUnit.Framework;").CompilationUnit;
-//			foreach (IUsing u in unit.Usings) {
-//				foreach (string ns in u.Namespaces) {
-//					if (ns == "System") {
-//						Assert.AreEqual (1, u.Region.End.Line);
-//						Assert.AreEqual (1, u.Region.Start.Line);
-//					} else if (ns == "NUnit.Framework") {
-//						Assert.AreEqual (2, u.Region.End.Line);
-//						Assert.AreEqual (2, u.Region.Start.Line);
-//					} else {
-//						Assert.Fail ("Unknown using: " + ns);
-//					}
-//				}
-//			}
-//		}
-//		
-//		[Test]
-//		public void TestUsings ()
-//		{
-//			DoTestUsings (new McsParser ());
-//			//DoTestUsings (new DomParser ());
-//		}
-//		
-//		void DoTestEnums (IParser parser)
-//		{
-//			ICompilationUnit unit = parser.Parse (null, "a.cs", 
-//@"enum TestEnum {
-//	A,
-//	B,
-//	C
-//}").CompilationUnit;
-//			Assert.AreEqual (1, unit.Types.Count);
-//			IType type = unit.Types[0];
-//			Assert.AreEqual (ClassType.Enum, type.ClassType);
-//			Assert.AreEqual ("TestEnum", type.Name);
-//			Assert.AreEqual (3, type.FieldCount);
-//			foreach (IField f in type.Fields) {
-//				Assert.IsTrue (f.IsConst);
-//				Assert.IsTrue (f.IsSpecialName);
-//				Assert.IsTrue (f.IsPublic);
-//				if (f.Name == "A") {
-//					Assert.AreEqual (2, f.Location.Line);
-//				} else if (f.Name == "B") {
-//					Assert.AreEqual (3, f.Location.Line);
-//				} else if (f.Name == "C") {
-//					Assert.AreEqual (4, f.Location.Line);
-//				} else {
-//					Assert.Fail ("Unknown field: " + f.Name);
-//				}
-//			}
-//		}
-//		
-//		[Test]
-//		public void TestEnums ()
-//		{
-//			DoTestEnums (new McsParser ());
-////			DoTestEnums (new DomParser ());
-//		}
-//		
-//		void DoTestStruct (IParser parser)
-//		{
-//			ICompilationUnit unit = parser.Parse (null, "a.cs", @"struct TestStruct { }").CompilationUnit;
-//			Assert.AreEqual (1, unit.Types.Count);
-//			IType type = unit.Types[0];
-//			Assert.AreEqual (ClassType.Struct, type.ClassType);
-//			Assert.AreEqual ("TestStruct", type.Name);
-//		}
-//		
-//		[Test]
-//		public void TestStruct ()
-//		{
-//			DoTestStruct (new McsParser ());
-////			DoTestStruct (new DomParser ());
-//		}
-//		
-//		void DoTestInterface (IParser parser)
-//		{
-//			ICompilationUnit unit = parser.Parse (null, "a.cs", @"interface TestInterface { }").CompilationUnit;
-//			Assert.AreEqual (1, unit.Types.Count);
-//			IType type = unit.Types[0];
-//			Assert.AreEqual (ClassType.Interface, type.ClassType);
-//			Assert.AreEqual ("TestInterface", type.Name);
-//		}
-//		
-//		[Test]
-//		public void TestInterface ()
-//		{
-//			DoTestInterface (new McsParser ());
-////			DoTestInterface (new DomParser ());
-//		}
-//		
-//		void DoTestDelegate (IParser parser)
-//		{
-//			ICompilationUnit unit = parser.Parse (null, "a.cs", @"delegate void TestDelegate (int a, string b);").CompilationUnit;
-//			Assert.AreEqual (1, unit.Types.Count);
-//			IType type = unit.Types[0];
-//			Assert.AreEqual (ClassType.Delegate, type.ClassType);
-//			Assert.AreEqual ("TestDelegate", type.Name);
-//			foreach (IMethod method in type.Methods) {
-//				Assert.AreEqual (DomReturnType.Void.FullName, method.ReturnType.FullName);
-//				foreach (IParameter parameter in method.Parameters) {
-//					if (parameter.Name == "a") {
-//						Assert.AreEqual (DomReturnType.Int32.FullName, parameter.ReturnType.FullName);
-//					} else if (parameter.Name == "b") {
-//						Assert.AreEqual (DomReturnType.String.FullName, parameter.ReturnType.FullName);
-//					} else {
-//						Assert.Fail ("Unknown parameter: " + parameter.Name);
-//					}
-//				}
-//			}
-//		}
-//		
-//		[Test]
-//		public void TestDelegate ()
-//		{
-//			DoTestDelegate (new McsParser ());
-////			DoTestDelegate (new DomParser ());
-//		}
-//		
-//		void DoTestClass (IParser parser)
-//		{
-//			ICompilationUnit unit = parser.Parse (null, "a.cs", @"public partial class TestClass<T, S> : MyBaseClass where T : Constraint { }").CompilationUnit;
-//			Assert.AreEqual (1, unit.Types.Count);
-//			IType type = unit.Types[0];
-//			Assert.AreEqual (ClassType.Class, type.ClassType);
-//			Assert.AreEqual ("TestClass", type.Name);
-//			Assert.AreEqual ("MyBaseClass", type.BaseType.Name);
-//			Assert.AreEqual (Modifiers.Partial | Modifiers.Public, type.Modifiers);
-//			Assert.AreEqual (2, type.TypeParameters.Count);
-//			Assert.AreEqual ("T", type.TypeParameters[0].Name);
-//			Assert.AreEqual ("Constraint", type.TypeParameters[0].Constraints[0].Name);
-//			Assert.AreEqual ("S", type.TypeParameters[1].Name);
-//		}
-//		
-//		[Test]
-//		public void TestClass ()
-//		{
-//			DoTestClass (new McsParser ());
-////			DoTestClass (new DomParser ());
-//		}
-//		
-//		void DoTestNamespace (IParser parser)
-//		{
-//			ICompilationUnit unit = parser.Parse (null, "a.cs", @"namespace Test1.Test2.Test3 { class A { } }").CompilationUnit;
-//			Assert.AreEqual (3, unit.Usings.Count);
-//			Assert.AreEqual ("Test1.Test2.Test3", unit.Usings[0].Namespaces[0]);
-//			Assert.AreEqual ("Test1.Test2", unit.Usings[1].Namespaces[0]);
-//			Assert.AreEqual ("Test1", unit.Usings[2].Namespaces[0]);
-//			Assert.AreEqual (1, unit.Types.Count);
-//			IType type = unit.Types[0];
-//			Assert.AreEqual ("Test1.Test2.Test3", type.Namespace);
-//		}
-//		
-//		[Test]
-//		public void TestNamespace ()
-//		{
-//			DoTestNamespace (new McsParser ());
-////			DoTestNamespace (new DomParser ());
-//		}
-//		
-//		void DoTestAttributes (IParser parser)
-//		{
-//			ICompilationUnit unit = parser.Parse (null, "a.cs", @"[Attr1][Attr2(1,true)][Attr3('c',a=1,b=""hi"")] public class TestClass { }").CompilationUnit;
-//			Assert.AreEqual (1, unit.Types.Count);
-//			IType type = unit.Types[0];
-//			Assert.AreEqual (ClassType.Class, type.ClassType);
-//			Assert.AreEqual ("TestClass", type.Name);
-//			IEnumerator<IAttribute> e = type.Attributes.GetEnumerator ();
-//			
-//			Assert.IsTrue (e.MoveNext ());
-//			IAttribute att = e.Current;
-//			Assert.AreEqual ("Attr1", att.Name);
-//			Assert.AreEqual (0, att.PositionalArguments.Count);
-//			Assert.AreEqual (0, att.NamedArguments.Count);
-//			
-//			Assert.IsTrue (e.MoveNext ());
-//			att = e.Current;
-//			Assert.AreEqual ("Attr2", att.Name);
-//			Assert.AreEqual (2, att.PositionalArguments.Count);
-//			Assert.AreEqual (0, att.NamedArguments.Count);
-//			Assert.IsTrue (att.PositionalArguments [0] is CodePrimitiveExpression);
-//			CodePrimitiveExpression exp = (CodePrimitiveExpression) att.PositionalArguments [0];
-//			Assert.AreEqual (1, exp.Value);
-//			exp = (CodePrimitiveExpression) att.PositionalArguments [1];
-//			Assert.AreEqual (true, exp.Value);
-//			
-//			Assert.IsTrue (e.MoveNext ());
-//			att = e.Current;
-//			Assert.AreEqual ("Attr3", att.Name);
-//			Assert.AreEqual (1, att.PositionalArguments.Count);
-//			Assert.AreEqual (2, att.NamedArguments.Count);
-//			Assert.IsTrue (att.PositionalArguments [0] is CodePrimitiveExpression);
-//			exp = (CodePrimitiveExpression) att.PositionalArguments [0];
-//			Assert.AreEqual ('c', exp.Value);
-//			exp = (CodePrimitiveExpression) att.NamedArguments ["a"];
-//			Assert.AreEqual (1, exp.Value);
-//			exp = (CodePrimitiveExpression) att.NamedArguments ["b"];
-//			Assert.AreEqual ("hi", exp.Value);
-//			
-//			Assert.IsFalse (e.MoveNext ());
-//		}
-//		
-//		[Test()]
-//		public void TestAttributes ()
-//		{
-//			DoTestAttributes (new McsParser ());
-////			DoTestAttributes (new DomParser ());
-//		}
-//	}
-//}
+
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using NUnit.Framework;
+
+using MonoDevelop.Projects.Dom;
+
+using MonoDevelop.Projects.Dom.Parser;
+using MonoDevelop.CSharpBinding;
+
+using MonoDevelop.CSharp.Parser;
+
+
+namespace MonoDevelop.CSharpBinding.Tests
+{
+	[TestFixture]
+	public class TopLevelTests : UnitTests.TestBase
+	{
+
+		void DoTestUsings (IParser parser)
+
+		{
+
+			ICompilationUnit unit = parser.Parse (null, "a.cs", 
+
+@"using System;
+
+using NUnit.Framework;").CompilationUnit;
+
+			foreach (IUsing u in unit.Usings) {
+
+				foreach (string ns in u.Namespaces) {
+
+					if (ns == "System") {
+
+						Assert.AreEqual (1, u.Region.End.Line);
+
+						Assert.AreEqual (1, u.Region.Start.Line);
+
+					} else if (ns == "NUnit.Framework") {
+
+						Assert.AreEqual (2, u.Region.End.Line);
+
+						Assert.AreEqual (2, u.Region.Start.Line);
+
+					} else {
+
+						Assert.Fail ("Unknown using: " + ns);
+
+					}
+
+				}
+
+			}
+
+		}
+
+		
+		[Test]
+		public void TestUsings ()
+		{
+
+			DoTestUsings (new McsParser ());
+
+			//DoTestUsings (new DomParser ());
+		}
+
+		
+
+		void DoTestEnums (IParser parser)
+
+		{
+
+			ICompilationUnit unit = parser.Parse (null, "a.cs", 
+
+@"enum TestEnum {
+
+	A,
+
+	B,
+
+	C
+
+}").CompilationUnit;
+
+			Assert.AreEqual (1, unit.Types.Count);
+
+			IType type = unit.Types[0];
+
+			Assert.AreEqual (ClassType.Enum, type.ClassType);
+
+			Assert.AreEqual ("TestEnum", type.Name);
+
+			Assert.AreEqual (3, type.FieldCount);
+
+			foreach (IField f in type.Fields) {
+
+				Assert.IsTrue (f.IsConst);
+
+				Assert.IsTrue (f.IsSpecialName);
+
+				Assert.IsTrue (f.IsPublic);
+
+				if (f.Name == "A") {
+
+					Assert.AreEqual (2, f.Location.Line);
+
+				} else if (f.Name == "B") {
+
+					Assert.AreEqual (3, f.Location.Line);
+
+				} else if (f.Name == "C") {
+
+					Assert.AreEqual (4, f.Location.Line);
+
+				} else {
+
+					Assert.Fail ("Unknown field: " + f.Name);
+
+				}
+
+			}
+
+		}
+
+		
+
+		[Test]
+		public void TestEnums ()
+		{
+
+			DoTestEnums (new McsParser ());
+
+//			DoTestEnums (new DomParser ());
+		}
+
+		
+
+		void DoTestStruct (IParser parser)
+
+		{
+
+			ICompilationUnit unit = parser.Parse (null, "a.cs", @"struct TestStruct { }").CompilationUnit;
+
+			Assert.AreEqual (1, unit.Types.Count);
+
+			IType type = unit.Types[0];
+
+			Assert.AreEqual (ClassType.Struct, type.ClassType);
+
+			Assert.AreEqual ("TestStruct", type.Name);
+
+		}
+
+		
+
+		[Test]
+		public void TestStruct ()
+		{
+
+			DoTestStruct (new McsParser ());
+
+//			DoTestStruct (new DomParser ());
+		}
+
+		
+
+		void DoTestInterface (IParser parser)
+
+		{
+
+			ICompilationUnit unit = parser.Parse (null, "a.cs", @"interface TestInterface { }").CompilationUnit;
+
+			Assert.AreEqual (1, unit.Types.Count);
+
+			IType type = unit.Types[0];
+
+			Assert.AreEqual (ClassType.Interface, type.ClassType);
+
+			Assert.AreEqual ("TestInterface", type.Name);
+
+		}
+
+		
+
+		[Test]
+		public void TestInterface ()
+		{
+
+			DoTestInterface (new McsParser ());
+
+//			DoTestInterface (new DomParser ());
+		}
+
+		
+
+		void DoTestDelegate (IParser parser)
+
+		{
+
+			ICompilationUnit unit = parser.Parse (null, "a.cs", @"delegate void TestDelegate (int a, string b);").CompilationUnit;
+
+			Assert.AreEqual (1, unit.Types.Count);
+
+			IType type = unit.Types[0];
+
+			Assert.AreEqual (ClassType.Delegate, type.ClassType);
+
+			Assert.AreEqual ("TestDelegate", type.Name);
+
+			foreach (IMethod method in type.Methods) {
+
+				Assert.AreEqual (DomReturnType.Void.FullName, method.ReturnType.FullName);
+
+				foreach (IParameter parameter in method.Parameters) {
+
+					if (parameter.Name == "a") {
+
+						Assert.AreEqual (DomReturnType.Int32.FullName, parameter.ReturnType.FullName);
+
+					} else if (parameter.Name == "b") {
+
+						Assert.AreEqual (DomReturnType.String.FullName, parameter.ReturnType.FullName);
+
+					} else {
+
+						Assert.Fail ("Unknown parameter: " + parameter.Name);
+
+					}
+
+				}
+
+			}
+
+		}
+
+		
+
+		[Test]
+		public void TestDelegate ()
+		{
+
+			DoTestDelegate (new McsParser ());
+
+//			DoTestDelegate (new DomParser ());
+		}
+
+		
+
+		void DoTestClass (IParser parser)
+
+		{
+
+			ICompilationUnit unit = parser.Parse (null, "a.cs", @"public partial class TestClass<T, S> : MyBaseClass where T : Constraint { }").CompilationUnit;
+
+			Assert.AreEqual (1, unit.Types.Count);
+
+			IType type = unit.Types[0];
+
+			Assert.AreEqual (ClassType.Class, type.ClassType);
+
+			Assert.AreEqual ("TestClass", type.Name);
+
+			Assert.AreEqual ("MyBaseClass", type.BaseType.Name);
+
+			Assert.AreEqual (Modifiers.Partial | Modifiers.Public, type.Modifiers);
+
+			Assert.AreEqual (2, type.TypeParameters.Count);
+
+			Assert.AreEqual ("T", type.TypeParameters[0].Name);
+
+			Assert.AreEqual ("Constraint", type.TypeParameters[0].Constraints[0].Name);
+
+			Assert.AreEqual ("S", type.TypeParameters[1].Name);
+
+		}
+
+		
+
+		[Test]
+		public void TestClass ()
+		{
+
+			DoTestClass (new McsParser ());
+
+//			DoTestClass (new DomParser ());
+		}
+
+		
+
+		void DoTestNamespace (IParser parser)
+
+		{
+
+			ICompilationUnit unit = parser.Parse (null, "a.cs", @"namespace Test1.Test2.Test3 { class A { } }").CompilationUnit;
+
+			Assert.AreEqual (3, unit.Usings.Count);
+
+			Assert.AreEqual ("Test1.Test2.Test3", unit.Usings[0].Namespaces[0]);
+
+			Assert.AreEqual ("Test1.Test2", unit.Usings[1].Namespaces[0]);
+
+			Assert.AreEqual ("Test1", unit.Usings[2].Namespaces[0]);
+
+			Assert.AreEqual (1, unit.Types.Count);
+
+			IType type = unit.Types[0];
+
+			Assert.AreEqual ("Test1.Test2.Test3", type.Namespace);
+
+		}
+
+		
+
+		[Test]
+		public void TestNamespace ()
+		{
+
+			DoTestNamespace (new McsParser ());
+
+//			DoTestNamespace (new DomParser ());
+		}
+		
+
+		void DoTestAttributes (IParser parser)
+
+		{
+
+			ICompilationUnit unit = parser.Parse (null, "a.cs", @"[Attr1][Attr2(1,true)][Attr3('c',a=1,b=""hi"")] public class TestClass { }").CompilationUnit;
+
+			Assert.AreEqual (1, unit.Types.Count);
+
+			IType type = unit.Types[0];
+
+			Assert.AreEqual (ClassType.Class, type.ClassType);
+
+			Assert.AreEqual ("TestClass", type.Name);
+
+			IEnumerator<IAttribute> e = type.Attributes.GetEnumerator ();
+
+			
+
+			Assert.IsTrue (e.MoveNext ());
+
+			IAttribute att = e.Current;
+
+			Assert.AreEqual ("Attr1", att.Name);
+
+			Assert.AreEqual (0, att.PositionalArguments.Count);
+
+			Assert.AreEqual (0, att.NamedArguments.Count);
+
+			
+
+			Assert.IsTrue (e.MoveNext ());
+
+			att = e.Current;
+
+			Assert.AreEqual ("Attr2", att.Name);
+
+			Assert.AreEqual (2, att.PositionalArguments.Count);
+
+			Assert.AreEqual (0, att.NamedArguments.Count);
+
+			Assert.IsTrue (att.PositionalArguments [0] is CodePrimitiveExpression);
+
+			CodePrimitiveExpression exp = (CodePrimitiveExpression) att.PositionalArguments [0];
+
+			Assert.AreEqual (1, exp.Value);
+
+			exp = (CodePrimitiveExpression) att.PositionalArguments [1];
+
+			Assert.AreEqual (true, exp.Value);
+
+			
+
+			Assert.IsTrue (e.MoveNext ());
+
+			att = e.Current;
+
+			Assert.AreEqual ("Attr3", att.Name);
+
+			Assert.AreEqual (1, att.PositionalArguments.Count);
+
+			Assert.AreEqual (2, att.NamedArguments.Count);
+
+			Assert.IsTrue (att.PositionalArguments [0] is CodePrimitiveExpression);
+
+			exp = (CodePrimitiveExpression) att.PositionalArguments [0];
+
+			Assert.AreEqual ('c', exp.Value);
+
+			exp = (CodePrimitiveExpression) att.NamedArguments ["a"];
+
+			Assert.AreEqual (1, exp.Value);
+
+			exp = (CodePrimitiveExpression) att.NamedArguments ["b"];
+
+			Assert.AreEqual ("hi", exp.Value);
+
+			
+
+			Assert.IsFalse (e.MoveNext ());
+
+		}
+
+		
+
+		[Test()]
+		public void TestAttributes ()
+		{
+
+			DoTestAttributes (new McsParser ());
+
+//			DoTestAttributes (new DomParser ());
+		}
+
+	}
+}
+*/
\ No newline at end of file
diff --git a/main/tests/UnitTests/MonoDevelop.Projects/MakefileTests.cs b/main/tests/UnitTests/MonoDevelop.Projects/MakefileTests.cs
index c6a94f4f9b..b94c8dcd73 100644
--- a/main/tests/UnitTests/MonoDevelop.Projects/MakefileTests.cs
+++ b/main/tests/UnitTests/MonoDevelop.Projects/MakefileTests.cs
@@ -70,7 +70,7 @@ namespace MonoDevelop.Projects
 			// Test saving
 			
 			p.References.Remove (xmlRef);
-			p.References.Add (new ProjectReference (ReferenceType.Gac, "System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"));
+			p.References.Add (new ProjectReference (ReferenceType.Package, "System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"));
 			
 			p.Files.Remove (f);
 			p.Files.Add (new ProjectFile (Path.Combine (p.BaseDirectory, "Class1.cs"), BuildAction.Compile));
diff --git a/main/tests/UnitTests/MonoDevelop.Projects/SolutionTests.cs b/main/tests/UnitTests/MonoDevelop.Projects/SolutionTests.cs
index 483096ae69..b872d791cb 100644
--- a/main/tests/UnitTests/MonoDevelop.Projects/SolutionTests.cs
+++ b/main/tests/UnitTests/MonoDevelop.Projects/SolutionTests.cs
@@ -120,7 +120,7 @@ namespace MonoDevelop.Projects
 			project.Files.Remove ("test2.cs");
 			Assert.AreEqual (2, countFileRemovedFromProject);
 			
-			ProjectReference pr1 = new ProjectReference (ReferenceType.Gac, "SomeTest");
+			ProjectReference pr1 = new ProjectReference (ReferenceType.Package, "SomeTest");
 			project.References.Add (pr1);
 			Assert.AreEqual (1, countReferenceAddedToProject);
 			
diff --git a/main/tests/UnitTests/MonoDevelop.Projects/TestProjectsChecks.cs b/main/tests/UnitTests/MonoDevelop.Projects/TestProjectsChecks.cs
index ca057e5d58..73e4de164b 100644
--- a/main/tests/UnitTests/MonoDevelop.Projects/TestProjectsChecks.cs
+++ b/main/tests/UnitTests/MonoDevelop.Projects/TestProjectsChecks.cs
@@ -63,7 +63,7 @@ namespace MonoDevelop.Projects
 			
 			Assert.AreEqual (1, project.References.Count);
 			ProjectReference pr = project.References [0];
-			Assert.AreEqual (ReferenceType.Gac, pr.ReferenceType);
+			Assert.AreEqual (ReferenceType.Package, pr.ReferenceType);
 			Assert.AreEqual ("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", pr.Reference);
 			
 			// Configurations
@@ -109,15 +109,15 @@ namespace MonoDevelop.Projects
 			Assert.AreEqual (3, project.References.Count);
 			
 			ProjectReference pr = project.References [0];
-			Assert.AreEqual (ReferenceType.Gac, pr.ReferenceType);
+			Assert.AreEqual (ReferenceType.Package, pr.ReferenceType);
 			Assert.AreEqual ("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", pr.Reference);
 			
 			pr = project.References [1];
-			Assert.AreEqual (ReferenceType.Gac, pr.ReferenceType);
+			Assert.AreEqual (ReferenceType.Package, pr.ReferenceType);
 			Assert.AreEqual ("System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", pr.Reference);
 			
 			pr = project.References [2];
-			Assert.AreEqual (ReferenceType.Gac, pr.ReferenceType);
+			Assert.AreEqual (ReferenceType.Package, pr.ReferenceType);
 			Assert.AreEqual ("System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", pr.Reference);
 			
 			// Configurations
@@ -151,9 +151,9 @@ namespace MonoDevelop.Projects
 			Assert.AreEqual (0, project.Configurations.Count);
 			
 			InitializeProject (dir, project, "TestProject");
-			project.References.Add (new ProjectReference (ReferenceType.Gac, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
-			project.References.Add (new ProjectReference (ReferenceType.Gac, "System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
-			project.References.Add (new ProjectReference (ReferenceType.Gac, "System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
+			project.References.Add (new ProjectReference (ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
+			project.References.Add (new ProjectReference (ReferenceType.Package, "System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
+			project.References.Add (new ProjectReference (ReferenceType.Package, "System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
 			project.Files.Add (new ProjectFile (Path.Combine (dir, "Main.cs")));
 			project.Files.Add (new ProjectFile (Path.Combine (dir, "Resource.xml"), BuildAction.EmbeddedResource));
 			project.Files.Add (new ProjectFile (Path.Combine (dir, "Excluded.xml"), BuildAction.Content));
@@ -256,14 +256,14 @@ namespace MonoDevelop.Projects
 			folder1.Name = "nested-solution1";
 			
 			DotNetProject projectLib1 = CreateProject (Util.Combine (dir, "nested-solution1", "library1"), "C#", "library1");
-			projectLib1.References.Add (new ProjectReference (ReferenceType.Gac, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
+			projectLib1.References.Add (new ProjectReference (ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
 			projectLib1.Files.Add (new ProjectFile (Path.Combine (projectLib1.BaseDirectory, "MyClass.cs")));
 			projectLib1.Files.Add (new ProjectFile (Path.Combine (projectLib1.BaseDirectory, "AssemblyInfo.cs")));
 			projectLib1.CompileTarget = CompileTarget.Library;
 			folder1.Items.Add (projectLib1);
 			
 			DotNetProject projectLib2 = CreateProject (Util.Combine (dir, "nested-solution1", "library2"), "C#", "library2");
-			projectLib2.References.Add (new ProjectReference (ReferenceType.Gac, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
+			projectLib2.References.Add (new ProjectReference (ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
 			projectLib2.Files.Add (new ProjectFile (Path.Combine (projectLib2.BaseDirectory, "MyClass.cs")));
 			projectLib2.Files.Add (new ProjectFile (Path.Combine (projectLib2.BaseDirectory, "AssemblyInfo.cs")));
 			projectLib2.CompileTarget = CompileTarget.Library;
@@ -278,7 +278,7 @@ namespace MonoDevelop.Projects
 			DotNetProject project2 = CreateProject (Util.Combine (dir, "nested-solution2", "console-project2"), "C#", "console-project2");
 			project2.Files.Add (new ProjectFile (Path.Combine (project2.BaseDirectory, "Main.cs")));
 			project2.Files.Add (new ProjectFile (Path.Combine (project2.BaseDirectory, "AssemblyInfo.cs")));
-			project2.References.Add (new ProjectReference (ReferenceType.Gac, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
+			project2.References.Add (new ProjectReference (ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
 			
 			// nested-solution3
 
@@ -286,14 +286,14 @@ namespace MonoDevelop.Projects
 			folder3.Name = "nested-solution3";
 			
 			DotNetProject projectLib3 = CreateProject (Util.Combine (dir, "nested-solution2", "nested-solution3", "library3"), "C#", "library3");
-			projectLib3.References.Add (new ProjectReference (ReferenceType.Gac, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
+			projectLib3.References.Add (new ProjectReference (ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
 			projectLib3.Files.Add (new ProjectFile (Path.Combine (projectLib3.BaseDirectory, "MyClass.cs")));
 			projectLib3.Files.Add (new ProjectFile (Path.Combine (projectLib3.BaseDirectory, "AssemblyInfo.cs")));
 			projectLib3.CompileTarget = CompileTarget.Library;
 			folder3.Items.Add (projectLib3);
 			
 			DotNetProject projectLib4 = CreateProject (Util.Combine (dir, "nested-solution2", "nested-solution3", "library4"), "C#", "library4");
-			projectLib4.References.Add (new ProjectReference (ReferenceType.Gac, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
+			projectLib4.References.Add (new ProjectReference (ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
 			projectLib4.Files.Add (new ProjectFile (Path.Combine (projectLib4.BaseDirectory, "MyClass.cs")));
 			projectLib4.Files.Add (new ProjectFile (Path.Combine (projectLib4.BaseDirectory, "AssemblyInfo.cs")));
 			projectLib4.CompileTarget = CompileTarget.Library;
@@ -305,7 +305,7 @@ namespace MonoDevelop.Projects
 			string file = Path.Combine (dir, "TestSolution.sln");
 			sol.FileName = file;
 			
-			project1.References.Add (new ProjectReference (ReferenceType.Gac, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
+			project1.References.Add (new ProjectReference (ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
 			project1.References.Add (new ProjectReference (projectLib1));
 			project1.References.Add (new ProjectReference (projectLib2));
 			project1.References.Add (new ProjectReference (projectLib3));
diff --git a/main/tests/UnitTests/MonoDevelop.Refactoring/CreateMethodTests.cs b/main/tests/UnitTests/MonoDevelop.Refactoring/CreateMethodTests.cs
index 4ec0d0ede4..8ac89e9ade 100644
--- a/main/tests/UnitTests/MonoDevelop.Refactoring/CreateMethodTests.cs
+++ b/main/tests/UnitTests/MonoDevelop.Refactoring/CreateMethodTests.cs
@@ -188,7 +188,7 @@ namespace MonoDevelop.Refactoring.Tests
 	throw new System.NotImplementedException ();

 }");
 		}
-		
+
 		[Test()]
 		public void TestCreateDelegateDeclaration ()
 		{
@@ -439,7 +439,60 @@ namespace Test {
 ", true);
 		}
 		
+		/// <summary>
+		/// Bug 469 - CreateMethod created a method incorrectly
+		/// </summary>
+		[Test()]
+		public void TestBug469 ()
+		{
+			TestCreateMethod (
+@"class Test
+{
+	public override string ToString ()
+	{
+		$BeginDownloadingImage (this);
+	}
+}
+", @"class Test
+{
+	public void BeginDownloadingImage (Test par1)
+	{
+		throw new System.NotImplementedException ();
+	}
+	
+	public override string ToString ()
+	{
+		BeginDownloadingImage (this);
+	}
+}
+", true);
+		}
+		
+		[Test()]
+		public void TestTestGuessReturnReturnType ()
+		{
+			TestCreateMethod (
+@"class Test
+{
+	public override string ToString ()
+	{
+		return $BeginDownloadingImage (this);
+	}
+}
+", @"class Test
+{
+	public string BeginDownloadingImage (Test par1)
+	{
+		throw new System.NotImplementedException ();
 	}
 	
+	public override string ToString ()
+	{
+		return BeginDownloadingImage (this);
+	}
+}
+", true);
+		}
+	}
 }
 
diff --git a/main/tests/UnitTests/MonoDevelop.Refactoring/ImplementInterfaceTests.cs b/main/tests/UnitTests/MonoDevelop.Refactoring/ImplementInterfaceTests.cs
index 96a3b0eeb6..2a3f0bd574 100644
--- a/main/tests/UnitTests/MonoDevelop.Refactoring/ImplementInterfaceTests.cs
+++ b/main/tests/UnitTests/MonoDevelop.Refactoring/ImplementInterfaceTests.cs
@@ -115,6 +115,26 @@ namespace MonoDevelop.Refactoring
 		throw new System.NotImplementedException ();
 	}");
 		}
+		
+		/// <summary>
+		/// Bug 243 - Implement implicit interface doesn't handle overloads correctly. 
+		/// </summary>
+		[Test()]
+		public void TestBug243 ()
+		{
+			TestCreateInterface (@"interface ITest {
+	void Inc (int n);
+	void Inc (string message);
+}", @"public void Inc (int n)
+	{
+		throw new System.NotImplementedException ();
+	}
+
+	public void Inc (string message)
+	{
+		throw new System.NotImplementedException ();
+	}");
+		}
 	}
 }