- allow code completion bindings to handle ReturnEditAction by handling '\n'.

- add dummy token "?" to VB lexer.
- use IntegerLiteralResolveResult that doesn't do code completion instead of returning no ResolveResult at all when resolving an integer literal.
- Implemented SD2-501: type inference when typing for both C# and VB.NET.
You can now type "? name = expr;" or "Dim name as ? = expr" and SharpDevelop will fill in the type for you.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@603 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

data/options/TipsOfTheDay.xml

@@ -2,4 +2,5 @@
 <TIPS>
         <TIP>${res:XML.StartupTips.Tip1}</TIP>
         <TIP>${res:XML.StartupTips.Tip2}</TIP>
+        <TIP>${res:XML.StartupTips.Tip3}</TIP>
 </TIPS>

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/BooResolver.cs

@@ -182,7 +182,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 			if (expr == null)
 				return null;
 			if (expr is AST.IntegerLiteralExpression)
-				return null; // no CC for "5."
+				return new IntegerLiteralResolveResult(callingClass, callingMember);
 			
 			if (expressionResult.Context == ExpressionFinder.BooAttributeContext.Instance) {
 				AST.MethodInvocationExpression mie = expr as AST.MethodInvocationExpression;

src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpCompletionBinding.cs

@@ -15,6 +15,8 @@ using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor;
 using ICSharpCode.SharpDevelop.Dom.NRefactoryResolver;
+using ICSharpCode.NRefactory.Parser;
+using CSTokens = ICSharpCode.NRefactory.Parser.CSharp.Tokens;
 
 namespace CSharpBinding
 {
@@ -114,11 +116,43 @@ namespace CSharpBinding
 						}
 					}
 				}
+			} else if (ch == ';') {
+				LineSegment curLine = editor.Document.GetLineSegmentForOffset(cursor);
+				// don't return true when inference succeeds, otherwise the ';' won't be added to the document.
+				TryDeclarationTypeInference(editor, curLine);
 			}
 			
 			return base.HandleKeyPress(editor, ch);
 		}
 		
+		bool TryDeclarationTypeInference(SharpDevelopTextAreaControl editor, LineSegment curLine)
+		{
+			string lineText = editor.Document.GetText(curLine.Offset, curLine.Length);
+			ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.CSharp, new System.IO.StringReader(lineText));
+			Token typeToken = lexer.NextToken();
+			if (typeToken.kind == CSTokens.Question) {
+				if (lexer.NextToken().kind == CSTokens.Identifier) {
+					Token t = lexer.NextToken();
+					if (t.kind == CSTokens.Assign) {
+						string expr = lineText.Substring(t.col);
+						LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
+						ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
+						                                         editor.ActiveTextAreaControl.Caret.Line,
+						                                         t.col, editor.FileName,
+						                                         editor.Document.TextContent);
+						if (rr != null && rr.ResolvedType != null) {
+							CSharpAmbience.Instance.ConversionFlags = ConversionFlags.ShowReturnType;
+							string typeName = CSharpAmbience.Instance.Convert(rr.ResolvedType);
+							editor.Document.Replace(curLine.Offset + typeToken.col - 1, 1, typeName);
+							editor.ActiveTextAreaControl.Caret.Column += typeName.Length - 1;
+							return true;
+						}
+					}
+				}
+			}
+			return false;
+		}
+		
 		void ShowInsight(SharpDevelopTextAreaControl editor, MethodInsightDataProvider dp, Stack<ResolveResult> parameters, char charTyped)
 		{
 			int paramCount = parameters.Count;
@@ -127,7 +161,7 @@ namespace CSharpBinding
 			if (methods.Count == 0) return;
 			bool overloadIsSure;
 			if (methods.Count == 1) {
-		 		overloadIsSure = true;
+				overloadIsSure = true;
 				dp.DefaultIndex = 0;
 			} else {
 				IReturnType[] parameterTypes = new IReturnType[paramCount + 1];

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

@@ -16,6 +16,8 @@ using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor;
 using ICSharpCode.SharpDevelop.Dom.NRefactoryResolver;
+using ICSharpCode.NRefactory.Parser;
+using VBTokens = ICSharpCode.NRefactory.Parser.VB.Tokens;
 
 namespace VBNetBinding
 {
@@ -94,6 +96,8 @@ namespace VBNetBinding
 						cursor = ef.LastExpressionStartPosition;
 					}
 				}
+			} else if (ch == '\n') {
+				TryDeclarationTypeInference(editor, editor.Document.GetLineSegmentForOffset(cursor));
 			}
 			return base.HandleKeyPress(editor, ch);
 		}
