Add SemanticHighlight Endpoint

src/OmniSharp.Abstractions/Models/v2/SemanticHighlight/SemanticHighlightClassification.cs

@@ -0,0 +1,72 @@
+namespace OmniSharp.Models.SemanticHighlight
+{
+    // Enum of the names defined Roslyn's ClassificationTypeNames.
+    public enum SemanticHighlightClassification
+    {
+        Comment,
+        ExcludedCode,
+        Identifier,
+        Keyword,
+        ControlKeyword,
+        NumericLiteral,
+        Operator,
+        OperatorOverloaded,
+        PreprocessorKeyword,
+        StringLiteral,
+        WhiteSpace,
+        Text,
+        StaticSymbol,
+        PreprocessorText,
+        Punctuation,
+        VerbatimStringLiteral,
+        StringEscapeCharacter,
+        ClassName,
+        DelegateName,
+        EnumName,
+        InterfaceName,
+        ModuleName,
+        StructName,
+        TypeParameterName,
+        FieldName,
+        EnumMemberName,
+        ConstantName,
+        LocalName,
+        ParameterName,
+        MethodName,
+        ExtensionMethodName,
+        PropertyName,
+        EventName,
+        NamespaceName,
+        LabelName,
+        XmlDocCommentAttributeName,
+        XmlDocCommentAttributeQuotes,
+        XmlDocCommentAttributeValue,
+        XmlDocCommentCDataSection,
+        XmlDocCommentComment,
+        XmlDocCommentDelimiter,
+        XmlDocCommentEntityReference,
+        XmlDocCommentName,
+        XmlDocCommentProcessingInstruction,
+        XmlDocCommentText,
+        XmlLiteralAttributeName,
+        XmlLiteralAttributeQuotes,
+        XmlLiteralAttributeValue,
+        XmlLiteralCDataSection,
+        XmlLiteralComment,
+        XmlLiteralDelimiter,
+        XmlLiteralEmbeddedExpression,
+        XmlLiteralEntityReference,
+        XmlLiteralName,
+        XmlLiteralProcessingInstruction,
+        XmlLiteralText,
+        RegexComment,
+        RegexCharacterClass,
+        RegexAnchor,
+        RegexQuantifier,
+        RegexGrouping,
+        RegexAlternation,
+        RegexText,
+        RegexSelfEscapedCharacter,
+        RegexOtherEscape,
+    }
+}

src/OmniSharp.Abstractions/Models/v2/SemanticHighlight/SemanticHighlightModifier.cs

@@ -0,0 +1,7 @@
+namespace OmniSharp.Models.SemanticHighlight
+{
+    public enum SemanticHighlightModifier
+    {
+        Static
+    }
+}

src/OmniSharp.Abstractions/Models/v2/SemanticHighlight/SemanticHighlightRequest.cs

@@ -0,0 +1,16 @@
+using OmniSharp.Mef;
+using OmniSharp.Models.V2;
+
+namespace OmniSharp.Models.SemanticHighlight
+{
+    [OmniSharpEndpoint(OmniSharpEndpoints.V2.Highlight, typeof(SemanticHighlightRequest), typeof(SemanticHighlightResponse))]
+    public class SemanticHighlightRequest : Request
+    {
+        /// <summary>
+        ///   Specifies the range to highlight.
+        ///   If none is given, highlight the entire
+        ///   file.
+        /// </summary>
+        public Range Range { get; set; }
+    }
+}

src/OmniSharp.Abstractions/Models/v2/SemanticHighlight/SemanticHighlightResponse.cs

@@ -0,0 +1,7 @@
+namespace OmniSharp.Models.SemanticHighlight
+{
+    public class SemanticHighlightResponse
+    {
+        public SemanticHighlightSpan[] Spans { get; set; }
+    }
+}

