Add explanation for predicate in identifier parser rule

Also adds some more tests.

Author: MDoerner

Rubberduck.Parsing/Grammar/VBAParser.g4

@@ -579,6 +579,13 @@ subscript : (expression whiteSpace TO whiteSpace)? expression;
 
 unrestrictedIdentifier : identifier | statementKeyword | markerKeyword;
 legalLabelIdentifier : { !(new[]{DOEVENTS,END,CLOSE,ELSE,LOOP,NEXT,RANDOMIZE,REM,RESUME,RETURN,STOP,WEND}).Contains(_input.La(1))}? identifier | markerKeyword;
+//The predicate in the following rule has been introduced to lessen the problem that VBA uses the same characters used as type hints in other syntactical constructs, 
+//e.g. in the bang notation (see withDictionaryAccessExpr). Generally, it is not legal to have an identifier of openeing bracket follow immediately after a type hint.
+//The first part of the predicate tries to exclude these two situations. Unfortunately, predicates have to be at the start of a rule. S, an assumprion about the number 
+//of tokens in the identifier is made. All untypedIdentifers not a foreignNames consist of exactly one token and a typedIdentifier is an untypes one followed by a typeHint,
+//again a single token. So, in the majority of situations, the third token is the token following the potential type hint. 
+//For foreignNames, no assumption can be made because they consist of a pair of brackets containing arbitrarily many tokens. 
+//That is why the second part of the predicate looks at the first character in order to determine whether the identifier is a foreignName. 
 identifier : {_input.La(3) != IDENTIFIER && _input.La(3) != L_SQUARE_BRACKET || _input.La(1) == L_SQUARE_BRACKET}? typedIdentifier 
              | untypedIdentifier;
 untypedIdentifier : identifierValue;

RubberduckTests/Grammar/VBAParserTests.cs

@@ -2961,10 +2961,11 @@ public void ParserDoesNotFailDoubleBracketForgeignIdentifierWithTypeHint()
 Sub Test()  
 Dim x
 x = [[bar]]!
+x = [bar]!
 End Sub
 ";
             var parseResult = Parse(code);
-            AssertTree(parseResult.Item1, parseResult.Item2, "//typeHint", matches => matches.Count == 1);
+            AssertTree(parseResult.Item1, parseResult.Item2, "//typeHint", matches => matches.Count == 2);
         }
 
         [Category("Parser")]
@@ -2980,6 +2981,7 @@ Dim x
 End Sub
 ";
             var parseResult = Parse(code);
+            AssertTree(parseResult.Item1, parseResult.Item2, "//typeHint", matches => matches.Count == 0);
         }
 
         [Category("Parser")]
@@ -2995,6 +2997,55 @@ Dim x
 End Sub
 ";
             var parseResult = Parse(code);
+            AssertTree(parseResult.Item1, parseResult.Item2, "//typeHint", matches => matches.Count == 0);
+        }
+
+        [Category("Parser")]
+        [Test]
+        [Ignore("This cannot work with the current setup of identifiers bacause the SLL parser confuses the bang for a type hint.")]
+        public void ParserDoesNotFailOnBangOperatorOnForeignIdentifier()
+        {
+            const string code = @"
+Sub Test()   
+Dim x
+x = [dict]!a
+End Sub
+";
+            var parseResult = Parse(code);
+            AssertTree(parseResult.Item1, parseResult.Item2, "//typeHint", matches => matches.Count == 0);
+        }
+
+        [Category("Parser")]
+        [Test]
+        public void ParserDoesNotFailOnStackedBangOperator()
+        {
+            const string code = @"
+Sub Test()   
+Dim dict As Scripting.Dictionary
+
+Dim x
+x = dict!a!b!c
+End Sub
+";
+            var parseResult = Parse(code);
+            AssertTree(parseResult.Item1, parseResult.Item2, "//typeHint", matches => matches.Count == 0);
+        }
+
+        [Category("Parser")]
+        [Test]
+        [Ignore("This cannot work with the current setup of identifiers bacause the SLL parser confuses the bang for a type hint.")]
+        public void ParserDoesNotFailOnStackedBangOperator_ForeignIdentifier()
+        {
+            const string code = @"
+Sub Test()   
+Dim dict As Scripting.Dictionary
+
+Dim x
+x = dict![a]!b!c
+End Sub
+";
+            var parseResult = Parse(code);
+            AssertTree(parseResult.Item1, parseResult.Item2, "//typeHint", matches => matches.Count == 0);
         }
 
         [Category("Parser")]