@@ -194,5 +198,37 @@ namespace VBNetBinding
 					return base.HandleKeyword(editor, word);
 			}
 		}
+		
+		bool TryDeclarationTypeInference(SharpDevelopTextAreaControl editor, LineSegment 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.col);
+			LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
+			ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
+			                                         editor.ActiveTextAreaControl.Caret.Line,
+			                                         t2.col, editor.FileName,
+			                                         editor.Document.TextContent);
+			if (rr != null && rr.ResolvedType != null) {
+				VBNetAmbience.Instance.ConversionFlags = ConversionFlags.ShowReturnType;
+				string typeName = VBNetAmbience.Instance.Convert(rr.ResolvedType);
+				editor.Document.Replace(curLine.Offset + t1.col - 1, 1, typeName);
+				editor.ActiveTextAreaControl.Caret.Column += typeName.Length - 1;
+				return true;
+			}
+			return false;
+		}
 	}
 }

src/Libraries/ICSharpCode.TextEditor/Project/Src/Actions/MiscActions.cs

@@ -708,16 +708,20 @@ namespace ICSharpCode.TextEditor.Actions
 				return;
 			}
 			textArea.BeginUpdate();
-			
-			textArea.InsertString(Environment.NewLine);
-			
-			int curLineNr = textArea.Caret.Line;
-			textArea.Caret.Column = textArea.Document.FormattingStrategy.FormatLine(textArea, curLineNr, textArea.Caret.Offset, '\n');
-			textArea.SetDesiredColumn();
-			
-			textArea.Document.UpdateQueue.Clear();
-			textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.PositionToEnd, new Point(0, curLineNr - 1)));
-			textArea.EndUpdate();
+			try {
+				if (textArea.HandleKeyPress('\n'))
+					return;
+				textArea.InsertString(Environment.NewLine);
+				
+				int curLineNr = textArea.Caret.Line;
+				textArea.Caret.Column = textArea.Document.FormattingStrategy.FormatLine(textArea, curLineNr, textArea.Caret.Offset, '\n');
+				textArea.SetDesiredColumn();
+				
+				textArea.Document.UpdateQueue.Clear();
+				textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.PositionToEnd, new Point(0, curLineNr - 1)));
+			} finally {
+				textArea.EndUpdate();
+			}
 		}
 	}
 	

src/Libraries/ICSharpCode.TextEditor/Project/Src/Gui/TextArea.cs

@@ -440,7 +440,7 @@ namespace ICSharpCode.TextEditor
 		/// True, if the key is handled by this method and should NOT be
 		/// inserted in the textarea.
 		/// </returns>
-		protected virtual bool HandleKeyPress(char ch)
+		protected internal virtual bool HandleKeyPress(char ch)
 		{
 			if (KeyEventHandler != null) {
 				return KeyEventHandler(ch);
@@ -802,5 +802,7 @@ namespace ICSharpCode.TextEditor
 		#endregion
 		public event KeyEventHandler    KeyEventHandler;
 		public event DialogKeyProcessor DoProcessDialogKey;
+		
+		//internal void 
 	}
 }

src/Libraries/NRefactory/Project/Src/Lexer/BuildKeywords.pl

@@ -1,4 +1,3 @@
-
 #!/bin/perl
 
 # File names
@@ -59,7 +58,7 @@ sort (ascend @keywords);
 print "done.\n";
 
 #write output
-print "writing output files.\nIf your computer doesn?t respond, then press \"Ctrl-Alt-Delete\"\n";
+print "writing output files.\nIf your computer doesn’t respond, then press \"Ctrl-Alt-Delete\"\n";
 print "\n";
 &write_keywordfile;
 print "\n";
