public AnalyzerItem(AnalyzersFolderItem analyzersFolder, AnalyzerReference analyzerReference, IContextMenuController contextMenuController)
     : base(GetNameText(analyzerReference))
 {
     _analyzersFolder = analyzersFolder;
     _analyzerReference = analyzerReference;
     _contextMenuController = contextMenuController;
 }

        public Checksum CreateChecksum(AnalyzerReference reference, CancellationToken cancellationToken)
        {
            using (var stream = SerializableBytes.CreateWritableStream())
            using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken))
            {
                WriteTo(reference, writer, cancellationToken);

                stream.Position = 0;
                return Checksum.Create(stream);
            }
        }

 private static string GetNameText(AnalyzerReference analyzerReference)
 {
     if (analyzerReference.IsUnresolved)
     {
         return analyzerReference.FullPath;
     }
     else
     {
         return analyzerReference.Display;
     }
 }

        private static Checksum CreateChecksum(AnalyzerReference reference)
        {
            using (var stream = SerializableBytes.CreateWritableStream())
            using (var objectWriter = new StreamObjectWriter(stream))
            {
                objectWriter.WriteString(WellKnownSynchronizationKinds.AnalyzerReference);
                objectWriter.WriteString(reference.FullPath);

                return Checksum.Create(stream);
            }
        }

        public void SonarAnalyzerManager_HasNoCollidingAnalyzerReference_SameNameVersion()
        {
            IEnumerable<AnalyzerReference> references = new AnalyzerReference[]
            {
                new ConfigurableAnalyzerReference(
                    new AssemblyIdentity(SonarAnalyzerManager.AnalyzerName, SonarAnalyzerManager.AnalyzerVersion),
                    SonarAnalyzerManager.AnalyzerName)
            };

            Assert.IsFalse(
                SonarAnalyzerManager.HasConflictingAnalyzerReference(
                    SonarAnalyzerManager.GetProjectAnalyzerConflictStatus(references)),
                "Same named and versioned analyzers should not be reported as conflicting ones");
        }

        public AnalyzerReference GetReference()
        {
            if (_analyzerReference == null)
            {
                if (File.Exists(_fullPath))
                {
                    _analyzerReference = new AnalyzerFileReference(_fullPath, _loader);
                    ((AnalyzerFileReference)_analyzerReference).AnalyzerLoadFailed += OnAnalyzerLoadError;
                }
                else
                {
                    _analyzerReference = new UnresolvedAnalyzerReference(_fullPath);
                }
            }

            return _analyzerReference;
        }

        public AnalyzerReference GetReference()
        {
            if (_analyzerReference == null)
            {
                if (File.Exists(_fullPath))
                {
                    _analyzerReference = new AnalyzerFileReference(_fullPath, InMemoryAssemblyProvider.GetAssembly);
                    ((AnalyzerFileReference)_analyzerReference).AnalyzerLoadFailed += OnAnalyzerLoadError;
                }
                else
                {
                    _analyzerReference = new UnresolvedAnalyzerReference(_fullPath);
                }
            }

            return _analyzerReference;
        }

        public void SonarAnalyzerManager_HasCollidingAnalyzerReference()
        {
            var version = new Version("0.1.2.3");
            Assert.AreNotEqual(SonarAnalyzerManager.AnalyzerVersion, version,
                "Test input should be different from the expected analyzer version");

            IEnumerable<AnalyzerReference> references = new AnalyzerReference[]
            {
                new ConfigurableAnalyzerReference(
                    new AssemblyIdentity(SonarAnalyzerManager.AnalyzerName, version),
                    SonarAnalyzerManager.AnalyzerName)
            };

            Assert.IsTrue(
                SonarAnalyzerManager.HasConflictingAnalyzerReference(
                    SonarAnalyzerManager.GetProjectAnalyzerConflictStatus(references)),
                "Conflicting analyzer package not found");
        }

        public void SonarAnalyzerManager_GetIsBoundWithoutAnalyzer_Unbound_Conflicting()
        {
            this.activeSolutionBoundTracker.IsActiveSolutionBound = false;

            var version = new Version("0.1.2.3");
            Assert.AreNotEqual(SonarAnalyzerManager.AnalyzerVersion, version,
                "Test input should be different from the expected analyzer version");

            IEnumerable<AnalyzerReference> references = new AnalyzerReference[]
            {
                new ConfigurableAnalyzerReference(
                    new AssemblyIdentity(SonarAnalyzerManager.AnalyzerName, version),
                    SonarAnalyzerManager.AnalyzerName)
            };

            Assert.IsFalse(
                this.testSubject.GetIsBoundWithoutAnalyzer(
                    SonarAnalyzerManager.GetProjectAnalyzerConflictStatus(references)),
                "Unbound solution should never return true");
        }

        private bool CheckAnalyzerReferenceIdentity(AnalyzerReference reference)
        {
            if (reference == null)
            {
                return false;
            }

            return !_hostAnalyzerReferencesMap.ContainsKey(reference.Id);
        }

 /// <summary>
 /// It returns a string that can be used as a way to de-duplicate <see cref="AnalyzerReference"/>s.
 /// </summary>
 public object GetAnalyzerReferenceIdentity(AnalyzerReference reference)
 {
     return reference.Id;
 }

 private static void WriteUnresolvedAnalyzerReferenceTo(AnalyzerReference reference, ObjectWriter writer)
 {
     writer.WriteString(nameof(UnresolvedAnalyzerReference));
     writer.WriteString(reference.FullPath);
 }

 protected override void ApplyAnalyzerReferenceRemoved(ProjectId projectId, AnalyzerReference analyzerReference)
 {
     Debug.Assert(_applyChangesProjectFile != null);
     _applyChangesProjectFile.RemoveAnalyzerReference(analyzerReference);
     this.OnAnalyzerReferenceRemoved(projectId, analyzerReference);
 }

        public void SonarAnalyzerManager_HasNoCollidingAnalyzerReference_SameVersionDifferentName()
        {
            var name = "Some test name";
            Assert.AreNotEqual(SonarAnalyzerManager.AnalyzerName, name,
                "Test input should be different from the expected analyzer name");

            IEnumerable<AnalyzerReference> references = new AnalyzerReference[]
            {
                new ConfigurableAnalyzerReference(
                    new AssemblyIdentity(name, SonarAnalyzerManager.AnalyzerVersion), name)
            };

            Assert.IsFalse(
                SonarAnalyzerManager.HasConflictingAnalyzerReference(
                    SonarAnalyzerManager.GetProjectAnalyzerConflictStatus(references)),
                "Name is not considered in the confliction checking");
        }

 public CustomAsset Build(AnalyzerReference reference, CancellationToken cancellationToken)
 {
     return new WorkspaceAnalyzerReferenceAsset(reference, _serializer);
 }

        public ProjectState AddAnalyzerReference(AnalyzerReference analyzerReference)
        {
            Contract.Requires(!this.AnalyzerReferences.Contains(analyzerReference));

            return this.With(
                projectInfo: this.ProjectInfo.WithAnalyzerReferences(this.AnalyzerReferences.ToImmutableArray().Add(analyzerReference)).WithVersion(this.Version.GetNewerVersion()));
        }

 public ProjectCodeFixProvider(AnalyzerReference reference)
 {
     _reference = reference;
     _fixersPerLanguage = ImmutableDictionary<string, ImmutableArray<CodeFixProvider>>.Empty;
 }

 public WorkspaceAnalyzerReferenceAsset(AnalyzerReference reference, Serializer serializer) :
     base(CreateChecksum(reference), WellKnownSynchronizationKinds.AnalyzerReference)
 {
     _reference = reference;
     _serializer = serializer;
 }

 /// <summary>
 /// Creates a new instance of this project updated to no longer include the specified analyzer reference.
 /// </summary>
 public Project RemoveAnalyzerReference(AnalyzerReference analyzerReference)
 {
     return this.Solution.RemoveAnalyzerReference(this.Id, analyzerReference).GetProject(this.Id);
 }

        public void SonarAnalyzerManager_GetIsBoundWithoutAnalyzer_Unbound_NonConflicting()
        {
            this.activeSolutionBoundTracker.IsActiveSolutionBound = false;

            IEnumerable<AnalyzerReference> references = new AnalyzerReference[]
            {
                new ConfigurableAnalyzerReference(
                    new AssemblyIdentity(SonarAnalyzerManager.AnalyzerName, SonarAnalyzerManager.AnalyzerVersion),
                    SonarAnalyzerManager.AnalyzerName)
            };

            Assert.IsFalse(
                this.testSubject.GetIsBoundWithoutAnalyzer(
                    SonarAnalyzerManager.GetProjectAnalyzerConflictStatus(references)),
                "Unbound solution should never return true");
        }