Q:

Visual Studio MEF & Irony: No syntax highlighting

My ITagger<IClassificationTag> is generating tags, however, Visual Studio is not showing the syntax coloring.
Here is the code for ITagger<IClassificationTag>:
[Export(typeof(ITaggerProvider))]
    [ContentType("FDL")]
    [TagType(typeof(ClassificationTag))]
    internal sealed class FDLClassifierProvider : ITaggerProvider
    {

        [Export]
        [Name("FDL")]
        [BaseDefinition("code")]
        internal static ContentTypeDefinition FDLContentType = null;

        [Export]
        [FileExtension(".fdl")]
        [ContentType("FDL")]
        internal static FileExtensionToContentTypeDefinition FDLFileType = null;

        [Import]
        internal IClassificationTypeRegistryService ClassificationTypeRegistry = null;

        [Import]
        internal IBufferTagAggregatorFactoryService aggregatorFactory = null;

        public ITagger<T> CreateTagger<T>(ITextBuffer buffer) where T : ITag
        {
            return new FDLClassifier(buffer, ClassificationTypeRegistry) as ITagger<T>;
        }
    }

    /// <summary>
    /// This is effectively the replacement to the LineScanner from 2008.
    /// This class must handle very quick processing times during GetTags() 
    /// as it is called very frequently!
    /// </summary>
    internal sealed class FDLClassifier : ITagger<ClassificationTag>
    {
        ITextBuffer _buffer;
        Grammar _grammar;
        Irony.Parsing.Parser _parser;

        IDictionary<Irony.Parsing.TokenType, ClassificationTag> _fdlTags;
        ClassificationTag _commentTag;

        public event EventHandler<SnapshotSpanEventArgs> TagsChanged;

        Dictionary<int, int> _lineStates = new Dictionary<int, int>();

        internal FDLClassifier(ITextBuffer buffer,
                               IClassificationTypeRegistryService typeService)
        {
            _buffer = buffer;

            _grammar = new Grammar();
            _parser = new Irony.Parsing.Parser(_grammar);
            _parser.Context.Mode = Irony.Parsing.ParseMode.VsLineScan;

            _fdlTags = new Dictionary<Irony.Parsing.TokenType, ClassificationTag>();
            _fdlTags[Irony.Parsing.TokenType.Text] = BuildTag(typeService, PredefinedClassificationTypeNames.Character);
            _fdlTags[Irony.Parsing.TokenType.Keyword] = BuildTag(typeService, PredefinedClassificationTypeNames.Keyword);
            _fdlTags[Irony.Parsing.TokenType.Identifier] = BuildTag(typeService, PredefinedClassificationTypeNames.Identifier);
            _fdlTags[Irony.Parsing.TokenType.String] = BuildTag(typeService, PredefinedClassificationTypeNames.String);
            _fdlTags[Irony.Parsing.TokenType.Literal] = BuildTag(typeService, PredefinedClassificationTypeNames.Literal);
            _fdlTags[Irony.Parsing.TokenType.Operator] = BuildTag(typeService, PredefinedClassificationTypeNames.Operator);
            _fdlTags[Irony.Parsing.TokenType.LineComment] = BuildTag(typeService, PredefinedClassificationTypeNames.Comment);
            _fdlTags[Irony.Parsing.TokenType.Comment] = BuildTag(typeService, PredefinedClassificationTypeNames.Comment);

            _commentTag = BuildTag(typeService, PredefinedClassificationTypeNames.Comment);

            InitializeLineStates(_buffer.CurrentSnapshot);
        }

        /// <summary>
        /// In the context of a classification tagger, this is called initially w/ spans for all
        /// content in the file.
        /// It is called immediately after the user modifies text given the span of text that was modified.
        /// It is also called for all lines that are newly visible due to scrolling.
        /// This function gets called ALOT.  Keep processing times to a minimal and try to only handle 1 line at a
        /// time.
        /// </summary>
        /// <param name="spans"></param>
        /// <returns></returns>
        public IEnumerable<ITagSpan<ClassificationTag>> GetTags(NormalizedSnapshotSpanCollection spans)
        {
            if (spans.Count == 0)
                yield break;

            var snapShot = spans[0].Snapshot;
            foreach (var span in spans)
            {
                var startLine = span.Start.GetContainingLine();
                var endLine = span.End.GetContainingLine();

                var startLineNumber = startLine.LineNumber;
                var endLineNumber = endLine.LineNumber;

                for (int i = startLineNumber; i <= endLineNumber; i++)
                {
                    var line = spans[0].Snapshot.GetLineFromLineNumber(i);
                    _parser.Scanner.VsSetSource(line.GetText(), 0);

                    int state = 0;
                    _lineStates.TryGetValue(i, out state);

                    var token = _parser.Scanner.VsReadToken(ref state);
                    while (token != null)
                    {
                        if (token.Category == Irony.Parsing.TokenCategory.Content)
                        {
                            if (token.EditorInfo != null)
                            {
                                ClassificationTag tag;
                                if (_fdlTags.TryGetValue(token.EditorInfo.Type, out tag))
                                {
                                    var location = new SnapshotSpan(snapShot, line.Start.Position + token.Location.Position, token.Length);
                                    yield return new TagSpan<ClassificationTag>(location, tag);

                                }
                            }
                        }
                        else if (token.Category == Irony.Parsing.TokenCategory.Comment)
                        {

                            var location = new SnapshotSpan(snapShot, line.Start.Position + token.Location.Position, token.Length);
                            yield return new TagSpan<ClassificationTag>(location, _commentTag);
                        }

                        token = _parser.Scanner.VsReadToken(ref state);
                    }

                    int oldState = 0;
                    _lineStates.TryGetValue(i + 1, out oldState);
                    _lineStates[i + 1] = state;

                    //We're going into overtime, process new tags and send the event that these spans need updating!
                    if (oldState != state)
                    {
                        var lineNumber = endLineNumber;
                        while (oldState != state && lineNumber < snapShot.LineCount)
                        {
                            lineNumber++;
                            var dummyToken = _parser.Scanner.VsReadToken(ref state);
                            while (dummyToken != null)
                            {
                                dummyToken = _parser.Scanner.VsReadToken(ref state);
                            }

                            _lineStates.TryGetValue(lineNumber + 1, out oldState);
                            _lineStates[lineNumber + 1] = state;
                        }

                        if (lineNumber >= snapShot.LineCount)
                            lineNumber = snapShot.LineCount - 1;

                        var lastLine = snapShot.GetLineFromLineNumber(lineNumber);
                        if (lastLine != null && this.TagsChanged != null)
                        {
                            int length = lastLine.End.Position - endLine.End.Position;
                            var snapShotSpan = new SnapshotSpan(snapShot, endLine.End.Position, length);
                            this.TagsChanged(this, new SnapshotSpanEventArgs(snapShotSpan));
                        }
                    }
                }
            }
        }

        private ClassificationTag BuildTag(IClassificationTypeRegistryService typeService, string type)
        {
            var classificationType = typeService.GetClassificationType(type);
            return new ClassificationTag(classificationType);
        }

        /// <summary>
        /// Initializes the line states based on the snapshot.
        /// </summary>
        private void InitializeLineStates(ITextSnapshot snapShot)
        {
            _lineStates[0] = 0;
            foreach (var line in snapShot.Lines)
            {
                int state = 0;
                _parser.Scanner.VsSetSource(line.GetText(), 0);

                var dummyToken = _parser.Scanner.VsReadToken(ref state);
                while (dummyToken != null)
                {
                    dummyToken = _parser.Scanner.VsReadToken(ref state);
                }

                _lineStates[line.LineNumber + 1] = state;
            }
        }
    }

