Flesh out classification.

src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/RegexPatternTokenClassifier.cs

@@ -49,12 +49,254 @@ public override void AddClassifications(SyntaxToken token, SemanticModel semanti
             }
 
             var tree = RegexParser.Parse(chars, options);
-            AddClassifications(tree, result);
+            var visitor = new Visitor(result);
+            AddClassifications(tree.Root, visitor, result);
         }
 
-        private void AddClassifications(RegexTree tree, ArrayBuilder<ClassifiedSpan> result)
+        private void AddClassifications(RegexNode node, Visitor visitor, ArrayBuilder<ClassifiedSpan> result)
         {
-            throw new NotImplementedException();
+            node.Accept(visitor);
+
+            for (int i = 0, n = node.ChildCount; i < n; i++)
+            {
+                var child = node.ChildAt(i);
+                if (child.IsNode)
+                {
+                    AddClassifications(child.Node, visitor, result);
+                }
+                else
+                {
+                    AddTriviaClassifications(child.Token, result);
+                }
+            }
+        }
+
+        private void AddTriviaClassifications(RegexToken token, ArrayBuilder<ClassifiedSpan> result)
+        {
+            foreach (var trivia in token.LeadingTrivia)
+            {
+                AddTriviaClassifications(trivia, result);
+            }
+        }
+
+        private void AddTriviaClassifications(RegexTrivia trivia, ArrayBuilder<ClassifiedSpan> result)
+        {
+            if (trivia.Kind == RegexKind.CommentTrivia &&
+                trivia.VirtualChars.Length > 0)
+            {
+                result.Add(new ClassifiedSpan(
+                    ClassificationTypeNames.Comment, RegexHelpers.GetSpan(trivia.VirtualChars)));
+            }
+        }
+
+        private class Visitor : IRegexNodeVisitor
+        {
+            private readonly ArrayBuilder<ClassifiedSpan> _result;
+
+            public Visitor(ArrayBuilder<ClassifiedSpan> result)
+            {
+                _result = result;
+            }
+
+            public void Visit(RegexCompilationUnit node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexSequenceNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexTextNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexCharacterClassNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexNegatedCharacterClassNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexCharacterClassRangeNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexCharacterClassSubtractionNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexPosixPropertyNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexWildcardNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexZeroOrMoreQuantifierNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexOneOrMoreQuantifierNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexZeroOrOneQuantifierNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexLazyQuantifierNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexExactNumericQuantifierNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexOpenNumericRangeQuantifierNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexClosedNumericRangeQuantifierNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexAnchorNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexAlternationNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexSimpleGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexSimpleOptionsGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexNestedOptionsGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexNonCapturingGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexPositiveLookaheadGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexNegativeLookaheadGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexPositiveLookbehindGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexNegativeLookbehindGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexNonBacktrackingGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexCaptureGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexBalancingGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexConditionalCaptureGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexConditionalExpressionGroupingNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexSimpleEscapeNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexControlEscapeNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexHexEscapeNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexUnicodeEscapeNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexCaptureEscapeNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexKCaptureEscapeNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexOctalEscapeNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexBackreferenceEscapeNode node)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Visit(RegexCategoryEscapeNode node)
+            {
+                throw new NotImplementedException();
+            }
         }
     }
 }

