public static ITagSpan<IClassificationTag> ToTagSpan(this TextSpan span, ITextSnapshot snapshot, IClassificationType classificationType)
 {
     return new TagSpan<IClassificationTag>(
       new SnapshotSpan(snapshot, span.Start, span.Length),
       new ClassificationTag(classificationType)
       );
 }

 public RobotsTxtSyntacticParser(IClassificationTypeRegistryService registry)
 {
     _commentType = registry.GetClassificationType(PredefinedClassificationTypeNames.Comment);
     _delimiterType = registry.GetClassificationType("RobotsTxt/Delimiter");
     _recordNameType = registry.GetClassificationType("RobotsTxt/RecordName");
     _recordValueType = registry.GetClassificationType("RobotsTxt/RecordValue");
 }

 internal VendorClassifier(IClassificationTypeRegistryService registry, ITextBuffer buffer)
 {
     _registry = registry;
     _buffer = buffer;
     _decClassification = _registry.GetClassificationType(ClassificationTypes._declaration);
     _valClassification = _registry.GetClassificationType(ClassificationTypes._value);
 }

 public static ClassificationSpan ToClassificationSpan(this TextSpan span, ITextSnapshot snapshot, IClassificationType classificationType)
 {
     return new ClassificationSpan(
       new SnapshotSpan(snapshot,  span.Start, span.Length),
       classificationType
       );
 }

		internal WacomTranslationDatabaseHighlighter(IClassificationTypeRegistryService registry)
		{
			_keyType = registry.GetClassificationType("wacom.tdb.key");
			_valType = registry.GetClassificationType("wacom.tdb.value");
			_sepType = registry.GetClassificationType("wacom.tdb.separator");
			_errType = registry.GetClassificationType("wacom.tdb.error");
		}

 private void AddClassification(IClassificationType classificationType, int startIndex, int length)
 {
     CurrentFileBlockBuilder.ClassificationSpans.Add(
         new ClassificationSpan(
             new SnapshotSpan(textSnapshot, new Span(startIndex, length)),
             classificationType));
 }

 public DockerfileClassifier(IClassificationTypeRegistryService registry)
 {
     _keyword = registry.GetClassificationType(PredefinedClassificationTypeNames.Keyword);
     _comment = registry.GetClassificationType(PredefinedClassificationTypeNames.Comment);
     _string = registry.GetClassificationType(PredefinedClassificationTypeNames.String);
     _symbol = registry.GetClassificationType(DockerfileClassificationTypes.Keyword);
 }

        public CurrentColumnAdornment(
            IWpfTextView view, IClassificationFormatMap formatMap,
            IClassificationType formatType, IVsfSettings settings)
        {
            this.view = view;
              this.formatMap = formatMap;
              this.formatType = formatType;
              this.settings = settings;
              this.columnRect = new Rectangle();
              layer = view.GetAdornmentLayer(Constants.COLUMN_HIGHLIGHT);

              view.Caret.PositionChanged += OnCaretPositionChanged;
              view.ViewportWidthChanged += OnViewportChanged;
              view.ViewportHeightChanged += OnViewportChanged;
              view.LayoutChanged += OnViewLayoutChanged;
              view.TextViewModel.EditBuffer.PostChanged += OnBufferPostChanged;
              view.Closed += OnViewClosed;
              view.Options.OptionChanged += OnSettingsChanged;

              this.settings.SettingsChanged += OnSettingsChanged;
              formatMap.ClassificationFormatMappingChanged +=
             OnClassificationFormatMappingChanged;

              CreateDrawingObjects();
        }

 public MarkdownClassifier(IClassificationTypeRegistryService registry)
 {
     _bold = registry.GetClassificationType(MarkdownClassificationTypes.MarkdownBold);
     _italic = registry.GetClassificationType(MarkdownClassificationTypes.MarkdownItalic);
     _header = registry.GetClassificationType(MarkdownClassificationTypes.MarkdownHeader);
     _code = registry.GetClassificationType(MarkdownClassificationTypes.MarkdownCode);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="DothtmlClassifier"/> class.
 /// </summary>
 public DothtmlClassifier(IClassificationTypeRegistryService registry, ITextBuffer buffer)
 {
     tokenizer = new DothtmlTokenizer();
     this.buffer = buffer;
     bindingBrace = registry.GetClassificationType(DothtmlClassificationTypes.BindingBrace);
     bindingContent = registry.GetClassificationType(DothtmlClassificationTypes.BindingContent);
 }

		internal static void FillClassificationGap(List<ClassificationSpan> classifications, Span? lastClassificationSpan, Span newClassificationSpan, ITextSnapshot currentSnapshot, IClassificationType classificationType)
		{
			if (lastClassificationSpan.HasValue && newClassificationSpan.Start > lastClassificationSpan.Value.Start + lastClassificationSpan.Value.Length)
			{
				classifications.Add(new ClassificationSpan(new SnapshotSpan(currentSnapshot, lastClassificationSpan.Value.Start + lastClassificationSpan.Value.Length, newClassificationSpan.Start - (lastClassificationSpan.Value.Start + lastClassificationSpan.Value.Length)), classificationType));
			}
		}

 public UsageClassifier(IClassificationTypeRegistryService classificationRegistry, ITextBuffer textBuffer)
 {
     _highlightOne = classificationRegistry.GetClassificationType(ClassificationTypes.HighlightOneName);
       _highlightTwo = classificationRegistry.GetClassificationType(ClassificationTypes.HighlightTwoName);
       _textBuffer = textBuffer;
       _textBuffer.Changed += (_, args) => UpdateUsageHighlighting(Enumerable.Empty<GotoInfo>());
 }

 internal SqlClassifier(ITagAggregator<NaturalTextTag> tagger, IClassificationTypeRegistryService classificationRegistry)
 {
     this.tagger = tagger;
     keywordType = classificationRegistry.GetClassificationType("sql-keyword");
     functionType = classificationRegistry.GetClassificationType("sql-function");
     variableType = classificationRegistry.GetClassificationType("sql-variable");
 }

        internal HSPClassifier(IClassificationTypeRegistryService registry)
        {
            _validType = registry.GetClassificationType("HSPClassifierValidFormat");
            _normalType = registry.GetClassificationType("HSPClassifierNormalFormat");

            _commentoutType = registry.GetClassificationType("HSPClassifierCommentOutFormat");
            _keywordType = registry.GetClassificationType("HSPClassifierKeywordFormat");
        }

 internal StorEvilClassifier(IClassificationTypeRegistryService registry)
 {
     _pending = registry.GetClassificationType("StorEvil.VS2010.Pending");
     _comment = registry.GetClassificationType("StorEvil.VS2010.Comment");
     _interpreted = registry.GetClassificationType("StorEvil.VS2010.Interpreted");
     _scenarioStart = registry.GetClassificationType("StorEvil.VS2010.ScenarioStart");
     _table = registry.GetClassificationType("StorEvil.VS2010.Table");
 }

        private void AddClassification(LocatedNode node, IClassificationType classificationType)
        {
            if (classificationType == null)
                throw new ArgumentNullException(nameof(classificationType));

            if (node.SourceRange.Length > 0 && node.Span.IsInRootFile)
                _results.Add(CreateClassificationTagSpan(node, classificationType));
        }

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="syntaxRoot">Syntax root</param>
		/// <param name="semanticModel">Semantic model</param>
		/// <param name="workspace">Workspace</param>
		/// <param name="roslynClassificationTypes">Classification types</param>
		/// <param name="defaultClassificationType">Default classification type if a token can't be classified or null to not use anything</param>
		/// <param name="cancellationToken">Cancellation token</param>
		public RoslynClassifier(SyntaxNode syntaxRoot, SemanticModel semanticModel, Workspace workspace, RoslynClassificationTypes roslynClassificationTypes, IClassificationType defaultClassificationType, CancellationToken cancellationToken) {
			this.syntaxRoot = syntaxRoot;
			this.semanticModel = semanticModel;
			this.workspace = workspace;
			this.roslynClassificationTypes = roslynClassificationTypes;
			this.defaultClassificationType = defaultClassificationType;
			this.cancellationToken = cancellationToken;
		}

        private void AddClassification(SyntaxNode node, IClassificationType classificationType)
        {
            if (classificationType == null)
                throw new ArgumentNullException(nameof(classificationType));

            if (node.Span.Length > 0)
                _results.Add(CreateClassificationTagSpan(node, classificationType));
        }

 public WebVttClassifier(IClassificationTypeRegistryService registry)
 {
     _markup = registry.GetClassificationType(WebVttClassificationTypes.Markup);
     _name = registry.GetClassificationType(WebVttClassificationTypes.Name);
     _statement = registry.GetClassificationType(WebVttClassificationTypes.Statement);
     _time = registry.GetClassificationType(WebVttClassificationTypes.Time);
     _comment = registry.GetClassificationType(PredefinedClassificationTypeNames.Comment);
 }

 internal VccClassifier(IClassificationTypeRegistryService registry)
 {
   this.keywordType = registry.GetClassificationType(VccClassificationTypeDefinitions.KeywordType);
   this.specType= registry.GetClassificationType(VccClassificationTypeDefinitions.SpecType);
   this.dimmedKeywordType = registry.GetClassificationType(VccClassificationTypeDefinitions.DimmedKeywordType);
   this.dimmedSpecType = registry.GetClassificationType(VccClassificationTypeDefinitions.DimmedSpecType);
   VSPackagePackage.Instance.OptionPage.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(OptionPage_PropertyChanged);
 }