/// <summary>
/// Resolves metadata references stored in command line arguments and reports errors for those that can't be resolved.
/// </summary>
internal List <MetadataReference> ResolveMetadataReferences(
MetadataFileReferenceResolver externalReferenceResolver,
MetadataFileReferenceProvider metadataProvider,
List <DiagnosticInfo> diagnostics,
AssemblyIdentityComparer assemblyIdentityComparer,
TouchedFileLogger touchedFiles,
out MetadataFileReferenceResolver referenceDirectiveResolver)
{
List <MetadataReference> resolved = new List <MetadataReference>();
Arguments.ResolveMetadataReferences(new AssemblyReferenceResolver(externalReferenceResolver, metadataProvider), diagnostics, this.MessageProvider, resolved);
if (Arguments.IsInteractive)
{
referenceDirectiveResolver = externalReferenceResolver;
}
else
{
// when compiling into an assembly (csc/vbc) we only allow #r that match references given on command line:
referenceDirectiveResolver = new ExistingReferencesResolver(
resolved.Where(r => r.Properties.Kind == MetadataImageKind.Assembly).OfType <PortableExecutableReference>().AsImmutable(),
Arguments.ReferencePaths,
Arguments.BaseDirectory,
assemblyIdentityComparer,
touchedFiles);
}
return(resolved);
}
/// <summary>
/// Initializes a new instance of the <see cref="FileResolver"/> class.
/// </summary>
/// <param name="assemblySearchPaths">An ordered set of fully qualified
/// paths which are searched when resolving assembly names.</param>
/// <param name="baseDirectory">Directory used when resolving relative paths.</param>
/// <param name="touchedFiles"></param>
public FileResolver(
IEnumerable <string> assemblySearchPaths,
string baseDirectory,
TouchedFileLogger touchedFiles = null)
: this(assemblySearchPaths.AsImmutableOrNull(), baseDirectory, touchedFiles)
{
}
internal override MetadataFileReferenceResolver GetExternalMetadataResolver(TouchedFileLogger touchedFiles)
{
// We don't log touched files atm.
return new DesktopMetadataReferenceResolver(
new RelativePathReferenceResolver(Arguments.ReferencePaths, Arguments.BaseDirectory),
null,
new GacFileResolver(GacFileResolver.Default.Architectures, CultureInfo.CurrentCulture));
}
public LoggingMetadataFileReferenceResolver(RelativePathResolver pathResolver, Func <string, MetadataReferenceProperties, PortableExecutableReference> provider, TouchedFileLogger loggerOpt)
{
Debug.Assert(pathResolver != null);
Debug.Assert(provider != null);
_pathResolver = pathResolver;
_provider = provider;
_loggerOpt = loggerOpt;
}
public LoggingSourceFileResolver(
ImmutableArray <string> searchPaths,
string baseDirectory,
ImmutableArray <KeyValuePair <string, string> > pathMap,
TouchedFileLogger logger)
: base(searchPaths, baseDirectory, pathMap)
{
_loggerOpt = logger;
}
public LoggingSourceFileResolver(
ImmutableArray<string> searchPaths,
string baseDirectory,
ImmutableArray<KeyValuePair<string, string>> pathMap,
TouchedFileLogger logger)
: base(searchPaths, baseDirectory, pathMap)
{
_loggerOpt = logger;
}
internal override MetadataReferenceResolver GetCommandLineMetadataReferenceResolver(TouchedFileLogger loggerOpt)
{
return new RuntimeMetadataReferenceResolver(
new RelativePathResolver(Arguments.ReferencePaths, Arguments.BaseDirectory),
null,
new GacFileResolver(GacFileResolver.Default.Architectures, CultureInfo.CurrentCulture),
(path, properties) =>
{
loggerOpt?.AddRead(path);
return MetadataReference.CreateFromFile(path);
});
}
/// <summary>
/// Creates an instance of <see cref="DesktopStrongNameProvider"/>.
/// </summary>
/// <param name="keyFileSearchPaths">
/// An ordered set of fully qualified paths which are searched when locating a cryptographic key file.
/// </param>
/// <param name="touchedFiles">
/// Files touched ("used") in process of discovering the key file.
/// </param>
public DesktopStrongNameProvider(
ImmutableArray <string> keyFileSearchPaths = default(ImmutableArray <string>),
TouchedFileLogger touchedFiles = null)
{
if (!keyFileSearchPaths.IsDefault && keyFileSearchPaths.Any(path => !PathUtilities.IsAbsolute(path)))
{
throw new ArgumentException(CodeAnalysisResources.AbsolutePathExpected, "keyFileSearchPaths");
}
this.keyFileSearchPaths = keyFileSearchPaths.NullToEmpty();
this.touchedFiles = touchedFiles;
}
public ExistingReferencesResolver(
ImmutableArray<PortableExecutableReference> availableReferences,
ImmutableArray<string> referencePaths,
string baseDirectory,
AssemblyIdentityComparer assemblyIdentityComparer,
TouchedFileLogger logger)
: base(referencePaths, baseDirectory, logger)
{
Debug.Assert(!availableReferences.Any(r => r.Properties.Kind != MetadataImageKind.Assembly));
_availableReferences = availableReferences;
_assemblyIdentityComparer = assemblyIdentityComparer;
}
public ExistingReferencesResolver(
ImmutableArray <MetadataFileReference> availableReferences,
ImmutableArray <string> referencePaths,
string baseDirectory,
AssemblyIdentityComparer assemblyIdentityComparer,
TouchedFileLogger logger)
: base(referencePaths, baseDirectory, logger)
{
Debug.Assert(!availableReferences.Any(r => r.Properties.Kind != MetadataImageKind.Assembly));
this.availableReferences = availableReferences;
this.assemblyIdentityComparer = assemblyIdentityComparer;
}
/// <summary>
/// Initializes a new instance of the <see cref="FileResolver"/> class.
/// </summary>
/// <param name="assemblySearchPaths">An ordered set of fully qualified
/// paths which are searched when resolving assembly names.</param>
/// <param name="baseDirectory">Directory used when resolving relative paths.</param>
/// <param name="touchedFiles"></param>
public FileResolver(
ImmutableArray <string> assemblySearchPaths,
string baseDirectory,
TouchedFileLogger touchedFiles = null)
{
ValidateSearchPaths(assemblySearchPaths, "assemblySearchPaths");
if (baseDirectory != null && PathUtilities.GetPathKind(baseDirectory) != PathKind.Absolute)
{
throw new ArgumentException(CodeAnalysisResources.AbsolutePathExpected, "baseDirectory");
}
this.assemblySearchPaths = assemblySearchPaths;
this.baseDirectory = baseDirectory;
this.touchedFiles = touchedFiles;
}
/// <summary>
/// Resolves metadata references stored in command line arguments and reports errors for those that can't be resolved.
/// </summary>
internal List <MetadataReference> ResolveMetadataReferences(
MetadataReferenceProvider metadataProvider,
List <DiagnosticInfo> diagnostics,
AssemblyIdentityComparer assemblyIdentityComparer,
TouchedFileLogger touchedFiles,
out FileResolver referenceDirectiveResolver)
{
using (Logger.LogBlock(FunctionId.Common_CommandLineCompiler_ResolveMetadataReferences))
{
string baseDirectory = Arguments.BaseDirectory;
ImmutableArray <string> absoluteReferencePaths = MakeAbsolute(Arguments.ReferencePaths, baseDirectory);
FileResolver externalReferenceResolver = new FileResolver(
absoluteReferencePaths,
baseDirectory,
touchedFiles);
List <MetadataReference> resolved = new List <MetadataReference>();
ResolveMetadataReferencesFromArguments(metadataProvider, diagnostics, externalReferenceResolver, resolved);
if (Arguments.IsInteractive)
{
referenceDirectiveResolver = externalReferenceResolver;
}
else
{
// when compiling into an assembly (csc/vbc) we only allow #r that match references given on command line:
referenceDirectiveResolver = new ExistingReferencesResolver(
resolved.Where(r => r.Properties.Kind == MetadataImageKind.Assembly).OfType <MetadataFileReference>().AsImmutable(),
absoluteReferencePaths,
baseDirectory,
assemblyIdentityComparer,
touchedFiles);
}
return(resolved);
}
}
/// <summary>
/// Resolves metadata references stored in command line arguments and reports errors for those that can't be resolved.
/// </summary>
internal List <MetadataReference> ResolveMetadataReferences(
List <DiagnosticInfo> diagnostics,
TouchedFileLogger touchedFiles,
out MetadataReferenceResolver referenceDirectiveResolver)
{
var commandLineReferenceResolver = GetCommandLineMetadataReferenceResolver(touchedFiles);
List <MetadataReference> resolved = new List <MetadataReference>();
Arguments.ResolveMetadataReferences(commandLineReferenceResolver, diagnostics, this.MessageProvider, resolved);
if (Arguments.IsScriptRunner)
{
referenceDirectiveResolver = commandLineReferenceResolver;
}
else
{
// when compiling into an assembly (csc/vbc) we only allow #r that match references given on command line:
referenceDirectiveResolver = new ExistingReferencesResolver(commandLineReferenceResolver, resolved.ToImmutableArray());
}
return(resolved);
}
protected abstract ImmutableArray <DiagnosticAnalyzer> ResolveAnalyzersFromArguments(List <DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles);
public LoggingMetadataReferencesResolver(ImmutableArray <string> searchPaths, string baseDirectory, TouchedFileLogger logger)
: base(searchPaths, baseDirectory)
{
this.logger = logger;
}
public LoggingStrongNameFileSystem(TouchedFileLogger logger, string tempPath)
: base(tempPath)
{
_loggerOpt = logger;
}
protected abstract ImmutableArray<DiagnosticAnalyzer> ResolveAnalyzersFromArguments(List<DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles);
internal virtual MetadataReferenceResolver GetCommandLineMetadataReferenceResolver(TouchedFileLogger loggerOpt)
{
var pathResolver = new RelativePathResolver(Arguments.ReferencePaths, Arguments.BaseDirectory);
return new LoggingMetadataFileReferenceResolver(pathResolver, GetMetadataProvider(), loggerOpt);
}
internal virtual MetadataFileReferenceResolver GetExternalMetadataResolver(TouchedFileLogger touchedFiles)
{
return CreateLoggingMetadataResolver(touchedFiles);
}
internal ImmutableArray<DiagnosticAnalyzer> ResolveAnalyzersFromArguments(string language, List<DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles, IAnalyzerAssemblyLoader analyzerLoader)
{
var builder = ImmutableArray.CreateBuilder<DiagnosticAnalyzer>();
EventHandler<AnalyzerLoadFailureEventArgs> errorHandler = (o, e) =>
{
var analyzerReference = o as AnalyzerFileReference;
DiagnosticInfo diagnostic = null;
switch (e.ErrorCode)
{
case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToLoadAnalyzer:
diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_UnableToLoadAnalyzer, analyzerReference.FullPath, e.Message);
break;
case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToCreateAnalyzer:
diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_AnalyzerCannotBeCreated, e.TypeName, analyzerReference.FullPath, e.Message);
break;
case AnalyzerLoadFailureEventArgs.FailureErrorCode.NoAnalyzers:
diagnostic = new DiagnosticInfo(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);
}
};
foreach (var reference in AnalyzerReferences)
{
var resolvedReference = ResolveAnalyzerReference(reference, analyzerLoader);
if (resolvedReference != null)
{
resolvedReference.AnalyzerLoadFailed += errorHandler;
resolvedReference.AddAnalyzers(builder, language);
resolvedReference.AnalyzerLoadFailed -= errorHandler;
}
else
{
diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_MetadataFileNotFound, reference.FilePath));
}
}
return builder.ToImmutable();
}
private MetadataFileReferenceResolver CreateLoggingMetadataResolver(TouchedFileLogger logger)
{
MetadataFileReferenceResolver resolver = new RelativePathReferenceResolver(Arguments.ReferencePaths, Arguments.BaseDirectory);
return((logger == null) ? resolver : new LoggingMetadataReferencesResolver(resolver, logger));
}
internal virtual MetadataFileReferenceResolver GetExternalMetadataResolver(TouchedFileLogger touchedFiles)
{
return(CreateLoggingMetadataResolver(touchedFiles));
}
/// <summary>
/// Resolves metadata references stored in command line arguments and reports errors for those that can't be resolved.
/// </summary>
internal List<MetadataReference> ResolveMetadataReferences(
MetadataReferenceResolver externalReferenceResolver,
MetadataReferenceProvider metadataProvider,
List<DiagnosticInfo> diagnostics,
AssemblyIdentityComparer assemblyIdentityComparer,
TouchedFileLogger touchedFiles,
out MetadataReferenceResolver referenceDirectiveResolver)
{
using (Logger.LogBlock(FunctionId.Common_CommandLineCompiler_ResolveMetadataReferences))
{
List<MetadataReference> resolved = new List<MetadataReference>();
ResolveMetadataReferencesFromArguments(externalReferenceResolver, metadataProvider, diagnostics, resolved);
if (Arguments.IsInteractive)
{
referenceDirectiveResolver = externalReferenceResolver;
}
else
{
// when compiling into an assembly (csc/vbc) we only allow #r that match references given on command line:
referenceDirectiveResolver = new ExistingReferencesResolver(
resolved.Where(r => r.Properties.Kind == MetadataImageKind.Assembly).OfType<MetadataFileReference>().AsImmutable(),
Arguments.ReferencePaths,
Arguments.BaseDirectory,
assemblyIdentityComparer,
touchedFiles);
}
return resolved;
}
}
internal ImmutableArray <DiagnosticAnalyzer> ResolveAnalyzersFromArguments(string language, List <DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles, IAnalyzerAssemblyLoader analyzerLoader)
{
var builder = ImmutableArray.CreateBuilder <DiagnosticAnalyzer>();
EventHandler <AnalyzerLoadFailureEventArgs> errorHandler = (o, e) =>
{
var analyzerReference = o as AnalyzerFileReference;
DiagnosticInfo diagnostic = null;
switch (e.ErrorCode)
{
case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToLoadAnalyzer:
diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_UnableToLoadAnalyzer, analyzerReference.FullPath, e.Message);
break;
case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToCreateAnalyzer:
diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_AnalyzerCannotBeCreated, e.TypeName, analyzerReference.FullPath, e.Message);
break;
case AnalyzerLoadFailureEventArgs.FailureErrorCode.NoAnalyzers:
diagnostic = new DiagnosticInfo(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);
}
};
foreach (var reference in AnalyzerReferences)
{
var resolvedReference = ResolveAnalyzerReference(reference, analyzerLoader);
if (resolvedReference != null)
{
resolvedReference.AnalyzerLoadFailed += errorHandler;
resolvedReference.AddAnalyzers(builder, language);
resolvedReference.AnalyzerLoadFailed -= errorHandler;
}
else
{
diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_MetadataFileNotFound, reference.FilePath));
}
}
return(builder.ToImmutable());
}
protected abstract Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger);
public LoggingStrongNameProvider(ImmutableArray <string> keyFileSearchPaths, TouchedFileLogger logger)
: base(keyFileSearchPaths)
{
_loggerOpt = logger;
}
internal override MetadataReferenceResolver GetCommandLineMetadataReferenceResolver(TouchedFileLogger loggerOpt)
{
return CommandLineRunner.GetMetadataReferenceResolver(Arguments, loggerOpt);
}
internal virtual MetadataReferenceResolver GetCommandLineMetadataReferenceResolver(TouchedFileLogger loggerOpt)
{
var pathResolver = new RelativePathResolver(Arguments.ReferencePaths, Arguments.BaseDirectory);
return(new LoggingMetadataFileReferenceResolver(pathResolver, GetMetadataProvider(), loggerOpt));
}
public LoggingStrongNameFileSystem(TouchedFileLogger logger)
{
_loggerOpt = logger;
}
internal ImmutableArray<IDiagnosticAnalyzer> ResolveAnalyzersFromArguments(List<DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles)
{
var builder = ImmutableArray.CreateBuilder<IDiagnosticAnalyzer>();
foreach (var reference in AnalyzerReferences)
{
var resolvedReference = ResolveAnalyzerReference(reference);
if (resolvedReference != null)
{
resolvedReference.AddAnalyzers(builder, diagnostics, messageProvider);
}
else
{
diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_MetadataFileNotFound, reference.FilePath));
}
}
return builder.ToImmutable();
}
public abstract Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger, ErrorLogger errorLoggerOpt);
/// <summary>
/// Resolves metadata references stored in command line arguments and reports errors for those that can't be resolved.
/// </summary>
internal List<MetadataReference> ResolveMetadataReferences(
MetadataFileReferenceResolver externalReferenceResolver,
MetadataFileReferenceProvider metadataProvider,
List<DiagnosticInfo> diagnostics,
AssemblyIdentityComparer assemblyIdentityComparer,
TouchedFileLogger touchedFiles,
out MetadataFileReferenceResolver referenceDirectiveResolver)
{
List<MetadataReference> resolved = new List<MetadataReference>();
Arguments.ResolveMetadataReferences(new AssemblyReferenceResolver(externalReferenceResolver, metadataProvider), diagnostics, this.MessageProvider, resolved);
if (Arguments.IsInteractive)
{
referenceDirectiveResolver = externalReferenceResolver;
}
else
{
// when compiling into an assembly (csc/vbc) we only allow #r that match references given on command line:
referenceDirectiveResolver = new ExistingReferencesResolver(
CreateLoggingMetadataResolver(touchedFiles),
resolved.Where(r => r.Properties.Kind == MetadataImageKind.Assembly).OfType<PortableExecutableReference>().AsImmutable(),
assemblyIdentityComparer);
}
return resolved;
}
internal CompilerEmitStreamProvider(CommonCompiler compiler, TouchedFileLogger touchedFileLogger, string filePath)
{
_compiler = compiler;
_touchedFileLogger = touchedFileLogger;
_filePath = filePath;
}
public abstract Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger, ErrorLogger errorLogger);
public LoggingStrongNameProvider(ImmutableArray<string> keyFileSearchPaths, TouchedFileLogger logger, string tempPath)
: base(keyFileSearchPaths, tempPath)
{
_loggerOpt = logger;
}
protected virtual ImmutableArray<AdditionalTextFile> ResolveAdditionalFilesFromArguments(List<DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFilesLogger)
{
var builder = ImmutableArray.CreateBuilder<AdditionalTextFile>();
foreach (var file in Arguments.AdditionalFiles)
{
builder.Add(new AdditionalTextFile(file, this));
}
return builder.ToImmutableArray();
}
public LoggingMetadataReferencesResolver(ImmutableArray<string> searchPaths, string baseDirectory, TouchedFileLogger logger)
: base(searchPaths, baseDirectory)
{
this.logger = logger;
}
/// <summary>
/// Resolves metadata references stored in command line arguments and reports errors for those that can't be resolved.
/// </summary>
internal List<MetadataReference> ResolveMetadataReferences(
List<DiagnosticInfo> diagnostics,
TouchedFileLogger touchedFiles,
out MetadataReferenceResolver referenceDirectiveResolver)
{
var commandLineReferenceResolver = GetCommandLineMetadataReferenceResolver(touchedFiles);
List<MetadataReference> resolved = new List<MetadataReference>();
Arguments.ResolveMetadataReferences(commandLineReferenceResolver, diagnostics, this.MessageProvider, resolved);
if (Arguments.IsScriptRunner)
{
referenceDirectiveResolver = commandLineReferenceResolver;
}
else
{
// when compiling into an assembly (csc/vbc) we only allow #r that match references given on command line:
referenceDirectiveResolver = new ExistingReferencesResolver(commandLineReferenceResolver, resolved.ToImmutableArray());
}
return resolved;
}
protected abstract Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger);
public LoggingSourceFileResolver(ImmutableArray<string> searchPaths, string baseDirectory, TouchedFileLogger logger)
: base(searchPaths, baseDirectory)
{
_logger = logger;
}
internal ImmutableArray <IDiagnosticAnalyzer> ResolveAnalyzersFromArguments(List <DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles)
{
var builder = ImmutableArray.CreateBuilder <IDiagnosticAnalyzer>();
foreach (var reference in AnalyzerReferences)
{
var resolvedReference = ResolveAnalyzerReference(reference);
if (resolvedReference != null)
{
resolvedReference.AddAnalyzers(builder, diagnostics, messageProvider);
}
else
{
diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_MetadataFileNotFound, reference.FilePath));
}
}
return(builder.ToImmutable());
}
public LoggingStrongNameProvider(ImmutableArray<string> keyFileSearchPaths, TouchedFileLogger logger)
: base(keyFileSearchPaths)
{
this.logger = logger;
}
public LoggingMetadataReferencesResolver(MetadataFileReferenceResolver resolver, TouchedFileLogger logger)
{
Debug.Assert(logger != null);
_resolver = resolver;
_logger = logger;
}
internal virtual MetadataFileReferenceResolver GetExternalMetadataResolver(TouchedFileLogger touchedFiles)
{
return(new LoggingMetadataReferencesResolver(Arguments.ReferencePaths, Arguments.BaseDirectory, touchedFiles));
}
private MetadataFileReferenceResolver CreateLoggingMetadataResolver(TouchedFileLogger logger)
{
MetadataFileReferenceResolver resolver = new RelativePathReferenceResolver(Arguments.ReferencePaths, Arguments.BaseDirectory);
return (logger == null) ? resolver : new LoggingMetadataReferencesResolver(resolver, logger);
}
internal virtual MetadataFileReferenceResolver GetExternalMetadataResolver(TouchedFileLogger touchedFiles)
{
return new LoggingMetadataReferencesResolver(Arguments.ReferencePaths, Arguments.BaseDirectory, touchedFiles);
}
internal ImmutableArray <DiagnosticAnalyzer> ResolveAnalyzersFromArguments(string language, List <DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles)
{
var builder = ImmutableArray.CreateBuilder <DiagnosticAnalyzer>();
EventHandler <AnalyzerLoadFailureEventArgs> errorHandler = (o, e) =>
{
var analyzerReference = o as AnalyzerFileReference;
switch (e.ErrorCode)
{
case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToLoadAnalyzer:
diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.WRN_UnableToLoadAnalyzer, analyzerReference.FullPath, e.Exception.Message));
break;
case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToCreateAnalyzer:
diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.WRN_AnalyzerCannotBeCreated, e.TypeName, analyzerReference.FullPath, e.Exception.Message));
break;
case AnalyzerLoadFailureEventArgs.FailureErrorCode.NoAnalyzers:
diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.WRN_NoAnalyzerInAssembly, analyzerReference.FullPath));
break;
case AnalyzerLoadFailureEventArgs.FailureErrorCode.None:
default:
return;
}
};
foreach (var reference in AnalyzerReferences)
{
var resolvedReference = ResolveAnalyzerReference(reference);
if (resolvedReference != null)
{
resolvedReference.AnalyzerLoadFailed += errorHandler;
resolvedReference.AddAnalyzers(builder, language);
resolvedReference.AnalyzerLoadFailed -= errorHandler;
}
else
{
diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_MetadataFileNotFound, reference.FilePath));
}
}
return(builder.ToImmutable());
}
protected virtual ImmutableArray <AdditionalTextFile> ResolveAdditionalFilesFromArguments(List <DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFilesLogger)
{
var builder = ImmutableArray.CreateBuilder <AdditionalTextFile>();
foreach (var file in Arguments.AdditionalFiles)
{
builder.Add(new AdditionalTextFile(file, this));
}
return(builder.ToImmutableArray());
}
public LoggingMetadataReferencesResolver(MetadataFileReferenceResolver resolver, TouchedFileLogger logger)
{
Debug.Assert(logger != null);
_resolver = resolver;
_logger = logger;
}
public LoggingSourceFileResolver(ImmutableArray <string> searchPaths, string baseDirectory, TouchedFileLogger logger)
: base(searchPaths, baseDirectory)
{
_loggerOpt = logger;
}
/// <summary>
/// Resolves analyzers stored in command line arguments and reports errors for those that can't be resolved.
/// </summary>
protected List <IDiagnosticAnalyzer> ResolveAnalyzersFromArguments(List <DiagnosticInfo> diagnostics, TouchedFileLogger touchedFiles)
{
List <IDiagnosticAnalyzer> analyzers = new List <IDiagnosticAnalyzer>();
string baseDirectory = Arguments.BaseDirectory;
ImmutableArray <string> absoluteReferencePaths = MakeAbsolute(Arguments.ReferencePaths, baseDirectory);
var fileResolver = new FileResolver(
absoluteReferencePaths,
baseDirectory,
touchedFiles);
foreach (CommandLineAnalyzer cmdLineAnalyzer in Arguments.Analyzers)
{
var analyzersFromAssembly = cmdLineAnalyzer.Resolve(fileResolver, diagnostics, MessageProvider);
if (analyzersFromAssembly != null)
{
// If there are no analyzers in this assembly, let the user know.
if (analyzersFromAssembly.IsEmpty())
{
diagnostics.Add(new DiagnosticInfo(MessageProvider, MessageProvider.WRN_NoAnalyzerInAssembly, cmdLineAnalyzer.Analyzer));
}
else
{
foreach (var analyzer in analyzersFromAssembly)
{
if (!AreAllDiagnosticsSuppressed(analyzer, Arguments.CompilationOptions.SpecificDiagnosticOptions))
{
analyzers.Add(analyzer);
}
}
}
}
}
return(analyzers);
}
