renamed namespace to ICSharpCode.VBNetBinding; started implementation of new Code Completion binding

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/vbnet@6077 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/BackendBindings/VBNetBinding/Project/Src/Extensions.cs

@@ -8,7 +8,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
 	public static class Extensions
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/FormattingStrategy/VBNetFormattingStrategy.cs

@@ -19,7 +19,7 @@ using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.Editor;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
 	/// <summary>
 	/// This class handles the auto and smart indenting in the textbuffer while

src/AddIns/BackendBindings/VBNetBinding/Project/Src/FormattingStrategy/VBStatement.cs

@@ -9,7 +9,7 @@ using System;
 using ICSharpCode.NRefactory.Parser;
 using ICSharpCode.NRefactory.Parser.VB;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
 	public class VBStatement
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/MyNamespaceBuilder.cs

@@ -10,7 +10,7 @@ using System.Collections.Generic;
 using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.Project;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
 	public static class MyNamespaceBuilder
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/OptionPanels/BuildOptions.cs

@@ -10,7 +10,7 @@ using ICSharpCode.SharpDevelop.Gui.OptionPanels;
 using ICSharpCode.SharpDevelop.Project;
 using StringPair = System.Collections.Generic.KeyValuePair<System.String, System.String>;
 
-namespace VBNetBinding.OptionPanels
+namespace ICSharpCode.VBNetBinding.OptionPanels
 {
 	public class BuildOptions : AbstractBuildOptions
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/OptionPanels/ProjectImports.cs

@@ -14,7 +14,7 @@ using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.Gui.OptionPanels;
 using ICSharpCode.SharpDevelop.Project;
 
-namespace VBNetBinding.OptionPanels
+namespace ICSharpCode.VBNetBinding.OptionPanels
 {
 	public class ProjectImports : AbstractXmlFormsProjectOptionPanel
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/OptionPanels/TextEditorOptions.cs

@@ -11,7 +11,7 @@ using System.Windows.Forms;
 using ICSharpCode.Core;
 using ICSharpCode.SharpDevelop.Gui;
 
-namespace VBNetBinding.OptionPanels
+namespace ICSharpCode.VBNetBinding.OptionPanels
 {
 	public class VBNetTextEditorPanel : XmlFormsOptionPanel
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/Parser/Parser.cs

@@ -13,7 +13,7 @@ using ICSharpCode.SharpDevelop.Dom.VBNet;
 using ICSharpCode.SharpDevelop.Dom.NRefactoryResolver;
 using ICSharpCode.SharpDevelop.Project;
 
-namespace VBNetBinding.Parser
+namespace ICSharpCode.VBNetBinding.Parser
 {
 	public class TParser : IParser
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/Project/CSharpToVBNetConverter.cs

@@ -16,7 +16,7 @@ using ICSharpCode.SharpDevelop.Dom.NRefactoryResolver;
 using ICSharpCode.SharpDevelop.Project;
 using ICSharpCode.SharpDevelop.Project.Converter;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
 	public class CSharpToVBNetConverter : NRefactoryLanguageConverter
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/Project/VBNetProject.cs

@@ -16,7 +16,7 @@ using ICSharpCode.SharpDevelop.Dom.VBNet;
 using ICSharpCode.SharpDevelop.Internal.Templates;
 using ICSharpCode.SharpDevelop.Project;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
 	public class VBNetProject : CompilableProject
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetBracketSearcher.cs

@@ -15,7 +15,7 @@ using ICSharpCode.NRefactory.Parser;
 using ICSharpCode.NRefactory.Parser.VB;
 using ICSharpCode.SharpDevelop.Editor;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
 	public class VBNetBracketSearcher : IBracketSearcher
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetCompletionBinding.cs

@@ -1,195 +1,46 @@
 // <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
-//     <owner name="Markus Palme" email="MarkusPalme@gmx.de"/>
+//     <owner name="Siegfried Pammer" email="siegfriedpammer@gmail.com"/>
 //     <version>$Revision$</version>
 // </file>
 
-using ICSharpCode.SharpDevelop.Editor.CodeCompletion;
 using System;
-using ICSharpCode.Core;
-using ICSharpCode.NRefactory;
-using ICSharpCode.NRefactory.Parser;
 using ICSharpCode.SharpDevelop;
-using ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor;
-using ICSharpCode.SharpDevelop.Dom;
-using ICSharpCode.SharpDevelop.Dom.Refactoring;
-using ICSharpCode.SharpDevelop.Dom.VBNet;
 using ICSharpCode.SharpDevelop.Editor;
-using VBTokens = ICSharpCode.NRefactory.Parser.VB.Tokens;
+using ICSharpCode.SharpDevelop.Editor.CodeCompletion;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
-	public class VBNetCompletionBinding : NRefactoryCodeCompletionBinding
+	public class VBNetCompletionBinding : ICodeCompletionBinding
 	{
-		public VBNetCompletionBinding()
+		public CodeCompletionKeyPressResult HandleKeyPress(ITextEditor editor, char ch)
-			: base(SupportedLanguage.VBNet)
-		{
-			// Don't use indexer insight for '[', VB uses '(' for indexer access
-			this.EnableIndexerInsight = false;
-		}
-		
-		public override CodeCompletionKeyPressResult HandleKeyPress(ITextEditor editor, char ch)
-		{
-			if(ch == '(' && EnableMethodInsight && CodeCompletionOptions.InsightEnabled) {
-				IInsightWindow insightWindow = editor.ShowInsightWindow(new MethodInsightProvider().ProvideInsight(editor));
-				if (insightWindow != null)
-					InitializeOpenedInsightWindow(editor, insightWindow);
-				return CodeCompletionKeyPressResult.Completed;
-			} else if(ch == ',' && CodeCompletionOptions.InsightRefreshOnComma && CodeCompletionOptions.InsightEnabled) {
-				if (InsightRefreshOnComma(editor, ch))
-					return CodeCompletionKeyPressResult.Completed;
-			} else if (ch == '\n') {
-				TryDeclarationTypeInference(editor, editor.Document.GetLineForOffset(editor.Caret.Offset));
-			} else if (char.IsLetter(ch) && CodeCompletionOptions.CompleteWhenTyping) {
-				if (editor.SelectionLength > 0) {
-					// allow code completion when overwriting an identifier
-					int endOffset = editor.SelectionStart + editor.SelectionLength;
-					// but block code completion when overwriting only part of an identifier
-					if (endOffset < editor.Document.TextLength && char.IsLetterOrDigit(editor.Document.GetCharAt(endOffset)))
-						return CodeCompletionKeyPressResult.None;
-					
-					editor.Document.Remove(editor.SelectionStart, editor.SelectionLength);
-				}
-				int cursor = editor.Caret.Offset;
-				char prevChar = cursor > 1 ? editor.Document.GetCharAt(cursor - 1) : ' ';
-				bool afterUnderscore = prevChar == '_';
-				if (afterUnderscore) {
-					cursor--;
-					prevChar = cursor > 1 ? editor.Document.GetCharAt(cursor - 1) : ' ';
-				}
-				if (!char.IsLetterOrDigit(prevChar) && prevChar != '.' && !IsInComment(editor)) {
-					VBNetExpressionFinder ef = new VBNetExpressionFinder(ParserService.GetParseInformation(editor.FileName));
-					ExpressionResult result = ef.FindExpression(editor.Document.Text, cursor);
-					LoggingService.Debug("CC: Beginning to type a word, result=" + result + ", context=" + result.Context);
-					if (result.Context != ExpressionContext.IdentifierExpected) {
-						var ctrlSpaceProvider = new NRefactoryCtrlSpaceCompletionItemProvider(LanguageProperties.VBNet, result.Context);
-						ctrlSpaceProvider.ShowTemplates = true;
-						ctrlSpaceProvider.AllowCompleteExistingExpression = afterUnderscore;
-						ctrlSpaceProvider.ShowCompletion(editor);
-						return CodeCompletionKeyPressResult.CompletedIncludeKeyInCompletion;
-					}
-				}
-
-			}
-			
-			return base.HandleKeyPress(editor, ch);
-		}
-		
-		bool IsInComment(ITextEditor editor)
-		{
-			VBExpressionFinder ef = new VBExpressionFinder();
-			int cursor = editor.Caret.Offset - 1;
-			return ef.FilterComments(editor.Document.GetText(0, cursor + 1), ref cursor) == null;
-		}
-		
-		sealed class GlobalCompletionItemProvider : CodeCompletionItemProvider
-		{
-			public override ExpressionResult GetExpression(ITextEditor editor)
-			{
-				return new ExpressionResult("Global", ExpressionContext.Importable);
-			}
-		}
-		
-		public override bool HandleKeyword(ITextEditor editor, string word)
 		{
-			// TODO: Assistance writing Methods/Fields/Properties/Events:
+			switch (ch) {
-			// use public/static/etc. as keywords to display a list with other modifiers
+				case ' ':
-			// and possible return types.
+					if (CodeCompletionOptions.KeywordCompletionEnabled) {
-			switch (word.ToLowerInvariant()) {
+						string word = editor.GetWordBeforeCaret();
-				case "imports":
+						if (!string.IsNullOrEmpty(word)) {
-					if (IsInComment(editor)) return false;
+							if (HandleKeyword(editor, word))
-					new GlobalCompletionItemProvider().ShowCompletion(editor);
+								return CodeCompletionKeyPressResult.Completed;
-					return true;
+						}
-				case "as":
-					if (IsInComment(editor)) return false;
-					CtrlSpaceCompletionItemProvider(ExpressionContext.Type).ShowCompletion(editor);
-					return true;
-				case "new":
-					if (IsInComment(editor)) return false;
-					CtrlSpaceCompletionItemProvider(ExpressionContext.ObjectCreation).ShowCompletion(editor);
-					return true;
-				case "inherits":
-					if (IsInComment(editor)) return false;
-					CtrlSpaceCompletionItemProvider(ExpressionContext.Type).ShowCompletion(editor);
-					return true;
-				case "implements":
-					if (IsInComment(editor)) return false;
-					CtrlSpaceCompletionItemProvider(ExpressionContext.Interface).ShowCompletion(editor);
-					return true;
-				case "overrides":
-					if (IsInComment(editor)) return false;
-					new OverrideCompletionItemProvider().ShowCompletion(editor);
-					return true;
-				case "return":
-					if (IsInComment(editor)) return false;
-					IMember m = GetCurrentMember(editor);
-					if (m != null) {
-						ProvideContextCompletion(editor, m.ReturnType, ' ');
-						return true;
-					} else {
-						goto default;
 					}
-				case "option":
+					break;
-					if (IsInComment(editor)) return false;
-					new TextCompletionItemProvider("Explicit On",
-					                               "Explicit Off",
-					                               "Strict On",
-					                               "Strict Off",
-					                               "Compare Binary",
-					                               "Compare Text",
-					                               "Infer On",
-					                               "Infer Off")
-						.ShowCompletion(editor);
-					return true;
 				default:
-					return base.HandleKeyword(editor, word);
+					
+					break;
 			}
+			
+			return CodeCompletionKeyPressResult.None;
 		}
 		
-		CtrlSpaceCompletionItemProvider CtrlSpaceCompletionItemProvider(ExpressionContext context)
+		public bool CtrlSpace(ITextEditor editor)
 		{
-			return new NRefactoryCtrlSpaceCompletionItemProvider(LanguageProperties.VBNet, context);
+			return false;
 		}
 		
-		bool TryDeclarationTypeInference(ITextEditor editor, IDocumentLine curLine)
+		bool HandleKeyword(ITextEditor editor, string word)
 		{
-			string lineText = editor.Document.GetText(curLine.Offset, curLine.Length);
-			ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, new System.IO.StringReader(lineText));
-			if (lexer.NextToken().Kind != VBTokens.Dim)
-				return false;
-			if (lexer.NextToken().Kind != VBTokens.Identifier)
-				return false;
-			if (lexer.NextToken().Kind != VBTokens.As)
-				return false;
-			Token t1 = lexer.NextToken();
-			if (t1.Kind != VBTokens.QuestionMark)
-				return false;
-			Token t2 = lexer.NextToken();
-			if (t2.Kind != VBTokens.Assign)
-				return false;
-			string expr = lineText.Substring(t2.Location.Column);
-			LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
-			ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
-			                                         editor.Caret.Line,
-			                                         t2.Location.Column, editor.FileName,
-			                                         editor.Document.Text);
-			if (rr != null && rr.ResolvedType != null) {
-				ClassFinder context = new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.Caret.Line, t1.Location.Column);
-				VBNetAmbience ambience = new VBNetAmbience();
-				if (CodeGenerator.CanUseShortTypeName(rr.ResolvedType, context))
-					ambience.ConversionFlags = ConversionFlags.None;
-				else
-					ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames;
-				string typeName = ambience.Convert(rr.ResolvedType);
-				using (editor.Document.OpenUndoGroup()) {
-					int offset = curLine.Offset + t1.Location.Column - 1;
-					editor.Document.Remove(offset, 1);
-					editor.Document.Insert(offset, typeName);
-				}
-				editor.Caret.Column += typeName.Length - 1;
-				return true;
-			}
 			return false;
 		}
 	}

src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetCompletionBindingOld.cs

@@ -0,0 +1,196 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Markus Palme" email="MarkusPalme@gmx.de"/>
+//     <version>$Revision: 5922 $</version>
+// </file>
+
+using ICSharpCode.SharpDevelop.Editor.CodeCompletion;
+using System;
+using ICSharpCode.Core;
+using ICSharpCode.NRefactory;
+using ICSharpCode.NRefactory.Parser;
+using ICSharpCode.SharpDevelop;
+using ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.Refactoring;
+using ICSharpCode.SharpDevelop.Dom.VBNet;
+using ICSharpCode.SharpDevelop.Editor;
+using VBTokens = ICSharpCode.NRefactory.Parser.VB.Tokens;
+
+namespace ICSharpCode.VBNetBinding
+{
+	public class VBNetCompletionBindingOld : NRefactoryCodeCompletionBinding
+	{
+		public VBNetCompletionBindingOld()
+			: base(SupportedLanguage.VBNet)
+		{
+			// Don't use indexer insight for '[', VB uses '(' for indexer access
+			this.EnableIndexerInsight = false;
+		}
+		
+		public override CodeCompletionKeyPressResult HandleKeyPress(ITextEditor editor, char ch)
+		{
+			if(ch == '(' && EnableMethodInsight && CodeCompletionOptions.InsightEnabled) {
+				IInsightWindow insightWindow = editor.ShowInsightWindow(new MethodInsightProvider().ProvideInsight(editor));
+				if (insightWindow != null)
+					InitializeOpenedInsightWindow(editor, insightWindow);
+				return CodeCompletionKeyPressResult.Completed;
+			} else if(ch == ',' && CodeCompletionOptions.InsightRefreshOnComma && CodeCompletionOptions.InsightEnabled) {
+				if (InsightRefreshOnComma(editor, ch))
+					return CodeCompletionKeyPressResult.Completed;
+			} else if (ch == '\n') {
+				TryDeclarationTypeInference(editor, editor.Document.GetLineForOffset(editor.Caret.Offset));
+			} else if (char.IsLetter(ch) && CodeCompletionOptions.CompleteWhenTyping) {
+				if (editor.SelectionLength > 0) {
+					// allow code completion when overwriting an identifier
+					int endOffset = editor.SelectionStart + editor.SelectionLength;
+					// but block code completion when overwriting only part of an identifier
+					if (endOffset < editor.Document.TextLength && char.IsLetterOrDigit(editor.Document.GetCharAt(endOffset)))
+						return CodeCompletionKeyPressResult.None;
+					
+					editor.Document.Remove(editor.SelectionStart, editor.SelectionLength);
+				}
+				int cursor = editor.Caret.Offset;
+				char prevChar = cursor > 1 ? editor.Document.GetCharAt(cursor - 1) : ' ';
+				bool afterUnderscore = prevChar == '_';
+				if (afterUnderscore) {
+					cursor--;
+					prevChar = cursor > 1 ? editor.Document.GetCharAt(cursor - 1) : ' ';
+				}
+				if (!char.IsLetterOrDigit(prevChar) && prevChar != '.' && !IsInComment(editor)) {
+					VBNetExpressionFinder ef = new VBNetExpressionFinder(ParserService.GetParseInformation(editor.FileName));
+					ExpressionResult result = ef.FindExpression(editor.Document.Text, cursor);
+					LoggingService.Debug("CC: Beginning to type a word, result=" + result + ", context=" + result.Context);
+					if (result.Context != ExpressionContext.IdentifierExpected) {
+						var ctrlSpaceProvider = new NRefactoryCtrlSpaceCompletionItemProvider(LanguageProperties.VBNet, result.Context);
+						ctrlSpaceProvider.ShowTemplates = true;
+						ctrlSpaceProvider.AllowCompleteExistingExpression = afterUnderscore;
+						ctrlSpaceProvider.ShowCompletion(editor);
+						return CodeCompletionKeyPressResult.CompletedIncludeKeyInCompletion;
+					}
+				}
+	
+			}
+			
+			return base.HandleKeyPress(editor, ch);
+		}
+		
+		bool IsInComment(ITextEditor editor)
+		{
+			VBExpressionFinder ef = new VBExpressionFinder();
+			int cursor = editor.Caret.Offset - 1;
+			return ef.FilterComments(editor.Document.GetText(0, cursor + 1), ref cursor) == null;
+		}
+		
+		sealed class GlobalCompletionItemProvider : CodeCompletionItemProvider
+		{
+			public override ExpressionResult GetExpression(ITextEditor editor)
+			{
+				return new ExpressionResult("Global", ExpressionContext.Importable);
+			}
+		}
+		
+		public override bool HandleKeyword(ITextEditor editor, string word)
+		{
+			// TODO: Assistance writing Methods/Fields/Properties/Events:
+			// use public/static/etc. as keywords to display a list with other modifiers
+			// and possible return types.
+			switch (word.ToLowerInvariant()) {
+				case "imports":
+					if (IsInComment(editor)) return false;
+					new GlobalCompletionItemProvider().ShowCompletion(editor);
+					return true;
+				case "as":
+					if (IsInComment(editor)) return false;
+					CtrlSpaceCompletionItemProvider(ExpressionContext.Type).ShowCompletion(editor);
+					return true;
+				case "new":
+					if (IsInComment(editor)) return false;
+					CtrlSpaceCompletionItemProvider(ExpressionContext.ObjectCreation).ShowCompletion(editor);
+					return true;
+				case "inherits":
+					if (IsInComment(editor)) return false;
+					CtrlSpaceCompletionItemProvider(ExpressionContext.Type).ShowCompletion(editor);
+					return true;
+				case "implements":
+					if (IsInComment(editor)) return false;
+					CtrlSpaceCompletionItemProvider(ExpressionContext.Interface).ShowCompletion(editor);
+					return true;
+				case "overrides":
+					if (IsInComment(editor)) return false;
+					new OverrideCompletionItemProvider().ShowCompletion(editor);
+					return true;
+				case "return":
+					if (IsInComment(editor)) return false;
+					IMember m = GetCurrentMember(editor);
+					if (m != null) {
+						ProvideContextCompletion(editor, m.ReturnType, ' ');
+						return true;
+					} else {
+						goto default;
+					}
+				case "option":
+					if (IsInComment(editor)) return false;
+					new TextCompletionItemProvider("Explicit On",
+					                               "Explicit Off",
+					                               "Strict On",
+					                               "Strict Off",
+					                               "Compare Binary",
+					                               "Compare Text",
+					                               "Infer On",
+					                               "Infer Off")
+						.ShowCompletion(editor);
+					return true;
+				default:
+					return base.HandleKeyword(editor, word);
+			}
+		}
+		
+		CtrlSpaceCompletionItemProvider CtrlSpaceCompletionItemProvider(ExpressionContext context)
+		{
+			return new NRefactoryCtrlSpaceCompletionItemProvider(LanguageProperties.VBNet, context);
+		}
+		
+		bool TryDeclarationTypeInference(ITextEditor editor, IDocumentLine curLine)
+		{
+			string lineText = editor.Document.GetText(curLine.Offset, curLine.Length);
+			ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, new System.IO.StringReader(lineText));
+			if (lexer.NextToken().Kind != VBTokens.Dim)
+				return false;
+			if (lexer.NextToken().Kind != VBTokens.Identifier)
+				return false;
+			if (lexer.NextToken().Kind != VBTokens.As)
+				return false;
+			Token t1 = lexer.NextToken();
+			if (t1.Kind != VBTokens.QuestionMark)
+				return false;
+			Token t2 = lexer.NextToken();
+			if (t2.Kind != VBTokens.Assign)
+				return false;
+			string expr = lineText.Substring(t2.Location.Column);
+			LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
+			ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
+			                                         editor.Caret.Line,
+			                                         t2.Location.Column, editor.FileName,
+			                                         editor.Document.Text);
+			if (rr != null && rr.ResolvedType != null) {
+				ClassFinder context = new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.Caret.Line, t1.Location.Column);
+				VBNetAmbience ambience = new VBNetAmbience();
+				if (CodeGenerator.CanUseShortTypeName(rr.ResolvedType, context))
+					ambience.ConversionFlags = ConversionFlags.None;
+				else
+					ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames;
+				string typeName = ambience.Convert(rr.ResolvedType);
+				using (editor.Document.OpenUndoGroup()) {
+					int offset = curLine.Offset + t1.Location.Column - 1;
+					editor.Document.Remove(offset, 1);
+					editor.Document.Insert(offset, typeName);
+				}
+				editor.Caret.Column += typeName.Length - 1;
+				return true;
+			}
+			return false;
+		}
+	}
+}

