Merge pull request #4760 from MDoerner/CureBangNotationParsing

Fix bang notation in the SLL mode for the most common case

Author: retailcoder

Rubberduck.Parsing/Grammar/VBAParser.g4

@@ -579,7 +579,15 @@ 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;
-identifier : typedIdentifier | untypedIdentifier;
+//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 or opening 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. So, an assumption 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 untyped 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;
 typedIdentifier : untypedIdentifier typeHint;
 identifierValue : IDENTIFIER | keyword | foreignName;

RubberduckTests/Grammar/VBAParserTests.cs

@@ -2953,6 +2953,101 @@ End Sub
             var parseResult = Parse(code);
         }
 
+        [Category("Parser")]
+        [Test]
+        public void ParserDoesNotFailDoubleBracketForgeignIdentifierWithTypeHint()
+        {
+            const string code = @"
+Sub Test()  
+Dim x
+x = [[bar]]!
+x = [bar]!
+End Sub
+";
+            var parseResult = Parse(code);
+            AssertTree(parseResult.Item1, parseResult.Item2, "//typeHint", matches => matches.Count == 2);
+        }
+
+        [Category("Parser")]
+        [Test]
+        public void ParserDoesNotFailOnBangOperatorFollowedByForeignIdentifier()
+        {
+            const string code = @"
+Sub Test()   
+Dim dict As Scripting.Dictionary
+
+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 ParserDoesNotFailOnBangOperator()
+        {
+            const string code = @"
+Sub Test()   
+Dim dict As Scripting.Dictionary
+
+Dim x
+x = dict!a
+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")]
         [Test]
         public void ParserDoesNotFailOnLineContinuedBangOperator1()