src/OmniSharp.Abstractions/Models/v2/SemanticHighlight/SemanticHighlightSpan.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace OmniSharp.Models.SemanticHighlight
+{
+    public class SemanticHighlightSpan : IComparable<SemanticHighlightSpan>
+    {
+        [JsonConverter(typeof(ZeroBasedIndexConverter))]
+        public int StartLine { get; set; }
+        [JsonConverter(typeof(ZeroBasedIndexConverter))]
+        public int StartColumn { get; set; }
+        [JsonConverter(typeof(ZeroBasedIndexConverter))]
+        public int EndLine { get; set; }
+        [JsonConverter(typeof(ZeroBasedIndexConverter))]
+        public int EndColumn { get; set; }
+        public SemanticHighlightClassification Type { get; set; }
+        public IEnumerable<SemanticHighlightModifier> Modifiers { get; set; }
+
+        public int CompareTo(SemanticHighlightSpan other)
+        {
+            if (other.StartLine < StartLine)
+            {
+                return 1;
+            }
+            else if (other.StartLine > StartLine)
+            {
+                return -1;
+            }
+            // same start line
+            else if (other.StartColumn < StartColumn)
+            {
+                return 1;
+            }
+            else if (other.StartColumn > StartColumn)
+            {
+                return -1;
+            }
+            // same start line and start column
+            else if (other.EndLine < EndLine)
+            {
+                return 1;
+            }
+            else if (other.EndLine > EndLine)
+            {
+                return -1;
+            }
+            // same start line, start column, and end line
+            else if (other.EndColumn < EndColumn)
+            {
+                return 1;
+            }
+            else if (other.EndColumn > EndColumn)
+            {
+                return -1;
+            }
+            // same, same
+            else
+            {
+                return 0;
+            }
+        }
+
+        public override bool Equals(object other)
+        {
+            var node = other as SemanticHighlightSpan;
+            return node != null
+                && node.StartLine == StartLine
+                && node.StartColumn == StartColumn
+                && node.EndLine == EndLine
+                && node.EndColumn == EndColumn;
+        }
+
+        public override int GetHashCode()
+        {
+            return 13 * StartLine +
+                17 * StartColumn +
+                23 * EndLine +
+                31 * EndColumn;
+        }
+    }
+}

src/OmniSharp.Abstractions/OmniSharpEndpoints.cs

@@ -60,6 +60,8 @@ public static class V2
 
             public const string BlockStructure = "/v2/blockstructure";
             public const string CodeStructure = "/v2/codestructure";
+
+            public const string Highlight = "/v2/highlight";
         }
     }
 }

src/OmniSharp.Roslyn.CSharp/Services/SemanticHighlight/SemanticHighlightService.cs

