/// <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; }
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 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); }