src/Workspaces/Core/Portable/RegularExpressions/IRegexNodeVisitor.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+
+namespace Microsoft.CodeAnalysis.RegularExpressions
+{
+    internal interface IRegexNodeVisitor
+    {
+        void Visit(RegexCompilationUnit node);
+        void Visit(RegexSequenceNode node);
+        void Visit(RegexTextNode node);
+        void Visit(RegexCharacterClassNode node);
+        void Visit(RegexNegatedCharacterClassNode node);
+        void Visit(RegexCharacterClassRangeNode node);
+        void Visit(RegexCharacterClassSubtractionNode node);
+        void Visit(RegexPosixPropertyNode node);
+        void Visit(RegexWildcardNode node);
+        void Visit(RegexZeroOrMoreQuantifierNode node);
+        void Visit(RegexOneOrMoreQuantifierNode node);
+        void Visit(RegexZeroOrOneQuantifierNode node);
+        void Visit(RegexLazyQuantifierNode node);
+        void Visit(RegexExactNumericQuantifierNode node);
+        void Visit(RegexOpenNumericRangeQuantifierNode node);
+        void Visit(RegexClosedNumericRangeQuantifierNode node);
+        void Visit(RegexAnchorNode node);
+        void Visit(RegexAlternationNode node);
+        void Visit(RegexSimpleGroupingNode node);
+        void Visit(RegexSimpleOptionsGroupingNode node);
+        void Visit(RegexNestedOptionsGroupingNode node);
+        void Visit(RegexNonCapturingGroupingNode node);
+        void Visit(RegexPositiveLookaheadGroupingNode node);
+        void Visit(RegexNegativeLookaheadGroupingNode node);
+        void Visit(RegexPositiveLookbehindGroupingNode node);
+        void Visit(RegexNegativeLookbehindGroupingNode node);
+        void Visit(RegexNonBacktrackingGroupingNode node);
+        void Visit(RegexCaptureGroupingNode node);
+        void Visit(RegexBalancingGroupingNode node);
+        void Visit(RegexConditionalCaptureGroupingNode node);
+        void Visit(RegexConditionalExpressionGroupingNode node);
+        void Visit(RegexSimpleEscapeNode node);
+        void Visit(RegexControlEscapeNode node);
+        void Visit(RegexHexEscapeNode node);
+        void Visit(RegexUnicodeEscapeNode node);
+        void Visit(RegexCaptureEscapeNode node);
+        void Visit(RegexKCaptureEscapeNode node);
+        void Visit(RegexOctalEscapeNode node);
+        void Visit(RegexBackreferenceEscapeNode node);
+        void Visit(RegexCategoryEscapeNode node);
+    }
+}

src/Workspaces/Core/Portable/RegularExpressions/RegexNode.cs

@@ -16,5 +16,7 @@ protected RegexNode(RegexKind kind)
 
         public abstract int ChildCount { get; }
         public abstract RegexNodeOrToken ChildAt(int index);
+
+        public abstract void Accept(IRegexNodeVisitor visitor);
     }
 }

src/Workspaces/Core/Portable/RegularExpressions/RegexNodes.cs

@@ -32,6 +32,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -59,6 +62,9 @@ public RegexSequenceNode(ImmutableArray<RegexExpressionNode> children)
 
         public override RegexNodeOrToken ChildAt(int index)
             => Children[index];
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -78,6 +84,9 @@ public RegexTextNode(RegexToken textToken)
         public override int ChildCount => 1;
 
         public override RegexNodeOrToken ChildAt(int index) => TextToken;
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -126,6 +135,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -157,6 +169,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -193,6 +208,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -227,6 +245,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -248,6 +269,9 @@ public RegexPosixPropertyNode(RegexToken textToken)
         public override int ChildCount => 1;
 
         public override RegexNodeOrToken ChildAt(int index) => TextToken;
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -289,6 +313,9 @@ public RegexWildcardNode(RegexToken dotToken)
         public override int ChildCount => 1;
 
         public override RegexNodeOrToken ChildAt(int index) => DotToken;
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -332,6 +359,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -364,6 +394,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -396,6 +429,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -430,6 +466,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -482,6 +521,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -516,6 +558,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -554,6 +599,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -573,6 +621,9 @@ public RegexAnchorNode(RegexKind kind, RegexToken anchorToken)
         public override int ChildCount => 1;
 
         public override RegexNodeOrToken ChildAt(int index) => AnchorToken;
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -609,6 +660,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -656,6 +710,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -712,6 +769,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -749,6 +809,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -785,6 +848,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -821,6 +887,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -857,6 +926,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     internal abstract class RegexLookbehindGroupingNode : RegexQuestionGroupingNode
@@ -908,6 +980,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -945,6 +1020,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -981,6 +1059,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1023,6 +1104,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1072,6 +1156,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     internal abstract class RegexConditionalGroupingNode : RegexQuestionGroupingNode
@@ -1127,6 +1214,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1161,6 +1251,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1213,6 +1306,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1241,6 +1337,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1269,6 +1368,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1297,6 +1399,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1331,7 +1436,11 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
+
     /// <summary>
     /// ```\k'name'``` or ```\k&lt;name&gt;``` escape.
     /// </summary>
@@ -1366,6 +1475,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1393,6 +1505,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1420,6 +1535,9 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 
     /// <summary>
@@ -1459,5 +1577,8 @@ public override RegexNodeOrToken ChildAt(int index)
 
             throw new InvalidOperationException();
         }
+
+        public override void Accept(IRegexNodeVisitor visitor)
+            => visitor.Visit(this);
     }
 }