@@ -0,0 +1,167 @@
+using System.Collections.Generic;
+using System.Composition;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Text;
+using OmniSharp.Mef;
+using OmniSharp.Models.SemanticHighlight;
+
+namespace OmniSharp.Roslyn.CSharp.Services.SemanticHighlight
+{
+    [OmniSharpHandler(OmniSharpEndpoints.V2.Highlight, LanguageNames.CSharp)]
+    public class SemanticHighlightService : IRequestHandler<SemanticHighlightRequest, SemanticHighlightResponse>
+    {
+        [ImportingConstructor]
+        public SemanticHighlightService(OmniSharpWorkspace workspace)
+        {
+            _workspace = workspace;
+        }
+
+        public async Task<SemanticHighlightResponse> Handle(SemanticHighlightRequest request)
+        {
+            var documents = _workspace.GetDocuments(request.FileName);
+
+            var results = new List<ClassifiedResult>();
+
+            foreach (var document in documents)
+            {
+                var project = document.Project.Name;
+                var text = await document.GetTextAsync();
+
+                TextSpan textSpan;
+                if (request.Range is object)
+                {
+                    var start = text.Lines.GetPosition(new LinePosition(request.Range.Start.Line, request.Range.Start.Column));
+                    var end = text.Lines.GetPosition(new LinePosition(request.Range.End.Line, request.Range.End.Column));
+                    textSpan = new TextSpan(start, end - start);
+                }
+                else
+                {
+                    textSpan = new TextSpan(0, text.Length);
+                }
+
+                results.AddRange((await Classifier.GetClassifiedSpansAsync(document, textSpan))
+                    .Select(span => new ClassifiedResult()
+                    {
+                        Span = span,
+                        Lines = text.Lines,
+                    }));
+            }
+
+            return new SemanticHighlightResponse()
+            {
+                Spans = results
+                    .GroupBy(result => result.Span.TextSpan.ToString())
+                    .Select(grouping => CreateSemanticSpan(grouping, grouping.First().Lines))
+                    .ToArray()
+            };
+        }
+
+        private static SemanticHighlightSpan CreateSemanticSpan(IEnumerable<ClassifiedResult> results, TextLineCollection lines)
+        {
+            var additiveResults = results.Where(result => ClassificationTypeNames.AdditiveTypeNames.Contains(result.Span.ClassificationType));
+            var modifiers = additiveResults.Select(result => _modifierMap[result.Span.ClassificationType]).ToArray();
+
+            var result = results.Except(additiveResults).Single();
+            var span = result.Span;
+
+            var linePos = lines.GetLinePositionSpan(span.TextSpan);
+
+            return new SemanticHighlightSpan
+            {
+                StartLine = linePos.Start.Line,
+                EndLine = linePos.End.Line,
+                StartColumn = linePos.Start.Character,
+                EndColumn = linePos.End.Character,
+                Type = _classificationMap[span.ClassificationType],
+                Modifiers = modifiers
+            };
+        }
+
+        class ClassifiedResult
+        {
+            public ClassifiedSpan Span { get; set; }
+            public TextLineCollection Lines { get; set; }
+        }
+
+        private static readonly Dictionary<string, SemanticHighlightClassification> _classificationMap =
+            new Dictionary<string, SemanticHighlightClassification>
+            {
+                [ClassificationTypeNames.Comment] = SemanticHighlightClassification.Comment,
+                [ClassificationTypeNames.ExcludedCode] = SemanticHighlightClassification.ExcludedCode,
+                [ClassificationTypeNames.Identifier] = SemanticHighlightClassification.Identifier,
+                [ClassificationTypeNames.Keyword] = SemanticHighlightClassification.Keyword,
+                [ClassificationTypeNames.ControlKeyword] = SemanticHighlightClassification.ControlKeyword,
+                [ClassificationTypeNames.NumericLiteral] = SemanticHighlightClassification.NumericLiteral,
+                [ClassificationTypeNames.Operator] = SemanticHighlightClassification.Operator,
+                [ClassificationTypeNames.OperatorOverloaded] = SemanticHighlightClassification.OperatorOverloaded,
+                [ClassificationTypeNames.PreprocessorKeyword] = SemanticHighlightClassification.PreprocessorKeyword,
+                [ClassificationTypeNames.StringLiteral] = SemanticHighlightClassification.StringLiteral,
+                [ClassificationTypeNames.WhiteSpace] = SemanticHighlightClassification.WhiteSpace,
+                [ClassificationTypeNames.Text] = SemanticHighlightClassification.Text,
+                [ClassificationTypeNames.StaticSymbol] = SemanticHighlightClassification.StaticSymbol,
+                [ClassificationTypeNames.PreprocessorText] = SemanticHighlightClassification.PreprocessorText,
+                [ClassificationTypeNames.Punctuation] = SemanticHighlightClassification.Punctuation,
+                [ClassificationTypeNames.VerbatimStringLiteral] = SemanticHighlightClassification.VerbatimStringLiteral,
+                [ClassificationTypeNames.StringEscapeCharacter] = SemanticHighlightClassification.StringEscapeCharacter,
+                [ClassificationTypeNames.ClassName] = SemanticHighlightClassification.ClassName,
+                [ClassificationTypeNames.DelegateName] = SemanticHighlightClassification.DelegateName,
+                [ClassificationTypeNames.EnumName] = SemanticHighlightClassification.EnumName,
+                [ClassificationTypeNames.InterfaceName] = SemanticHighlightClassification.InterfaceName,
+                [ClassificationTypeNames.ModuleName] = SemanticHighlightClassification.ModuleName,
+                [ClassificationTypeNames.StructName] = SemanticHighlightClassification.StructName,
+                [ClassificationTypeNames.TypeParameterName] = SemanticHighlightClassification.TypeParameterName,
+                [ClassificationTypeNames.FieldName] = SemanticHighlightClassification.FieldName,
+                [ClassificationTypeNames.EnumMemberName] = SemanticHighlightClassification.EnumMemberName,
+                [ClassificationTypeNames.ConstantName] = SemanticHighlightClassification.ConstantName,
+                [ClassificationTypeNames.LocalName] = SemanticHighlightClassification.LocalName,
+                [ClassificationTypeNames.ParameterName] = SemanticHighlightClassification.ParameterName,
+                [ClassificationTypeNames.MethodName] = SemanticHighlightClassification.MethodName,
+                [ClassificationTypeNames.ExtensionMethodName] = SemanticHighlightClassification.ExtensionMethodName,
+                [ClassificationTypeNames.PropertyName] = SemanticHighlightClassification.PropertyName,
+                [ClassificationTypeNames.EventName] = SemanticHighlightClassification.EventName,
+                [ClassificationTypeNames.NamespaceName] = SemanticHighlightClassification.NamespaceName,
+                [ClassificationTypeNames.LabelName] = SemanticHighlightClassification.LabelName,
+                [ClassificationTypeNames.XmlDocCommentAttributeName] = SemanticHighlightClassification.XmlDocCommentAttributeName,
+                [ClassificationTypeNames.XmlDocCommentAttributeQuotes] = SemanticHighlightClassification.XmlDocCommentAttributeQuotes,
+                [ClassificationTypeNames.XmlDocCommentAttributeValue] = SemanticHighlightClassification.XmlDocCommentAttributeValue,
+                [ClassificationTypeNames.XmlDocCommentCDataSection] = SemanticHighlightClassification.XmlDocCommentCDataSection,
+                [ClassificationTypeNames.XmlDocCommentComment] = SemanticHighlightClassification.XmlDocCommentComment,
+                [ClassificationTypeNames.XmlDocCommentDelimiter] = SemanticHighlightClassification.XmlDocCommentDelimiter,
+                [ClassificationTypeNames.XmlDocCommentEntityReference] = SemanticHighlightClassification.XmlDocCommentEntityReference,
+                [ClassificationTypeNames.XmlDocCommentName] = SemanticHighlightClassification.XmlDocCommentName,
+                [ClassificationTypeNames.XmlDocCommentProcessingInstruction] = SemanticHighlightClassification.XmlDocCommentProcessingInstruction,
+                [ClassificationTypeNames.XmlDocCommentText] = SemanticHighlightClassification.XmlDocCommentText,
+                [ClassificationTypeNames.XmlLiteralAttributeName] = SemanticHighlightClassification.XmlLiteralAttributeName,
+                [ClassificationTypeNames.XmlLiteralAttributeQuotes] = SemanticHighlightClassification.XmlLiteralAttributeQuotes,
+                [ClassificationTypeNames.XmlLiteralAttributeValue] = SemanticHighlightClassification.XmlLiteralAttributeValue,
+                [ClassificationTypeNames.XmlLiteralCDataSection] = SemanticHighlightClassification.XmlLiteralCDataSection,
+                [ClassificationTypeNames.XmlLiteralComment] = SemanticHighlightClassification.XmlLiteralComment,
+                [ClassificationTypeNames.XmlLiteralDelimiter] = SemanticHighlightClassification.XmlLiteralDelimiter,
+                [ClassificationTypeNames.XmlLiteralEmbeddedExpression] = SemanticHighlightClassification.XmlLiteralEmbeddedExpression,
+                [ClassificationTypeNames.XmlLiteralEntityReference] = SemanticHighlightClassification.XmlLiteralEntityReference,
+                [ClassificationTypeNames.XmlLiteralName] = SemanticHighlightClassification.XmlLiteralName,
+                [ClassificationTypeNames.XmlLiteralProcessingInstruction] = SemanticHighlightClassification.XmlLiteralProcessingInstruction,
+                [ClassificationTypeNames.XmlLiteralText] = SemanticHighlightClassification.XmlLiteralText,
+                [ClassificationTypeNames.RegexComment] = SemanticHighlightClassification.RegexComment,
+                [ClassificationTypeNames.RegexCharacterClass] = SemanticHighlightClassification.RegexCharacterClass,
+                [ClassificationTypeNames.RegexAnchor] = SemanticHighlightClassification.RegexAnchor,
+                [ClassificationTypeNames.RegexQuantifier] = SemanticHighlightClassification.RegexQuantifier,
+                [ClassificationTypeNames.RegexGrouping] = SemanticHighlightClassification.RegexGrouping,
+                [ClassificationTypeNames.RegexAlternation] = SemanticHighlightClassification.RegexAlternation,
+                [ClassificationTypeNames.RegexText] = SemanticHighlightClassification.RegexText,
+                [ClassificationTypeNames.RegexSelfEscapedCharacter] = SemanticHighlightClassification.RegexSelfEscapedCharacter,
+                [ClassificationTypeNames.RegexOtherEscape] = SemanticHighlightClassification.RegexOtherEscape,
+            };
+
+        private static readonly Dictionary<string, SemanticHighlightModifier> _modifierMap =
+            new Dictionary<string, SemanticHighlightModifier>
+            {
+                [ClassificationTypeNames.StaticSymbol] = SemanticHighlightModifier.Static,
+            };
+
+        private readonly OmniSharpWorkspace _workspace;
+    }
+}