public AnalyzerItem(AnalyzersFolderItem analyzersFolder, AnalyzerReference analyzerReference, IContextMenuController contextMenuController)
: base(GetNameText(analyzerReference))
{
_analyzersFolder = analyzersFolder;
_analyzerReference = analyzerReference;
_contextMenuController = contextMenuController;
}
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 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;
}
}
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 bool HasAnalyzerReference(AnalyzerReference analyzerReference)
{
Contract.ThrowIfNull(analyzerReference);
if (analyzerReference is AnalyzerFileReference)
{
// Filter out duplicate analyzer references with same assembly name/full path.
return(analyzerReference.Display != null && _diagnosticAnalyzerIdMap.ContainsKey(analyzerReference.Display));
}
else
{
// For non-file references, we will check individual DiagnosticAnalyzer instances for duplicates.
return(false);
}
}
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 void UpdateDiagnosticAnalyzerToPackageNameMap(
ImmutableDictionary <string, string> nameMap,
AnalyzerReference reference,
ImmutableArray <DiagnosticAnalyzer> analyzers)
{
if (!(reference is AnalyzerFileReference fileReference))
{
return;
}
if (!nameMap.TryGetValue(fileReference.FullPath, out var name))
{
return;
}
foreach (var analyzer in analyzers)
{
ImmutableInterlocked.GetOrAdd(ref _hostDiagnosticAnalyzerPackageNameMap, analyzer, name);
}
}
/// <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_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 object GetAnalyzerReferenceIdentity(AnalyzerReference reference) => reference.Id;
private static void WriteUnresolvedAnalyzerReferenceTo(AnalyzerReference reference, ObjectWriter writer)
{
writer.WriteString(nameof(UnresolvedAnalyzerReference));
writer.WriteString(reference.FullPath);
}
public void SonarAnalyzerManager_MultipleReferencesWithSameName_NonCollidingVersion()
{
var version1 = new Version("0.1.2.3");
Assert.AreNotEqual(SonarAnalyzerManager.AnalyzerVersion, version1,
"Test input should be different from the expected analyzer version");
var version2 = new Version("1.2.3.4");
Assert.AreNotEqual(SonarAnalyzerManager.AnalyzerVersion, version2,
"Test input should be different from the expected analyzer version");
IEnumerable<AnalyzerReference> references = new AnalyzerReference[]
{
new ConfigurableAnalyzerReference(
new AssemblyIdentity(SonarAnalyzerManager.AnalyzerName, version1),
SonarAnalyzerManager.AnalyzerName),
new ConfigurableAnalyzerReference(
new AssemblyIdentity(SonarAnalyzerManager.AnalyzerName, version2),
SonarAnalyzerManager.AnalyzerName),
};
Assert.IsTrue(
SonarAnalyzerManager.HasConflictingAnalyzerReference(
SonarAnalyzerManager.GetProjectAnalyzerConflictStatus(references)),
"Having only different reference versions should disable the embedded analyzer");
}
public void SonarAnalyzerManager_MultipleReferencesWithSameName_CollidingVersion()
{
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),
new ConfigurableAnalyzerReference(
new AssemblyIdentity(SonarAnalyzerManager.AnalyzerName, SonarAnalyzerManager.AnalyzerVersion),
SonarAnalyzerManager.AnalyzerName),
};
Assert.IsFalse(
SonarAnalyzerManager.HasConflictingAnalyzerReference(
SonarAnalyzerManager.GetProjectAnalyzerConflictStatus(references)),
"Having already colliding references should not disable the embedded analyzer if one is of the same version");
}
public ProjectCodeFixProvider(AnalyzerReference reference)
{
_reference = reference;
_fixersPerLanguage = ImmutableDictionary<string, ImmutableArray<CodeFixProvider>>.Empty;
}
/// <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 bool CheckAnalyzerReferenceIdentity(AnalyzerReference reference)
{
if (reference == null)
{
return false;
}
return !_hostAnalyzerReferencesMap.ContainsKey(reference.Id);
}
public WorkspaceAnalyzerReferenceAsset(AnalyzerReference reference, Serializer serializer) :
base(CreateChecksum(reference), WellKnownSynchronizationKinds.AnalyzerReference)
{
_reference = reference;
_serializer = serializer;
}
public bool HasAnalyzerReference(AnalyzerReference analyzerReference, string language)
{
var analyzersAndStates = this.GetOrCreatePerLanguageAnalyzersAndStates(language);
return(analyzersAndStates.HasAnalyzerReference(analyzerReference));
}
protected override void ApplyAnalyzerReferenceRemoved(ProjectId projectId, AnalyzerReference analyzerReference)
{
Debug.Assert(_applyChangesProjectFile != null);
_applyChangesProjectFile.RemoveAnalyzerReference(analyzerReference);
this.OnAnalyzerReferenceRemoved(projectId, analyzerReference);
}
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()));
}
/// <summary>
/// Create a new solution instance with the project specified updated to no longer include
/// the specified analyzer reference.
/// </summary>
public SolutionState RemoveAnalyzerReference(ProjectId projectId, AnalyzerReference analyzerReference)
{
if (projectId == null)
{
throw new ArgumentNullException(nameof(projectId));
}
if (analyzerReference == null)
{
throw new ArgumentNullException(nameof(analyzerReference));
}
CheckContainsProject(projectId);
return this.ForkProject(this.GetProjectState(projectId).RemoveAnalyzerReference(analyzerReference));
}
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");
}
public void Reset()
{
var analyzerFileReference = _analyzerReference as AnalyzerFileReference;
if (analyzerFileReference != null)
{
analyzerFileReference.AnalyzerLoadFailed -= OnAnalyzerLoadError;
if (_analyzerLoadErrors != null && _analyzerLoadErrors.Count > 0)
{
_hostDiagnosticUpdateSource.ClearDiagnosticsForProject(_projectId, this);
}
_hostDiagnosticUpdateSource.ClearAnalyzerReferenceDiagnostics(analyzerFileReference, _language, _projectId);
}
_analyzerLoadErrors = null;
_analyzerReference = null;
}
/// <summary>
/// It returns a string that can be used as a way to de-duplicate <see cref="AnalyzerReference"/>s.
/// </summary>
public string GetAnalyzerReferenceIdentity(AnalyzerReference reference)
{
return(GetAnalyzerReferenceId(reference));
}
public void WriteTo(AnalyzerReference reference, ObjectWriter writer, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var file = reference as AnalyzerFileReference;
if (file != null)
{
writer.WriteString(nameof(AnalyzerFileReference));
writer.WriteInt32((int)SerializationKinds.FilePath);
writer.WriteString(file.FullPath);
// TODO: remove this kind of host specific knowledge from common layer.
// but think moving it to host layer where this implementation detail actually exist.
//
// analyzer assembly path to load analyzer acts like
// snapshot version for analyzer (since it is based on shadow copy)
// we can't send over bits and load analyer from memory (image) due to CLR not being able
// to find satellite dlls for analyzers.
writer.WriteString(GetAnalyzerAssemblyPath(file));
return;
}
var image = reference as AnalyzerImageReference;
if (image != null)
{
// TODO: think a way to support this or a way to deal with this kind of situation.
throw new NotSupportedException(nameof(AnalyzerImageReference));
}
var unresolved = reference as UnresolvedAnalyzerReference;
if (unresolved != null)
{
writer.WriteString(nameof(UnresolvedAnalyzerReference));
writer.WriteString(reference.FullPath);
return;
}
throw ExceptionUtilities.UnexpectedValue(reference.GetType());
}
private static string GetDisplayName(AnalyzerReference reference)
{
return(reference.Display ?? FeaturesResources.Unknown);
}
private void UpdateDiagnosticAnalyzerToPackageNameMap(
ImmutableDictionary<string, string> nameMap,
AnalyzerReference reference,
ImmutableArray<DiagnosticAnalyzer> analyzers)
{
var fileReference = reference as AnalyzerFileReference;
if (fileReference == null)
{
return;
}
string name;
if (!nameMap.TryGetValue(fileReference.FullPath, out name))
{
return;
}
foreach (var analyzer in analyzers)
{
ImmutableInterlocked.GetOrAdd(ref _hostDiagnosticAnalyzerPackageNameMap, analyzer, _ => name);
}
}
public void SerializeAnalyzerReference(AnalyzerReference reference, ObjectWriter writer, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
_hostSerializationService.WriteTo(reference, writer, cancellationToken);
}
/// <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);
}
public void SonarAnalyzerManager_HasNoCollidingAnalyzerReference_NoDisplayName()
{
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),
null)
};
Assert.IsFalse(
SonarAnalyzerManager.HasConflictingAnalyzerReference(
SonarAnalyzerManager.GetProjectAnalyzerConflictStatus(references)),
"Null analyzer name should not report conflict");
}
public ProjectState RemoveAnalyzerReference(AnalyzerReference analyzerReference)
{
Contract.Requires(this.AnalyzerReferences.Contains(analyzerReference));
return this.With(
projectInfo: this.ProjectInfo.WithAnalyzerReferences(this.AnalyzerReferences.Remove(analyzerReference)).WithVersion(this.Version.GetNewerVersion()));
}
public void SonarAnalyzerManager_HasNoCollidingAnalyzerReference_NoAssemblyIdentity()
{
IEnumerable<AnalyzerReference> references = new AnalyzerReference[]
{
new ConfigurableAnalyzerReference(
new object(),
SonarAnalyzerManager.AnalyzerName)
};
Assert.IsTrue(
SonarAnalyzerManager.HasConflictingAnalyzerReference(
SonarAnalyzerManager.GetProjectAnalyzerConflictStatus(references)),
"If no AssemblyIdentity is present, but the name matches, we should report a conflict");
}