public sealed override bool Equals(object obj)
{
DiagnosticInfoWithMessageProvider other = obj as DiagnosticInfoWithMessageProvider;
bool result = false;
if (other != null &&
other._errorCode == _errorCode &&
this.GetType() == obj.GetType())
{
if (_arguments == null && other._arguments == null)
{
result = true;
}
else if (_arguments != null && other._arguments != null && _arguments.Length == other._arguments.Length)
{
result = true;
for (int i = 0; i < _arguments.Length; i++)
{
if (!object.Equals(_arguments[i], other._arguments[i]))
{
result = false;
break;
}
}
}
}
return(result);
}
private DiagnosticInfoWithMessageProvider(DiagnosticInfoWithMessageProvider original, DiagnosticSeverity overriddenSeverity)
{
_messageProvider = original.MessageProvider;
_errorCode = original._errorCode;
_defaultSeverity = original.DefaultSeverity;
_arguments = original._arguments;
_effectiveSeverity = overriddenSeverity;
}
public void Close(DiagnosticBag diagnostics)
{
try
{
_streamToDispose?.Dispose();
}
catch (Exception e)
{
var messageProvider = _compiler.MessageProvider;
var diagnosticInfo = new DiagnosticInfoWithMessageProvider(messageProvider, messageProvider.ERR_OutputWriteFailed, _filePath, e.Message);
diagnostics.Add(messageProvider.CreateDiagnostic(diagnosticInfo));
}
}
internal ImmutableArray <DiagnosticAnalyzer> ResolveAnalyzersFromArguments(
string language,
List <DiagnosticInfo> diagnostics,
CommonMessageProvider messageProvider,
IAnalyzerAssemblyLoader analyzerLoader)
{
var analyzerBuilder = ImmutableArray.CreateBuilder <DiagnosticAnalyzer>();
EventHandler <AnalyzerLoadFailureEventArgs> errorHandler = (o, e) =>
{
var analyzerReference = o as AnalyzerFileReference;
DiagnosticInfo diagnostic;
switch (e.ErrorCode)
{
case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToLoadAnalyzer:
diagnostic = new DiagnosticInfoWithMessageProvider(messageProvider, messageProvider.WRN_UnableToLoadAnalyzer, analyzerReference.FullPath, e.Message);
break;
case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToCreateAnalyzer:
diagnostic = new DiagnosticInfoWithMessageProvider(messageProvider, messageProvider.WRN_AnalyzerCannotBeCreated, e.TypeName, analyzerReference.FullPath, e.Message);
break;
case AnalyzerLoadFailureEventArgs.FailureErrorCode.NoAnalyzers:
diagnostic = new DiagnosticInfoWithMessageProvider(messageProvider, messageProvider.WRN_NoAnalyzerInAssembly, analyzerReference.FullPath);
break;
case AnalyzerLoadFailureEventArgs.FailureErrorCode.None:
default:
return;
}
// Filter this diagnostic based on the compilation options so that /nowarn and /warnaserror etc. take effect.
diagnostic = messageProvider.FilterDiagnosticInfo(diagnostic, this.CompilationOptions);
if (diagnostic != null)
{
diagnostics.Add(diagnostic);
}
};
var resolvedReferences = ArrayBuilder <AnalyzerFileReference> .GetInstance();
foreach (var reference in AnalyzerReferences)
{
var resolvedReference = ResolveAnalyzerReference(reference, analyzerLoader);
if (resolvedReference != null)
{
resolvedReferences.Add(resolvedReference);
// register the reference to the analyzer loader:
analyzerLoader.AddDependencyLocation(resolvedReference.FullPath);
}
else
{
diagnostics.Add(new DiagnosticInfoWithMessageProvider(messageProvider, messageProvider.ERR_MetadataFileNotFound, reference.FilePath));
}
}
// All analyzer references are registered now, we can start loading them:
foreach (var resolvedReference in resolvedReferences)
{
resolvedReference.AnalyzerLoadFailed += errorHandler;
resolvedReference.AddAnalyzers(analyzerBuilder, language);
resolvedReference.AnalyzerLoadFailed -= errorHandler;
}
resolvedReferences.Free();
return(analyzerBuilder.ToImmutable());
}