Grammar:
[Language("FDL", "6.0", "Feature Description Language")]
    public class Grammar: Irony.Parsing.Grammar
    {
        public Grammar():base(true)
        {
            #region NonTerminals

            var blockComment = new CommentTerminal("block-comment", "/*", "*/");
            var lineComment = new CommentTerminal("line-comment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
            NonGrammarTerminals.Add(blockComment);
            NonGrammarTerminals.Add(lineComment);
            var identifier = new IdentifierTerminal("identifier");
            var stringLit = new StringLiteral("string");

            #endregion
            #region Symbols
            MarkPunctuation(";", ",", ":");
            RegisterBracePair("{", "}");
            RegisterBracePair("<", ">");
            RegisterBracePair("[", "]");
            RegisterBracePair("(", ")");
            #endregion
            #region Keywords
            var action = Keyword("action");
            var actionBoxFont = Keyword("actionBoxFont");
            var actionBoxFontSize = Keyword("actionBoxFontSize");
            var allocate = Keyword("allocate");
            // rest of grammar omitted for brevity.
            #endregion
        }
        KeyTerm Keyword(string keyword)
        {
            var term = ToTerm(keyword);
            MarkReservedWords(keyword);
            term.EditorInfo = new TokenEditorInfo(TokenType.Keyword, TokenColor.Keyword, TokenTriggers.None);
            return term;
        }
    }

A:

Did you have a chance to look at Ben Morrison article - Writing Your First Visual Studio Language Service, where he explains how to use Irony for VS Language Service (syntax highlighting is a part of it)? 
Update: for Irony see my comment for similar thread Syntax highlight in Visual Studio 2015 using Irony grammar?
P.S. You could also find some valuable information here - MSDN Forums: Visual Studio Extensibility 