@@ -255,7 +254,7 @@ sub write_unittests {
 	open(DAT,">$unittests_outfile") || die("Cannot Open File");
 	print DAT "using System;\n";
 	print DAT "using System.IO;\n";
-	print DAT "using MbUnit.Framework;\n";
+	print DAT "using NUnit.Framework;\n";
 	print DAT "using ICSharpCode.NRefactory.Parser;\n";
 	print DAT "using ICSharpCode.NRefactory.PrettyPrinter;\n";
 	

src/Libraries/NRefactory/Project/Src/Lexer/VBNet/KeywordList.txt

@@ -32,7 +32,9 @@ Div ="/"
 DivInteger = "\\"
 ConcatString = "&"
 Power = "^"
-	
+# Question mark is not needed by VB8, but we use it inside the IDE
+QuestionMark = "?"
+
 OpenCurlyBrace = "{"
 CloseCurlyBrace = "}"
 	

src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Lexer.cs

@@ -690,10 +690,8 @@ namespace ICSharpCode.NRefactory.Parser.VB
 					return new Token(Tokens.OpenCurlyBrace, x, y);
 				case '}':
 					return new Token(Tokens.CloseCurlyBrace, x, y);
-//				case '[':
-//					return new Token(Tokens.OpenSquareBracket, x, y);
-//				case ']':
-//					return new Token(Tokens.CloseSquareBracket, x, y);
+				case '?':
+					return new Token(Tokens.QuestionMark, x, y);
 			}
 			return null;
 		}

src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Tokens.cs

@@ -30,194 +30,195 @@ namespace ICSharpCode.NRefactory.Parser.VB
 		public const int DivInteger           = 18;
 		public const int ConcatString         = 19;
 		public const int Power                = 20;
-		public const int OpenCurlyBrace       = 21;
-		public const int CloseCurlyBrace      = 22;
-		public const int OpenParenthesis      = 23;
-		public const int CloseParenthesis     = 24;
-		public const int GreaterThan          = 25;
-		public const int LessThan             = 26;
-		public const int NotEqual             = 27;
-		public const int GreaterEqual         = 28;
-		public const int LessEqual            = 29;
-		public const int ShiftLeft            = 30;
-		public const int ShiftRight           = 31;
-		public const int PlusAssign           = 32;
-		public const int PowerAssign          = 33;
-		public const int MinusAssign          = 34;
-		public const int TimesAssign          = 35;
-		public const int DivAssign            = 36;
-		public const int DivIntegerAssign     = 37;
-		public const int ShiftLeftAssign      = 38;
-		public const int ShiftRightAssign     = 39;
-		public const int ConcatStringAssign   = 40;
+		public const int QuestionMark         = 21;
+		public const int OpenCurlyBrace       = 22;
+		public const int CloseCurlyBrace      = 23;
+		public const int OpenParenthesis      = 24;
+		public const int CloseParenthesis     = 25;
+		public const int GreaterThan          = 26;
+		public const int LessThan             = 27;
+		public const int NotEqual             = 28;
+		public const int GreaterEqual         = 29;
+		public const int LessEqual            = 30;
+		public const int ShiftLeft            = 31;
+		public const int ShiftRight           = 32;
+		public const int PlusAssign           = 33;
+		public const int PowerAssign          = 34;
+		public const int MinusAssign          = 35;
+		public const int TimesAssign          = 36;
+		public const int DivAssign            = 37;
+		public const int DivIntegerAssign     = 38;
+		public const int ShiftLeftAssign      = 39;
+		public const int ShiftRightAssign     = 40;
+		public const int ConcatStringAssign   = 41;
 
 		// ----- keywords -----