src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetLanguageBinding.cs

@@ -5,11 +5,11 @@
 //     <version>$Revision$</version>
 // </file>
 
-using ICSharpCode.SharpDevelop.Editor;
 using System;
 using ICSharpCode.SharpDevelop;
+using ICSharpCode.SharpDevelop.Editor;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
 	/// <summary>
 	/// Description of VBNetLanguageBinding.

src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetProjectBinding.cs

@@ -10,7 +10,7 @@ using System.Xml;
 using ICSharpCode.SharpDevelop.Internal.Templates;
 using ICSharpCode.SharpDevelop.Project;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
 	public class VBNetProjectBinding : IProjectBinding
 	{

src/AddIns/BackendBindings/VBNetBinding/Project/Src/VbcEncodingFixingLogger.cs

@@ -11,7 +11,7 @@ using ICSharpCode.SharpDevelop.Project;
 using Microsoft.Build.Framework;
 using System.IO;
 
-namespace VBNetBinding
+namespace ICSharpCode.VBNetBinding
 {
 	/// <summary>
 	/// Fixes SD2-995 : Special characters not correctly encoded for languages others than English

src/AddIns/BackendBindings/VBNetBinding/Project/VBNetBinding.addin

@@ -9,7 +9,7 @@
 	</Manifest>
 	
 	<Runtime>
-		<Import assembly = "VBNetBinding.dll"/>
+		<Import assembly = "ICSharpCode.VBNetBinding.dll"/>
 		<Import assembly = ":ICSharpCode.SharpDevelop"/>
 		<Import assembly = ":ICSharpCode.SharpDevelop.Dom"/>
 	</Runtime>
@@ -43,28 +43,28 @@
 		<TaskBoundLoggerFilter
 			id = "VbcEncodingFixingLogger"
 			taskname = "vbc"
-			class = "VBNetBinding.VbcEncodingFixingLogger"/>
+			class = "ICSharpCode.VBNetBinding.VbcEncodingFixingLogger"/>
 	</Path>
 	
 	<Path name = "/Workspace/Parser">
 		<Parser id    = "VBNet" 
 			supportedextensions  = ".vb"
 			projectfileextension = ".vbproj"
-			class = "VBNetBinding.Parser.TParser"/>
+			class = "ICSharpCode.VBNetBinding.Parser.TParser"/>
 	</Path>
 	
 	<Path name = "/SharpDevelop/Pads/ProjectBrowser/ContextMenu/ProjectActions/Convert">
 		<Condition name = "ProjectActive" activeproject="C#">
 			<MenuItem id = "CSharpToVBConverter"
 			          label = "${res:ICSharpCode.SharpDevelop.Commands.CharpConvertProjectToVB}"
-			          class = "VBNetBinding.CSharpToVBNetConverter"/>
+			          class = "ICSharpCode.VBNetBinding.CSharpToVBNetConverter"/>
 		</Condition>
 	</Path>
 	
 	<Path name = "/SharpDevelop/Dialogs/OptionsDialog/TextEditorOptions">
 		<OptionPanel id = "VBSpecificOptions"
 			             label = "${res:Dialog.Options.IDEOptions.TextEditor.VB.PanelName}"
-			             class = "VBNetBinding.OptionPanels.VBNetTextEditorPanel"/>
+			             class = "ICSharpCode.VBNetBinding.OptionPanels.VBNetTextEditorPanel"/>
 	</Path>
 	
 	<Path path = "/SharpDevelop/BackendBindings/ProjectOptions/VBNet">
@@ -82,7 +82,7 @@
 		             class = "ICSharpCode.SharpDevelop.Gui.OptionPanels.BuildEvents"/>
 		<OptionPanel id    = "BuildOptions"
 		             label = "${res:Dialog.ProjectOptions.BuildOptions}"
-		             class = "VBNetBinding.OptionPanels.BuildOptions"/>
+		             class = "ICSharpCode.VBNetBinding.OptionPanels.BuildOptions"/>
 		<OptionPanel id    = "DebugOptions"
 		             label = "${res:Dialog.ProjectOptions.DebugOptions}"
 		             class = "ICSharpCode.SharpDevelop.Gui.OptionPanels.DebugOptions"/>
@@ -91,7 +91,7 @@
 		             class = "ICSharpCode.SharpDevelop.Gui.OptionPanels.Publish"/>-->
 		<OptionPanel id    = "ProjectImports"
 		             label = "${res:Dialog.ProjectOptions.ProjectImports}"
-		             class = "VBNetBinding.OptionPanels.ProjectImports"/>
+		             class = "ICSharpCode.VBNetBinding.OptionPanels.ProjectImports"/>
 		<Include id = "AllManaged" path="/SharpDevelop/BackendBindings/ProjectOptions/AllManaged"/>
 	</Path>
 
@@ -100,7 +100,7 @@
 	</Path>
 	
 	<Path name="/SharpDevelop/Workbench/LanguageBindings">
-		<LanguageBinding id="VBNet" class="VBNetBinding.VBNetLanguageBinding" extensions=".vb" />
+		<LanguageBinding id="VBNet" class="ICSharpCode.VBNetBinding.VBNetLanguageBinding" extensions=".vb" />
 	</Path>
 	
 	<Path name = "/Workspace/Icons">
@@ -119,7 +119,7 @@
 		                guid                 = "{F184B08F-C81C-45F6-A57F-5ABD9991F28F}"
 		                supportedextensions  = ".vb"
 		                projectfileextension = ".vbproj"
-		                class                = "VBNetBinding.VBNetProjectBinding" />
+		                class                = "ICSharpCode.VBNetBinding.VBNetProjectBinding" />
 	</Path>
 	
 	<Path name="/SharpDevelop/Services/ParserService/SingleFileGacReferences">

src/AddIns/BackendBindings/VBNetBinding/Project/VBNetBinding.csproj

@@ -6,7 +6,7 @@
     <ProductVersion>8.0.50630</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{BF38FB72-B380-4196-AF8C-95749D726C61}</ProjectGuid>
-    <AssemblyName>VBNetBinding</AssemblyName>
+    <AssemblyName>ICSharpCode.VBNetBinding</AssemblyName>
     <OutputTarget>Library</OutputTarget>
     <WarningLevel>4</WarningLevel>
     <NoStdLib>False</NoStdLib>
@@ -21,6 +21,7 @@
     <BaseAddress>104857600</BaseAddress>
     <PlatformTarget>AnyCPU</PlatformTarget>
     <FileAlignment>4096</FileAlignment>
+    <RootNamespace>ICSharpCode.VBNetBinding</RootNamespace>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -53,6 +54,7 @@
     <Compile Include="Src\Extensions.cs" />
     <Compile Include="Src\FormattingStrategy\VBStatement.cs" />
     <Compile Include="Src\VBNetBracketSearcher.cs" />
+    <Compile Include="Src\VBNetCompletionBindingOld.cs" />
     <Compile Include="Src\VBNetLanguageBinding.cs" />
     <Compile Include="Src\VBNetProjectBinding.cs" />
     <Compile Include="Src\FormattingStrategy\VBNetFormattingStrategy.cs" />

src/AddIns/BackendBindings/VBNetBinding/Test/FormattingStrategy/EndOperatorTests.cs

@@ -11,7 +11,7 @@ using ICSharpCode.AvalonEdit;
 using ICSharpCode.Core;
 using NUnit.Framework;
 
-namespace VBNetBinding.Tests
+namespace ICSharpCode.VBNetBinding.Tests
 {
 	/// <summary>
 	/// Tests that Operator overrides have "End Operator" added after the user presses the return key.

src/AddIns/BackendBindings/VBNetBinding/Test/FormattingStrategy/EndSubTests.cs

@@ -11,7 +11,7 @@ using ICSharpCode.Core;
 using ICSharpCode.SharpDevelop.Editor.AvalonEdit;
 using NUnit.Framework;
 
-namespace VBNetBinding.Tests
+namespace ICSharpCode.VBNetBinding.Tests
 {
 	/// <summary>
 	/// Tests that Operator overrides have "End Operator" added after the user presses the return key.

src/AddIns/BackendBindings/VBNetBinding/Test/FormattingStrategy/IndentationTests.cs

@@ -11,7 +11,7 @@ using ICSharpCode.AvalonEdit;
 using ICSharpCode.Core;
 using NUnit.Framework;
 
-namespace VBNetBinding.Tests
+namespace ICSharpCode.VBNetBinding.Tests
 {
 	[TestFixture]
 	public class IndentationTests

src/AddIns/BackendBindings/VBNetBinding/Test/FormattingStrategy/InterfaceTests.cs

@@ -11,7 +11,7 @@ using ICSharpCode.Core;
 using ICSharpCode.SharpDevelop.Editor.AvalonEdit;
 using NUnit.Framework;
 
-namespace VBNetBinding.Tests
+namespace ICSharpCode.VBNetBinding.Tests
 {
 	/// <summary>
 	/// Tests the special case of an interface. for ex. no insertion of End-Tags etc.

src/AddIns/BackendBindings/VBNetBinding/Test/VBNetBinding.Tests.csproj

@@ -2,8 +2,8 @@
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <RootNamespace>VBNetBinding.Tests</RootNamespace>
+    <RootNamespace>ICSharpCode.VBNetBinding.Tests</RootNamespace>
-    <AssemblyName>VBNetBinding.Tests</AssemblyName>
+    <AssemblyName>ICSharpCode.VBNetBinding.Tests</AssemblyName>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProjectGuid>{50A89267-A28B-4DF3-8E62-912E005143B8}</ProjectGuid>

src/AddIns/Misc/ResourceToolkit/Test/TestHelper.cs

@@ -35,7 +35,7 @@ namespace ResourceToolkit.Tests
 		{
 			Dictionary<string, IParser> parsers = new Dictionary<string, IParser>();
 			parsers.Add(".cs", new CSharpBinding.Parser.TParser());
-			parsers.Add(".vb", new VBNetBinding.Parser.TParser());
+			parsers.Add(".vb", new ICSharpCode.VBNetBinding.Parser.TParser());
 			ResourceResolverService.SetParsersUnitTestOnly(parsers);
 		}
 		

src/AddIns/Misc/ResourceToolkit/Test/VBNet/AbstractVBNetResourceResolverTestFixture.cs

@@ -13,7 +13,7 @@ using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.Internal.Templates;
 using ICSharpCode.SharpDevelop.Project;
 using NUnit.Framework;
-using VBNetBinding;
+using ICSharpCode.VBNetBinding;
 
 namespace ResourceToolkit.Tests.VBNet
 {

src/Libraries/NRefactory/Project/Src/Lexer/VBNet/ExpressionFinder.atg

@@ -7,7 +7,7 @@ using ICSharpCode.NRefactory.Ast;
 using ICSharpCode.NRefactory.Parser.VB;
 using ASTAttribute = ICSharpCode.NRefactory.Ast.Attribute;
 
-PUSHCOMPILER ExpressionFinder
+PUSHCOMPILER WITH EXPECTEDSETS ExpressionFinder
 
 /* START AUTOGENERATED TOKENS SECTION */
 TOKENS

src/Libraries/NRefactory/Project/Src/Lexer/VBNet/PushParser.frame

@@ -80,7 +80,9 @@ partial class ExpressionFinder {
 		InformToken(null);
 	}
 	
-	static readonly bool[,] set = {
+	public BitArray GetExpectedSet() { return GetExpectedSet(currentState); }
+	
+	static readonly BitArray[] set = {
 -->initialization
 	};
 

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/NRefactoryResolver/NRefactoryResolver.cs

@@ -1149,21 +1149,14 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			List<ICompletionEntry> result = new List<ICompletionEntry>();
 			if (language == NR.SupportedLanguage.VBNet) {
 				
-				if (context == ExpressionContext.TypeDeclaration) {
+//				if (context == ExpressionContext.TypeDeclaration) {
-					AddVBNetKeywords(result, NR.Parser.VB.Tokens.TypeLevel);
+//				} else if (context == ExpressionContext.Global) {
-				} else if (context == ExpressionContext.Global) {
+//				} else if (context == ExpressionContext.MethodBody) {
-					AddVBNetKeywords(result, NR.Parser.VB.Tokens.GlobalLevel);
+//					CtrlSpaceInternal(result, fileContent, showEntriesFromAllNamespaces);
-				} else if (context == ExpressionContext.MethodBody) {
+//				} else {
-					AddVBNetKeywords(result, NR.Parser.VB.Tokens.StatementStart);
+//					AddVBNetPrimitiveTypes(result);
-					CtrlSpaceInternal(result, fileContent, showEntriesFromAllNamespaces);
+//					CtrlSpaceInternal(result, fileContent, showEntriesFromAllNamespaces);
-				} else {
+//				}
-					AddVBNetPrimitiveTypes(result);
-					CtrlSpaceInternal(result, fileContent, showEntriesFromAllNamespaces);
-				}
-				
-				result.Add(new KeywordEntry("Global"));
-				result.Add(new KeywordEntry("New"));
-				
 			} else {
 				if (context == ExpressionContext.TypeDeclaration) {
 					AddCSharpKeywords(result, NR.Parser.CSharp.Tokens.TypeLevel);
@@ -1248,17 +1241,6 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			}
 			return result;
 		}
-
-		void AddVBNetPrimitiveTypes(List<ICompletionEntry> result)
-		{
-			foreach (KeyValuePair<string, string> pair in TypeReference.PrimitiveTypesVB) {
-				if ("System." + pair.Key != pair.Value) {
-					IClass c = GetPrimitiveClass(pair.Value, pair.Key);
-					if (c != null)
-						result.Add(c);
-				}
-			}
-		}
 		
 		void AddCSharpPrimitiveTypes(List<ICompletionEntry> result)
 		{