private void ColorizeLinePart(string value, GherkinBufferSpan span, IClassificationType classificationType)
        {
            var textPosition = gherkinBuffer.IndexOfTextForLine(value, span.StartPosition.Line);
            if (textPosition == null)
                return;

            var textSpan = new GherkinBufferSpan(
                textPosition,
                textPosition.ShiftByCharacters(value.Length));
            ColorizeSpan(textSpan, classificationType);
        }

        public void Examples(string keyword, string name, string description, GherkinBufferSpan headerSpan, GherkinBufferSpan descriptionSpan)
        {
            var position = GetFilePosition(headerSpan.StartPosition);
            var exampleBuilder = new ExampleBuilder(name, description, position);
            tableProcessor = exampleBuilder;

            if (exampleProcessor == null)
                throw new GherkinSemanticErrorException(
                    "Examples can only be specified for a scenario outline.", position);
            exampleProcessor.ProcessExample(exampleBuilder);
        }

        private void ColorizeSpan(GherkinBufferSpan span, IClassificationType classificationType)
        {
            if (span == null)
                return;

            var startLine = textSnapshot.GetLineFromLineNumber(span.StartPosition.Line);
            var endLine = span.StartPosition.Line == span.EndPosition.Line ? startLine :
                textSnapshot.GetLineFromLineNumber(span.EndPosition.Line);
            var startIndex = startLine.Start + span.StartPosition.LinePosition;

            AddClassification(classificationType, 
                startIndex, 
                endLine.Start + span.EndPosition.LinePosition - startIndex);
        }

        private void ColorizeSpan(GherkinBufferSpan span, IClassificationType classificationType)
        {
            if (span == null)
                return;

            var startLine = textSnapshot.GetLineFromLineNumber(span.StartPosition.Line);
            var endLine = span.StartPosition.Line == span.EndPosition.Line ? 
                startLine : textSnapshot.GetLineFromLineNumber(span.EndPosition.Line);
            var startIndex = startLine.Start + span.StartPosition.LinePosition;
            var endLinePosition = span.EndPosition.LinePosition == endLine.Length ? 
                endLine.LengthIncludingLineBreak : span.EndPosition.LinePosition;
            var length = endLine.Start + endLinePosition - startIndex;
            AddClassification(classificationType, startIndex, length);
        }

        public void Comment(string commentText, GherkinBufferSpan commentSpan)
        {
            if (GherkinDialectServices.IsLanguageLine(commentText))
                return;

            var position = GetFilePosition(commentSpan.StartPosition);
            string trimmedComment = commentText.TrimStart(' ', '#', '\t');
            position.Column += commentText.Length - trimmedComment.Length;
            trimmedComment = trimmedComment.Trim();

            if (trimmedComment.Length == 0)
                return;

            featureBuilder.AddComment(trimmedComment, position);
        }

 public void Examples(string keyword, string name, string description, GherkinBufferSpan headerSpan, GherkinBufferSpan descriptionSpan)
 {
     //TODO: outline
     RegisterKeyword(keyword, headerSpan);
     ColorizeSpan(descriptionSpan, classifications.Description);
 }

 public void ScenarioOutline(string keyword, string name, string description, GherkinBufferSpan headerSpan, GherkinBufferSpan descriptionSpan)
 {
     ScenarioEditorInfo scenario = ProcessScenario(keyword, name, headerSpan, descriptionSpan);
     scenario.IsScenarioOutline = true;
 }

 public void Comment(string commentText, GherkinBufferSpan commentSpan)
 {
     ColorizeSpan(commentSpan, classifications.Comment);
 }

 public void Feature(string keyword, string name, string description, GherkinBufferSpan headerSpan, GherkinBufferSpan descriptionSpan)
 {
     ColorizeKeywordLine(keyword, headerSpan, classifications.FeatureTitle);
     ColorizeSpan(descriptionSpan, classifications.Description);
 }

 public void ScenarioOutline(string keyword, string name, string description, GherkinBufferSpan headerSpan, GherkinBufferSpan descriptionSpan)
 {
     ProcessScenario(keyword, name, headerSpan, descriptionSpan, typeof(IScenarioOutlineBlock));
 }

        public virtual void Feature(string keyword, string name, string description, GherkinBufferSpan headerSpan, GherkinBufferSpan descriptionSpan)
        {
            CurrentFileBlockBuilder.SetMainData(typeof(IHeaderBlock), headerSpan.StartPosition.Line, keyword, name);

            ColorizeKeywordLine(keyword, headerSpan, classifications.FeatureTitle);
            ColorizeSpan(descriptionSpan, classifications.Description);
        }

        public void MultilineText(string text, GherkinBufferSpan textSpan)
        {
            ColorizeSpan(textSpan, classifications.MultilineText);

            if (currentStep != null)
            {
                currentStep.MultilineTextArgument = text;
            }
            else
            {
                //TODO: shall we mark it as error?
            }
        }

 public void ScenarioTag(string name, GherkinBufferSpan tagSpan)
 {
     EnsureNewScenario(tagSpan.StartPosition.Line);
     ColorizeSpan(tagSpan, classifications.Tag);
 }

        public void Step(string keyword, StepKeyword stepKeyword, Parser.Gherkin.ScenarioBlock scenarioBlock, string text, GherkinBufferSpan stepSpan)
        {
            if (CurrentFileBlockBuilder.BlockType == typeof(IScenarioOutlineBlock))
            {
                var matches = placeholderRe.Matches(text);
                foreach (Match match in matches)
                    ColorizeLinePart(match.Value, stepSpan, classifications.Placeholder);
            }

            var editorLine = stepSpan.StartPosition.Line;
            var tags = FeatureTags.Concat(CurrentFileBlockBuilder.Tags).Distinct();
            var stepContext = new StepContext(FeatureTitle, CurrentFileBlockBuilder.BlockType == typeof(IBackgroundBlock) ? null : CurrentFileBlockBuilder.Title, tags.ToArray(), gherkinFileScope.GherkinDialect.CultureInfo);

            currentStep = new GherkinStep((StepDefinitionType)scenarioBlock, (StepDefinitionKeyword)stepKeyword, text, stepContext, keyword, editorLine - CurrentFileBlockBuilder.KeywordLine);
            CurrentFileBlockBuilder.Steps.Add(currentStep);



            var bindingMatchService = projectScope.BindingMatchService;
         


            if (bindingMatchService.Ready && bindingMatchService != null)
            {
                List<BindingMatch> candidatingMatches;
                candidatingMatches = null;
                StepDefinitionAmbiguityReason ambiguityReason;
                CultureInfo bindingCulture = currentStep.StepContext.Language;
                var match = bindingMatchService.GetBestMatch(currentStep, bindingCulture, out ambiguityReason, out candidatingMatches);

                if (candidatingMatches.Count == 0)
                {
                    ColorizeKeywordLine(keyword, stepSpan, classifications.StepText);
                }
                else
                {
                    ColorizeKeywordLine(keyword, stepSpan, classifications.KnownStepText);
                    foreach (String value in candidatingMatches.First().StepBinding.Regex.Split(text))
                        ColorizeLinePart(value, stepSpan, classifications.Variable);
                }
                  

            
            }
            else
                ColorizeKeywordLine(keyword, stepSpan, classifications.StepText);

        }

 public void TableRow(string[] cells, GherkinBufferSpan rowSpan, GherkinBufferSpan[] cellSpans)
 {
     foreach (var cellSpan in cellSpans)
     {
         ColorizeSpan(cellSpan, classifications.TableCell);
     }
     if (currentStep != null)
     {
         try
         {
             currentStep.TableArgument.AddRow(cells);
         }
         catch (Exception)
         {
             //TODO: shall we mark it as error?
         }
     }
     //TODO: register outline example
 }

 public void ScenarioTag(string name, GherkinBufferSpan tagSpan)
 {
     EnsureNewScenario(tagSpan.StartPosition.Line);
     CurrentFileBlockBuilder.Tags.Add(name.TrimStart('@'));
     ColorizeSpan(tagSpan, classifications.Tag);
 }

 public void FeatureTag(string name, GherkinBufferSpan tagSpan)
 {
     ColorizeSpan(tagSpan, classifications.Tag);
     CurrentFileBlockBuilder.Tags.Add(name.TrimStart('@'));
 }

        private void ProcessScenario(string keyword, string name, GherkinBufferSpan headerSpan, GherkinBufferSpan descriptionSpan, Type blockType)
        {
            EnsureNewScenario(headerSpan.StartPosition.Line);
            CurrentFileBlockBuilder.SetMainData(blockType, headerSpan.StartPosition.Line, keyword, name);

            ColorizeKeywordLine(keyword, headerSpan, classifications.ScenarioTitle);
            ColorizeSpan(descriptionSpan, classifications.Description);
        }

        private ScenarioEditorInfo ProcessScenario(string keyword, string name, GherkinBufferSpan headerSpan, GherkinBufferSpan descriptionSpan)
        {
            EnsureNewScenario(headerSpan.StartPosition.Line);

            ColorizeKeywordLine(keyword, headerSpan, classifications.ScenarioTitle);
            ColorizeSpan(descriptionSpan, classifications.Description);

            var scenario = gherkinFileEditorInfo.ScenarioEditorInfos.Last();
            scenario.KeywordLine = headerSpan.StartPosition.Line;
            scenario.Title = name;
            scenario.Keyword = keyword;
            return scenario;
        }

 public void TableRow(string[] cells, GherkinBufferSpan rowSpan, GherkinBufferSpan[] cellSpans)
 {
     foreach (var cellSpan in cellSpans)
     {
         ColorizeSpan(cellSpan, classifications.TableCell);
     }
 }