-		public const int AddHandler           = 41;
-		public const int AddressOf            = 42;
-		public const int Alias                = 43;
-		public const int And                  = 44;
-		public const int AndAlso              = 45;
-		public const int Ansi                 = 46;
-		public const int As                   = 47;
-		public const int Assembly             = 48;
-		public const int Auto                 = 49;
-		public const int Binary               = 50;
-		public const int Boolean              = 51;
-		public const int ByRef                = 52;
-		public const int Byte                 = 53;
-		public const int ByVal                = 54;
-		public const int Call                 = 55;
-		public const int Case                 = 56;
-		public const int Catch                = 57;
-		public const int CBool                = 58;
-		public const int CByte                = 59;
-		public const int CChar                = 60;
-		public const int CDate                = 61;
-		public const int CDbl                 = 62;
-		public const int CDec                 = 63;
-		public const int Char                 = 64;
-		public const int CInt                 = 65;
-		public const int Class                = 66;
-		public const int CLng                 = 67;
-		public const int CObj                 = 68;
-		public const int Compare              = 69;
-		public const int Const                = 70;
-		public const int CShort               = 71;
-		public const int CSng                 = 72;
-		public const int CStr                 = 73;
-		public const int CType                = 74;
-		public const int Date                 = 75;
-		public const int Decimal              = 76;
-		public const int Declare              = 77;
-		public const int Default              = 78;
-		public const int Delegate             = 79;
-		public const int Dim                  = 80;
-		public const int DirectCast           = 81;
-		public const int Do                   = 82;
-		public const int Double               = 83;
-		public const int Each                 = 84;
-		public const int Else                 = 85;
-		public const int ElseIf               = 86;
-		public const int End                  = 87;
-		public const int EndIf                = 88;
-		public const int Enum                 = 89;
-		public const int Erase                = 90;
-		public const int Error                = 91;
-		public const int Event                = 92;
-		public const int Exit                 = 93;
-		public const int Explicit             = 94;
-		public const int False                = 95;
-		public const int Finally              = 96;
-		public const int For                  = 97;
-		public const int Friend               = 98;
-		public const int Function             = 99;
-		public const int Get                  = 100;
-		new public const int GetType              = 101;
-		public const int GoSub                = 102;
-		public const int GoTo                 = 103;
-		public const int Handles              = 104;
-		public const int If                   = 105;
-		public const int Implements           = 106;
-		public const int Imports              = 107;
-		public const int In                   = 108;
-		public const int Inherits             = 109;
-		public const int Integer              = 110;
-		public const int Interface            = 111;
-		public const int Is                   = 112;
-		public const int Let                  = 113;
-		public const int Lib                  = 114;
-		public const int Like                 = 115;
-		public const int Long                 = 116;
-		public const int Loop                 = 117;
-		public const int Me                   = 118;
-		public const int Mod                  = 119;
-		public const int Module               = 120;
-		public const int MustInherit          = 121;
-		public const int MustOverride         = 122;
-		public const int MyBase               = 123;
-		public const int MyClass              = 124;
-		public const int Namespace            = 125;
-		public const int New                  = 126;
-		public const int Next                 = 127;
-		public const int Not                  = 128;
-		public const int Nothing              = 129;
-		public const int NotInheritable       = 130;
-		public const int NotOverridable       = 131;
-		public const int Object               = 132;
-		public const int Off                  = 133;
-		public const int On                   = 134;
-		public const int Option               = 135;
-		public const int Optional             = 136;
-		public const int Or                   = 137;
-		public const int OrElse               = 138;
-		public const int Overloads            = 139;
-		public const int Overridable          = 140;
-		public const int Override             = 141;
-		public const int Overrides            = 142;
-		public const int ParamArray           = 143;
-		public const int Preserve             = 144;
-		public const int Private              = 145;
-		public const int Property             = 146;
-		public const int Protected            = 147;
-		public const int Public               = 148;
-		public const int RaiseEvent           = 149;
-		public const int ReadOnly             = 150;
-		public const int ReDim                = 151;
-		public const int RemoveHandler        = 152;
-		public const int Resume               = 153;
-		public const int Return               = 154;
-		public const int Select               = 155;
-		public const int Set                  = 156;
-		public const int Shadows              = 157;
-		public const int Shared               = 158;
-		public const int Short                = 159;
-		public const int Single               = 160;
-		public const int Static               = 161;
-		public const int Step                 = 162;
-		public const int Stop                 = 163;
-		public const int Strict               = 164;
-		public const int String               = 165;
-		public const int Structure            = 166;
-		public const int Sub                  = 167;
-		public const int SyncLock             = 168;
-		public const int Text                 = 169;
-		public const int Then                 = 170;
-		public const int Throw                = 171;
-		public const int To                   = 172;
-		public const int True                 = 173;
-		public const int Try                  = 174;
-		public const int TypeOf               = 175;
-		public const int Unicode              = 176;
-		public const int Until                = 177;
-		public const int Variant              = 178;
-		public const int Wend                 = 179;
-		public const int When                 = 180;
-		public const int While                = 181;
-		public const int With                 = 182;
-		public const int WithEvents           = 183;
-		public const int WriteOnly            = 184;
-		public const int Xor                  = 185;
-		public const int Continue             = 186;
-		public const int Operator             = 187;
-		public const int Using                = 188;
-		public const int IsNot                = 189;
-		public const int SByte                = 190;
-		public const int UInteger             = 191;
-		public const int ULong                = 192;
-		public const int UShort               = 193;
-		public const int CSByte               = 194;
-		public const int CUShort              = 195;
-		public const int CUInt                = 196;
-		public const int CULng                = 197;
-		public const int Global               = 198;
-		public const int TryCast              = 199;
-		public const int Of                   = 200;
-		public const int Narrowing            = 201;
-		public const int Widening             = 202;
-		public const int Partial              = 203;
-		public const int Custom               = 204;
+		public const int AddHandler           = 42;
+		public const int AddressOf            = 43;
+		public const int Alias                = 44;
+		public const int And                  = 45;
+		public const int AndAlso              = 46;
+		public const int Ansi                 = 47;
+		public const int As                   = 48;
+		public const int Assembly             = 49;
+		public const int Auto                 = 50;
+		public const int Binary               = 51;
+		public const int Boolean              = 52;
+		public const int ByRef                = 53;
+		public const int Byte                 = 54;
+		public const int ByVal                = 55;
+		public const int Call                 = 56;
+		public const int Case                 = 57;
+		public const int Catch                = 58;
+		public const int CBool                = 59;
+		public const int CByte                = 60;
+		public const int CChar                = 61;
+		public const int CDate                = 62;
+		public const int CDbl                 = 63;
+		public const int CDec                 = 64;
+		public const int Char                 = 65;
+		public const int CInt                 = 66;
+		public const int Class                = 67;
+		public const int CLng                 = 68;
+		public const int CObj                 = 69;
+		public const int Compare              = 70;
+		public const int Const                = 71;
+		public const int CShort               = 72;
+		public const int CSng                 = 73;
+		public const int CStr                 = 74;
+		public const int CType                = 75;
+		public const int Date                 = 76;
+		public const int Decimal              = 77;
+		public const int Declare              = 78;
+		public const int Default              = 79;
+		public const int Delegate             = 80;
+		public const int Dim                  = 81;
+		public const int DirectCast           = 82;
+		public const int Do                   = 83;
+		public const int Double               = 84;
+		public const int Each                 = 85;
+		public const int Else                 = 86;
+		public const int ElseIf               = 87;
+		public const int End                  = 88;
+		public const int EndIf                = 89;
+		public const int Enum                 = 90;
+		public const int Erase                = 91;
+		public const int Error                = 92;
+		public const int Event                = 93;
+		public const int Exit                 = 94;
+		public const int Explicit             = 95;
+		public const int False                = 96;
+		public const int Finally              = 97;
+		public const int For                  = 98;
+		public const int Friend               = 99;
+		public const int Function             = 100;
+		public const int Get                  = 101;
+		new public const int GetType              = 102;
+		public const int GoSub                = 103;
+		public const int GoTo                 = 104;
+		public const int Handles              = 105;
+		public const int If                   = 106;
+		public const int Implements           = 107;
+		public const int Imports              = 108;
+		public const int In                   = 109;
+		public const int Inherits             = 110;
+		public const int Integer              = 111;
+		public const int Interface            = 112;
+		public const int Is                   = 113;
+		public const int Let                  = 114;
+		public const int Lib                  = 115;
+		public const int Like                 = 116;
+		public const int Long                 = 117;
+		public const int Loop                 = 118;
+		public const int Me                   = 119;
+		public const int Mod                  = 120;
+		public const int Module               = 121;
+		public const int MustInherit          = 122;
+		public const int MustOverride         = 123;
+		public const int MyBase               = 124;
+		public const int MyClass              = 125;
+		public const int Namespace            = 126;
+		public const int New                  = 127;
+		public const int Next                 = 128;
+		public const int Not                  = 129;
+		public const int Nothing              = 130;
+		public const int NotInheritable       = 131;
+		public const int NotOverridable       = 132;
+		public const int Object               = 133;
+		public const int Off                  = 134;
+		public const int On                   = 135;
+		public const int Option               = 136;
+		public const int Optional             = 137;
+		public const int Or                   = 138;
+		public const int OrElse               = 139;
+		public const int Overloads            = 140;
+		public const int Overridable          = 141;
+		public const int Override             = 142;
+		public const int Overrides            = 143;
+		public const int ParamArray           = 144;
+		public const int Preserve             = 145;
+		public const int Private              = 146;
+		public const int Property             = 147;
+		public const int Protected            = 148;
+		public const int Public               = 149;
+		public const int RaiseEvent           = 150;
+		public const int ReadOnly             = 151;
+		public const int ReDim                = 152;
+		public const int RemoveHandler        = 153;
+		public const int Resume               = 154;
+		public const int Return               = 155;
+		public const int Select               = 156;
+		public const int Set                  = 157;
+		public const int Shadows              = 158;
+		public const int Shared               = 159;
+		public const int Short                = 160;
+		public const int Single               = 161;
+		public const int Static               = 162;
+		public const int Step                 = 163;
+		public const int Stop                 = 164;
+		public const int Strict               = 165;
+		public const int String               = 166;
+		public const int Structure            = 167;
+		public const int Sub                  = 168;
+		public const int SyncLock             = 169;
+		public const int Text                 = 170;
+		public const int Then                 = 171;
+		public const int Throw                = 172;
+		public const int To                   = 173;
+		public const int True                 = 174;
+		public const int Try                  = 175;
+		public const int TypeOf               = 176;
+		public const int Unicode              = 177;
+		public const int Until                = 178;
+		public const int Variant              = 179;
+		public const int Wend                 = 180;
+		public const int When                 = 181;
+		public const int While                = 182;
+		public const int With                 = 183;
+		public const int WithEvents           = 184;
+		public const int WriteOnly            = 185;
+		public const int Xor                  = 186;
+		public const int Continue             = 187;
+		public const int Operator             = 188;
+		public const int Using                = 189;
+		public const int IsNot                = 190;
+		public const int SByte                = 191;
+		public const int UInteger             = 192;
+		public const int ULong                = 193;
+		public const int UShort               = 194;
+		public const int CSByte               = 195;
+		public const int CUShort              = 196;
+		public const int CUInt                = 197;
+		public const int CULng                = 198;
+		public const int Global               = 199;
+		public const int TryCast              = 200;
+		public const int Of                   = 201;
+		public const int Narrowing            = 202;
+		public const int Widening             = 203;
+		public const int Partial              = 204;
+		public const int Custom               = 205;
 
-		public const int maxToken = 205;
+		public const int maxToken = 206;
 		static BitArray NewSet(params int[] values)
 		{
 			BitArray bitArray = new BitArray(maxToken);
@@ -253,6 +254,7 @@ namespace ICSharpCode.NRefactory.Parser.VB
 			"\\",
 			"&",
 			"^",
+			"?",
 			"{",
 			"}",
 			"(",

src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG

@@ -283,6 +283,7 @@ TOKENS
 	"\\"
 	"&"
 	"^"
+	"?"
 	"{"
 	"}"
 	"("

src/Libraries/NRefactory/Test/Lexer/VBNet/LexerTests.cs

@@ -99,6 +99,13 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.VB
 			Assert.AreEqual(Tokens.Power, lexer.NextToken().kind);
 		}
 
+		[Test]
+		public void TestQuestionMark()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("?"));
+			Assert.AreEqual(Tokens.QuestionMark, lexer.NextToken().kind);
+		}
+
 		[Test]
 		public void TestOpenCurlyBrace()
 		{

src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs

@@ -244,7 +244,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			
 			if (expr is PrimitiveExpression) {
 				if (((PrimitiveExpression)expr).Value is int)
-					return null;
+					return new IntegerLiteralResolveResult(callingClass, callingMember);
 			} else if (expr is InvocationExpression) {
 				IMethod method = typeVisitor.GetMethod(expr as InvocationExpression, null);
 				if (method != null) {
@@ -325,7 +325,8 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 						return CreateMemberResolveResult(Constructor.CreateDefault(c));
 					}
 				}
-				return CreateMemberResolveResult(typeVisitor.FindOverload(constructors, null, ((ObjectCreateExpression)expr).Parameters, null));
+				IReturnType[] typeParameters = null; // TODO: get constructor type parameters
+				return CreateMemberResolveResult(typeVisitor.FindOverload(constructors, typeParameters, ((ObjectCreateExpression)expr).Parameters, null));
 			}
 			return new ResolveResult(callingClass, callingMember, type);
 		}

src/Main/Base/Project/Src/Dom/ResolveResult.cs

@@ -270,6 +270,26 @@ namespace ICSharpCode.SharpDevelop.Dom
 	}
 	#endregion
 	
+	#region IntegerLiteralResolveResult
+	/// <summary>
+	/// The IntegerLiteralResolveResult is used when an expression was an integer literal.
+	/// It is a normal ResolveResult with a type of "int", but does not provide
+	/// any code completion data.
+	/// </summary>
+	public class IntegerLiteralResolveResult : ResolveResult
+	{
+		public IntegerLiteralResolveResult(IClass callingClass, IMember callingMember)
+			: base(callingClass, callingMember, ReflectionReturnType.Int)
+		{
+		}
+		
+		public override ArrayList GetCompletionData(IProjectContent projectContent)
+		{
+			return null;
+		}
+	}
+	#endregion
+	
 	#region TypeResolveResult
 	/// <summary>
 	/// The TypeResolveResult is used when an expression was the name of a type.