internal static int Run(string[] args, BuildPaths buildPaths, TextWriter textWriter, IAnalyzerAssemblyLoader analyzerLoader) { FatalError.Handler = FailFast.OnFatalException; var responseFile = Path.Combine(buildPaths.ClientDirectory, CSharpCompiler.ResponseFileName); var compiler = new Csc(responseFile, buildPaths, args, analyzerLoader); return ConsoleUtil.RunWithUtf8Output(compiler.Arguments.Utf8Output, textWriter, tw => compiler.Run(tw)); }
public TestableCompilerServerHost( IAnalyzerAssemblyLoader loader = null, Func<string, MetadataReferenceProperties, PortableExecutableReference> assemblyReferenceProvider = null) : base(ServerUtil.DefaultClientDirectory, ServerUtil.DefaultSdkDirectory) { AnalyzerAssemblyLoader = loader; AssemblyReferenceProvider = assemblyReferenceProvider; }
internal static int Run(string clientDirectory, string sdkDirectory, string[] args, IAnalyzerAssemblyLoader analyzerLoader) { FatalError.Handler = FailFast.OnFatalException; var responseFile = Path.Combine(clientDirectory, VisualBasicCompiler.ResponseFileName); Vbc compiler = new Vbc(responseFile, clientDirectory, Directory.GetCurrentDirectory(), sdkDirectory, args, analyzerLoader); return ConsoleUtil.RunWithOutput(compiler.Arguments.Utf8Output, (textWriterOut, _) => compiler.Run(textWriterOut)); }
public static int Run(CommandLineParser parser, string responseFile, string[] args, string clientDirectory, string baseDirectory, string sdkDirectory, string additionalReferenceDirectories, IAnalyzerAssemblyLoader analyzerLoader, TextWriter output) { return new PhpCompiler(parser, responseFile, args, clientDirectory, baseDirectory, sdkDirectory, additionalReferenceDirectories, analyzerLoader) .Run(output); }
internal static int Run(IEnumerable<string> arguments, IEnumerable<string> extraArguments, RequestLanguage language, CompileFunc compileFunc, IAnalyzerAssemblyLoader analyzerAssemblyLoader) { var client = new DesktopBuildClient(language, compileFunc, analyzerAssemblyLoader); var clientDir = AppDomain.CurrentDomain.BaseDirectory; var sdkDir = RuntimeEnvironment.GetRuntimeDirectory(); var workingDir = Directory.GetCurrentDirectory(); var buildPaths = new BuildPaths(clientDir: clientDir, workingDir: workingDir, sdkDir: sdkDir); var originalArguments = BuildClient.GetCommandLineArgs(arguments).Concat(extraArguments).ToArray(); return client.RunCompilation(originalArguments, buildPaths).ExitCode; }
public VisualStudioAnalyzer(string fullPath, IVsFileChangeEx fileChangeService, HostDiagnosticUpdateSource hostDiagnosticUpdateSource, ProjectId projectId, Workspace workspace, IAnalyzerAssemblyLoader loader, string language) { _fullPath = fullPath; _tracker = new FileChangeTracker(fileChangeService, fullPath); _tracker.UpdatedOnDisk += OnUpdatedOnDisk; _tracker.StartFileChangeListeningAsync(); _tracker.EnsureSubscription(); _hostDiagnosticUpdateSource = hostDiagnosticUpdateSource; _projectId = projectId; _workspace = workspace; _loader = loader; _language = language; }
public Pchp(string[] args, IAnalyzerAssemblyLoader analyzerLoader) :base( PhpCommandLineParser.Default, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ResponseFileName), CreateArgs(args), AppDomain.CurrentDomain.BaseDirectory, Directory.GetCurrentDirectory(), System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory(), Environment.GetEnvironmentVariable("LIB") + @";C:\Windows\Microsoft.NET\assembly\GAC_MSIL", analyzerLoader) { }
public CommonCompiler(CommandLineParser parser, string responseFile, string[] args, string clientDirectory, string baseDirectory, string sdkDirectoryOpt, string additionalReferenceDirectories, IAnalyzerAssemblyLoader analyzerLoader) { IEnumerable<string> allArgs = args; _clientDirectory = clientDirectory; Debug.Assert(null == responseFile || PathUtilities.IsAbsolute(responseFile)); if (!SuppressDefaultResponseFile(args) && PortableShim.File.Exists(responseFile)) { allArgs = new[] { "@" + responseFile }.Concat(allArgs); } this.Arguments = parser.Parse(allArgs, baseDirectory, sdkDirectoryOpt, additionalReferenceDirectories); this.MessageProvider = parser.MessageProvider; this.AnalyzerLoader = analyzerLoader; }
/// <summary> /// Creates an AnalyzerFileReference with the given <paramref name="fullPath"/> and <paramref name="assemblyLoader"/>. /// </summary> /// <param name="fullPath">Full path of the analyzer assembly.</param> /// <param name="assemblyLoader">Loader for obtaining the <see cref="Assembly"/> from the <paramref name="fullPath"/></param> public AnalyzerFileReference(string fullPath, IAnalyzerAssemblyLoader assemblyLoader) { if (fullPath == null) { throw new ArgumentNullException(nameof(fullPath)); } if (assemblyLoader == null) { throw new ArgumentNullException(nameof(assemblyLoader)); } _fullPath = fullPath; _diagnosticAnalyzers = new Extensions <DiagnosticAnalyzer>(this, IsDiagnosticAnalyzerAttribute); _assemblyLoader = assemblyLoader; }
internal Vbc( string responseFile, BuildPaths buildPaths, string[] args, IAnalyzerAssemblyLoader analyzerLoader ) : base( VisualBasicCommandLineParser.Default, responseFile, args, buildPaths, Environment.GetEnvironmentVariable("LIB"), analyzerLoader ) { }
/// <summary> /// Run a compilation through the compiler server and print the output /// to the console. If the compiler server fails, run the fallback /// compiler. /// </summary> public static int RunWithConsoleOutput( string[] args, string clientDir, string workingDir, string sdkDir, IAnalyzerAssemblyLoader analyzerLoader, RequestLanguage language, Func <string, string, string[], IAnalyzerAssemblyLoader, int> fallbackCompiler) { args = args.Select(arg => arg.Trim()).ToArray(); bool hasShared; string keepAlive; string errorMessage; List <string> parsedArgs; if (!CommandLineParser.TryParseClientArgs( args, out parsedArgs, out hasShared, out keepAlive, out errorMessage)) { Console.Out.WriteLine(errorMessage); return(CommonCompiler.Failed); } if (hasShared) { var responseTask = TryRunServerCompilation( language, clientDir, workingDir, parsedArgs, default(CancellationToken), keepAlive: keepAlive, libEnvVariable: Environment.GetEnvironmentVariable("LIB")); var response = responseTask.Result; if (response != null) { return(HandleResponse(response)); } } return(fallbackCompiler(clientDir, sdkDir, parsedArgs.ToArray(), analyzerLoader)); }
/// <summary> /// Run a compilation through the compiler server and print the output /// to the console. If the compiler server fails, run the fallback /// compiler. /// </summary> public static int RunWithConsoleOutput( string[] args, string clientDir, string workingDir, string sdkDir, IAnalyzerAssemblyLoader analyzerLoader, RequestLanguage language, Func<string, string, string[], IAnalyzerAssemblyLoader, int> fallbackCompiler) { args = args.Select(arg => arg.Trim()).ToArray(); bool hasShared; string keepAlive; string errorMessage; List<string> parsedArgs; if (!CommandLineParser.TryParseClientArgs( args, out parsedArgs, out hasShared, out keepAlive, out errorMessage)) { Console.Out.WriteLine(errorMessage); return CommonCompiler.Failed; } if (hasShared) { var responseTask = TryRunServerCompilation( language, clientDir, workingDir, parsedArgs, default(CancellationToken), keepAlive: keepAlive, libEnvVariable: Environment.GetEnvironmentVariable("LIB")); var response = responseTask.Result; if (response != null) { return HandleResponse(response, clientDir, sdkDir, analyzerLoader, fallbackCompiler, parsedArgs); } } return fallbackCompiler(clientDir, sdkDir, parsedArgs.ToArray(), analyzerLoader); }
internal VisualBasicCompilerServer( Func <string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, BuildPaths buildPaths, string?libDirectory, IAnalyzerAssemblyLoader analyzerLoader ) : this( metadataProvider, Path.Combine(buildPaths.ClientDirectory, ResponseFileName), args, buildPaths, libDirectory, analyzerLoader ) { }
internal CSharpInteractiveCompiler( string responseFile, BuildPaths buildPaths, string[] args, IAnalyzerAssemblyLoader analyzerLoader ) // Unlike C# compiler we do not use LIB environment variable. It's only supported for historical reasons. : base( CSharpCommandLineParser.Script, responseFile, args, buildPaths, null, analyzerLoader ) { }
/// <summary> /// Creates an AnalyzerFileReference with the given <paramref name="fullPath"/> and <paramref name="assemblyLoader"/>. /// </summary> /// <param name="fullPath">Full path of the analyzer assembly.</param> /// <param name="assemblyLoader">Loader for obtaining the <see cref="Assembly"/> from the <paramref name="fullPath"/></param> public AnalyzerFileReference(string fullPath, IAnalyzerAssemblyLoader assemblyLoader) { if (fullPath == null) { throw new ArgumentNullException(nameof(fullPath)); } if (assemblyLoader == null) { throw new ArgumentNullException(nameof(assemblyLoader)); } _fullPath = fullPath; _lazyAllAnalyzers = default(ImmutableArray <DiagnosticAnalyzer>); _lazyAnalyzersPerLanguage = ImmutableDictionary <string, ImmutableArray <DiagnosticAnalyzer> > .Empty; _assemblyLoader = assemblyLoader; }
internal VisualBasicCompilerServer( Func <string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string?responseFile, string[] args, BuildPaths buildPaths, string?libDirectory, IAnalyzerAssemblyLoader analyzerLoader ) : base( VisualBasicCommandLineParser.Default, responseFile, args, buildPaths, libDirectory, analyzerLoader ) { _metadataProvider = metadataProvider; }
public AbstractMSBuildTestFixture(ITestOutputHelper output) : base(output) { _assemblyLoader = new AssemblyLoader(this.LoggerFactory); _analyzerAssemblyLoader = ShadowCopyAnalyzerAssemblyLoader.Instance; // Since we can only load MSBuild once into our process we need to include // prerelease version so that our .NET 7 tests will pass. var configuration = new Dictionary <string, string> { ["sdk:IncludePrereleases"] = bool.TrueString }.ToConfiguration(); _msbuildLocator = MSBuildLocator.CreateDefault(this.LoggerFactory, _assemblyLoader, configuration); // Some tests require MSBuild to be discovered early // to ensure that the Microsoft.Build.* assemblies can be located _msbuildLocator.RegisterDefaultInstance(this.LoggerFactory.CreateLogger("MSBuildTests"), dotNetInfo: null); }
public static int Run( string[] args, string clientDir, string workingDir, string sdkDir, string tempDir, TextWriter textWriter, IAnalyzerAssemblyLoader analyzerLoader ) => Vbc.Run( args, new BuildPaths( clientDir: clientDir, workingDir: workingDir, sdkDir: sdkDir, tempDir: tempDir ), textWriter, analyzerLoader );
public CommonCompiler(CommandLineParser parser, string responseFile, string[] args, string clientDirectory, string baseDirectory, string sdkDirectoryOpt, string additionalReferenceDirectories, IAnalyzerAssemblyLoader assemblyLoader) { IEnumerable<string> allArgs = args; _clientDirectory = clientDirectory; Debug.Assert(null == responseFile || PathUtilities.IsAbsolute(responseFile)); if (!SuppressDefaultResponseFile(args) && File.Exists(responseFile)) { allArgs = new[] { "@" + responseFile }.Concat(allArgs); } this.Arguments = parser.Parse(allArgs, baseDirectory, sdkDirectoryOpt, additionalReferenceDirectories); this.MessageProvider = parser.MessageProvider; this.AssemblyLoader = assemblyLoader; this.EmbeddedSourcePaths = GetEmbedddedSourcePaths(Arguments); if (Arguments.ParseOptions.Features.ContainsKey("debug-determinism")) { EmitDeterminismKey(Arguments, args, baseDirectory, parser); } }
internal static int Run( string[] args, BuildPaths buildPaths, TextWriter textWriter, IAnalyzerAssemblyLoader analyzerLoader ) { FatalError.Handler = FailFast.OnFatalException; var responseFile = Path.Combine( buildPaths.ClientDirectory, VisualBasicCompiler.ResponseFileName ); var compiler = new Vbc(responseFile, buildPaths, args, analyzerLoader); return(ConsoleUtil.RunWithUtf8Output( compiler.Arguments.Utf8Output, textWriter, tw => compiler.Run(tw) )); }
public static bool Check( string baseDirectory, IEnumerable <CommandLineAnalyzerReference> analyzerReferences, IAnalyzerAssemblyLoader loader, ICompilerServerLogger?logger = null) { try { logger?.Log("Begin Analyzer Consistency Check"); return(CheckCore(baseDirectory, analyzerReferences, loader, logger)); } catch (Exception e) { logger?.LogException(e, "Analyzer Consistency Check"); return(false); } finally { logger?.Log("End Analyzer Consistency Check"); } }
public static IServiceProvider Create( ITestOutputHelper testOutput, IOmniSharpEnvironment environment, ILoggerFactory loggerFactory, IAssemblyLoader assemblyLoader, IAnalyzerAssemblyLoader analyzerAssemblyLoader, IMSBuildLocator msbuildLocator, IConfiguration configurationData = null, DotNetCliVersion dotNetCliVersion = DotNetCliVersion.Current, IEventEmitter eventEmitter = null) { eventEmitter = eventEmitter ?? NullEventEmitter.Instance; var dotNetCliService = CreateDotNetCliService(dotNetCliVersion, loggerFactory, eventEmitter); var configuration = CreateConfiguration(configurationData, dotNetCliService); var sharedTextWriter = CreateSharedTextWriter(testOutput); return(new TestServiceProvider( environment, loggerFactory, assemblyLoader, analyzerAssemblyLoader, sharedTextWriter, msbuildLocator, eventEmitter, dotNetCliService, configuration)); }
public static int RunCompiler( string clientDirectory, string[] args, string baseDirectory, string sdkDirectory, string libDirectory, IAnalyzerAssemblyLoader analyzerLoader, TextWriter output, CancellationToken cancellationToken, out bool utf8output) { var compiler = new CSharpCompilerServer(args, clientDirectory, baseDirectory, sdkDirectory, libDirectory, analyzerLoader); utf8output = compiler.Arguments.Utf8Output; foreach (var analyzer in compiler.Arguments.AnalyzerReferences) { CompilerServerFileWatcher.AddPath(analyzer.FilePath); } return(compiler.Run(output, cancellationToken)); }
public static bool Check(string baseDirectory, IEnumerable<CommandLineAnalyzerReference> analyzerReferences, IAnalyzerAssemblyLoader loader, IEnumerable<string> ignorableReferenceNames = null) { if (ignorableReferenceNames == null) { ignorableReferenceNames = s_defaultIgnorableReferenceNames; } try { CompilerServerLogger.Log("Begin Analyzer Consistency Check"); return CheckCore(baseDirectory, analyzerReferences, loader, ignorableReferenceNames); } catch (Exception e) { CompilerServerLogger.LogException(e, "Analyzer Consistency Check"); return false; } finally { CompilerServerLogger.Log("End Analyzer Consistency Check"); } }
public static BuildResponse RunCompiler( string clientDirectory, string[] args, string baseDirectory, string sdkDirectory, string libDirectory, IAnalyzerAssemblyLoader analyzerLoader, CancellationToken cancellationToken) { var compiler = new VisualBasicCompilerServer(args, clientDirectory, baseDirectory, sdkDirectory, libDirectory, analyzerLoader); bool utf8output = compiler.Arguments.Utf8Output; if (!AnalyzerConsistencyChecker.Check(baseDirectory, compiler.Arguments.AnalyzerReferences, analyzerLoader)) { return(new AnalyzerInconsistencyBuildResponse()); } TextWriter output = new StringWriter(CultureInfo.InvariantCulture); int returnCode = compiler.Run(output, cancellationToken); return(new CompletedBuildResponse(returnCode, utf8output, output.ToString(), string.Empty)); }
private TestServiceProvider( IOmniSharpEnvironment environment, ILoggerFactory loggerFactory, IAssemblyLoader assemblyLoader, IAnalyzerAssemblyLoader analyzerAssemblyLoader, ISharedTextWriter sharedTextWriter, IMSBuildLocator msbuildLocator, IEventEmitter eventEmitter, IDotNetCliService dotNetCliService, IConfigurationRoot configuration) { _logger = loggerFactory.CreateLogger <TestServiceProvider>(); var services = _services = new ServiceCollection(); services .AddLogging() .AddOptions() .AddMemoryCache(); services .AddSingleton(environment) .AddSingleton(loggerFactory) .AddSingleton(assemblyLoader) .AddSingleton(sharedTextWriter) .AddSingleton(msbuildLocator) .AddSingleton(eventEmitter) .AddSingleton(dotNetCliService) .AddSingleton(configuration) .AddSingleton(configuration as IConfiguration) .Configure <OmniSharpOptions>(configuration) .PostConfigure <OmniSharpOptions>(OmniSharpOptions.PostConfigure) .AddSingleton(analyzerAssemblyLoader); services.TryAddSingleton(_ => new ManualFileSystemWatcher()); services.TryAddSingleton <IFileSystemNotifier>(_ => _.GetRequiredService <ManualFileSystemWatcher>()); services.TryAddSingleton <IFileSystemWatcher>(_ => _.GetRequiredService <ManualFileSystemWatcher>()); _serviceProvider = services.BuildServiceProvider(); }
public static BuildResponse RunCompiler( string clientDirectory, string[] args, string baseDirectory, string sdkDirectory, string libDirectory, IAnalyzerAssemblyLoader analyzerLoader, CancellationToken cancellationToken) { var compiler = new VisualBasicCompilerServer(args, clientDirectory, baseDirectory, sdkDirectory, libDirectory, analyzerLoader); bool utf8output = compiler.Arguments.Utf8Output; if (!AnalyzerConsistencyChecker.Check(baseDirectory, compiler.Arguments.AnalyzerReferences, analyzerLoader)) { return new AnalyzerInconsistencyBuildResponse(); } TextWriter output = new StringWriter(CultureInfo.InvariantCulture); int returnCode = compiler.Run(output, cancellationToken); return new CompletedBuildResponse(returnCode, utf8output, output.ToString(), string.Empty); }
internal void ResolveAnalyzersFromArguments( string language, List <DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, IAnalyzerAssemblyLoader analyzerLoader, bool skipAnalyzers, out ImmutableArray <DiagnosticAnalyzer> analyzers, out ImmutableArray <ISourceGenerator> generators) { var analyzerBuilder = ImmutableArray.CreateBuilder <DiagnosticAnalyzer>(); var generatorBuilder = ImmutableArray.CreateBuilder <ISourceGenerator>(); EventHandler <AnalyzerLoadFailureEventArgs> errorHandler = (o, e) => { var analyzerReference = o as AnalyzerFileReference; RoslynDebug.Assert(analyzerReference is object); DiagnosticInfo?diagnostic; 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.ReferencesFramework: diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_AnalyzerReferencesFramework, analyzerReference.FullPath, e.TypeName !); break; case AnalyzerLoadFailureEventArgs.FailureErrorCode.ReferencesNewerCompiler: diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_AnalyzerReferencesNewerCompiler, analyzerReference.FullPath, e.ReferencedCompilerVersion !.ToString(), typeof(AnalyzerFileReference).Assembly.GetName().Version !.ToString()); break;
public static IServiceProvider Create( ITestOutputHelper testOutput, IOmniSharpEnvironment environment, ILoggerFactory loggerFactory, IAssemblyLoader assemblyLoader, IAnalyzerAssemblyLoader analyzerAssemblyLoader, IMSBuildLocator msbuildLocator, IEnumerable <KeyValuePair <string, string> > configurationData = null, DotNetCliVersion dotNetCliVersion = DotNetCliVersion.Current, IEventEmitter eventEmitter = null) { eventEmitter = eventEmitter ?? NullEventEmitter.Instance; var dotNetCliService = CreateDotNetCliService(dotNetCliVersion, loggerFactory, eventEmitter); var configuration = CreateConfiguration(configurationData, dotNetCliService); var memoryCache = CreateMemoryCache(); var optionsMonitor = CreateOptionsMonitor(configuration); var sharedTextWriter = CreateSharedTextWriter(testOutput); return(new TestServiceProvider( environment, loggerFactory, assemblyLoader, analyzerAssemblyLoader, memoryCache, sharedTextWriter, msbuildLocator, eventEmitter, dotNetCliService, configuration, optionsMonitor)); }
public ProjectManager( ILoggerFactory loggerFactory, MSBuildOptions options, IEventEmitter eventEmitter, IFileSystemWatcher fileSystemWatcher, MetadataFileReferenceCache metadataFileReferenceCache, PackageDependencyChecker packageDependencyChecker, ProjectLoader projectLoader, OmniSharpWorkspace workspace, IAnalyzerAssemblyLoader analyzerAssemblyLoader, ImmutableArray <IMSBuildEventSink> eventSinks, DotNetInfo dotNetInfo) { _logger = loggerFactory.CreateLogger <ProjectManager>(); _options = options ?? new MSBuildOptions(); _eventEmitter = eventEmitter; _fileSystemWatcher = fileSystemWatcher; _metadataFileReferenceCache = metadataFileReferenceCache; _packageDependencyChecker = packageDependencyChecker; _projectFiles = new ProjectFileInfoCollection(); _failedToLoadProjectFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase); _projectsRequestedOnDemand = new ConcurrentDictionary <string, int>(StringComparer.OrdinalIgnoreCase); _projectLoader = projectLoader; _workspace = workspace; _eventSinks = eventSinks; _dotNetInfo = dotNetInfo; _queue = new BufferBlock <ProjectToUpdate>(); _processLoopCancellation = new CancellationTokenSource(); _processLoopTask = Task.Run(() => ProcessLoopAsync(_processLoopCancellation.Token)); _analyzerAssemblyLoader = analyzerAssemblyLoader; _onDirectoryFileChanged = OnDirectoryFileChanged; if (_options.LoadProjectsOnDemand) { _workspace.AddWaitForProjectModelReadyHandler(WaitForProjectModelReadyAsync); } }
protected CSharpCompiler( CSharpCommandLineParser parser, string?responseFile, string[] args, BuildPaths buildPaths, string?additionalReferenceDirectories, IAnalyzerAssemblyLoader assemblyLoader ) : base( parser, responseFile, args, buildPaths, additionalReferenceDirectories, assemblyLoader ) { _diagnosticFormatter = new CommandLineDiagnosticFormatter( buildPaths.WorkingDirectory, Arguments.PrintFullPaths, Arguments.ShouldIncludeErrorEndLocation ); _tempDirectory = buildPaths.TempDirectory; }
private static int HandleResponse(BuildResponse response, string clientDir, string sdkDir, IAnalyzerAssemblyLoader analyzerLoader, Func<string, string, string[], IAnalyzerAssemblyLoader, int> fallbackCompiler, List<string> parsedArgs) { switch (response.Type) { case BuildResponse.ResponseType.MismatchedVersion: Console.Error.WriteLine(CommandLineParser.MismatchedVersionErrorText); return CommonCompiler.Failed; case BuildResponse.ResponseType.Completed: var completedResponse = (CompletedBuildResponse)response; return ConsoleUtil.RunWithOutput( completedResponse.Utf8Output, (outWriter, errorWriter) => { outWriter.Write(completedResponse.Output); errorWriter.Write(completedResponse.ErrorOutput); return completedResponse.ReturnCode; }); case BuildResponse.ResponseType.AnalyzerInconsistency: return fallbackCompiler(clientDir, sdkDir, parsedArgs.ToArray(), analyzerLoader); default: throw new InvalidOperationException("Encountered unknown response type"); } }
internal VisualBasicCompilerServer(string[] args, string clientDirectory, string baseDirectory, string sdkDirectory, string libDirectory, IAnalyzerAssemblyLoader analyzerLoader) : base(VisualBasicCommandLineParser.Default, clientDirectory != null ? Path.Combine(clientDirectory, ResponseFileName) : null, args, clientDirectory, baseDirectory, sdkDirectory, libDirectory, analyzerLoader) { }
private static IEnumerable <AnalyzerReference> ResolveAnalyzerReferencesForProject(ProjectFileInfo projectFileInfo, IAnalyzerAssemblyLoader analyzerAssemblyLoader) { foreach (var analyzerAssemblyPath in projectFileInfo.Analyzers.Distinct()) { analyzerAssemblyLoader.AddDependencyLocation(analyzerAssemblyPath); } return(projectFileInfo.Analyzers.Select(analyzerCandicatePath => new AnalyzerFileReference(analyzerCandicatePath, analyzerAssemblyLoader))); }
protected CSharpCompiler(CSharpCommandLineParser parser, string responseFile, string[] args, string clientDirectory, string baseDirectory, string sdkDirectoryOpt, string additionalReferenceDirectories, IAnalyzerAssemblyLoader analyzerLoader) : base(parser, responseFile, args, clientDirectory, baseDirectory, sdkDirectoryOpt, additionalReferenceDirectories, analyzerLoader) { _diagnosticFormatter = new CommandLineDiagnosticFormatter(baseDirectory, Arguments.PrintFullPaths, Arguments.ShouldIncludeErrorEndLocation); }
public HostAnalyzerManager(IEnumerable <HostDiagnosticAnalyzerPackage> hostAnalyzerPackages, IAnalyzerAssemblyLoader hostAnalyzerAssemblyLoader, AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource) : this(CreateAnalyzerReferencesFromPackages(hostAnalyzerPackages, new HostAnalyzerReferenceDiagnosticReporter(hostDiagnosticUpdateSource), hostAnalyzerAssemblyLoader), hostAnalyzerPackages.ToImmutableArrayOrEmpty(), hostDiagnosticUpdateSource) { }
internal DesktopBuildClient(RequestLanguage language, CompileFunc compileFunc, IAnalyzerAssemblyLoader analyzerAssemblyLoader) { _language = language; _compileFunc = compileFunc; _analyzerAssemblyLoader = analyzerAssemblyLoader; }
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 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); } }; 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 DiagnosticInfo(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()); }
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 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); } }; 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 DiagnosticInfo(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(); }
private AnalyzerFileReference ResolveAnalyzerReference(CommandLineAnalyzerReference reference, IAnalyzerAssemblyLoader analyzerLoader) { string resolvedPath = FileUtilities.ResolveRelativePath(reference.FilePath, basePath: null, baseDirectory: BaseDirectory, searchPaths: ReferencePaths, fileExists: PortableShim.File.Exists); if (resolvedPath != null) { resolvedPath = FileUtilities.TryNormalizeAbsolutePath(resolvedPath); } if (resolvedPath != null) { return new AnalyzerFileReference(resolvedPath, analyzerLoader); } return null; }
/// <summary> /// Resolves analyzer references stored in <see cref="AnalyzerReferences"/> using given file resolver. /// </summary> /// <param name="analyzerLoader">Load an assembly from a file path</param> /// <returns>Yields resolved <see cref="AnalyzerFileReference"/> or <see cref="UnresolvedAnalyzerReference"/>.</returns> public IEnumerable<AnalyzerReference> ResolveAnalyzerReferences(IAnalyzerAssemblyLoader analyzerLoader) { foreach (CommandLineAnalyzerReference cmdLineReference in AnalyzerReferences) { yield return ResolveAnalyzerReference(cmdLineReference, analyzerLoader) ?? (AnalyzerReference)new UnresolvedAnalyzerReference(cmdLineReference.FilePath); } }
public AnalyzerAssemblyLoader() { _fallbackLoader = new DesktopAnalyzerAssemblyLoader(); }
public static int Run(string[] args, string clientDir, string workingDir, string sdkDir, TextWriter textWriter, IAnalyzerAssemblyLoader analyzerLoader) => Csc.Run(args, new BuildPaths(clientDir: clientDir, workingDir: workingDir, sdkDir: sdkDir), textWriter, analyzerLoader);
internal Vbc(string responseFile, string clientDirectory, string baseDirectory, string sdkDirectory, string[] args, IAnalyzerAssemblyLoader analyzerLoader) : base(VisualBasicCommandLineParser.Default, responseFile, args, clientDirectory, baseDirectory, sdkDirectory, Environment.GetEnvironmentVariable("LIB"), analyzerLoader) { }
public VisualStudioAnalyzer(string fullPath, IVsFileChangeEx fileChangeService, HostDiagnosticUpdateSource hostDiagnosticUpdateSource, ProjectId projectId, Workspace workspace, IAnalyzerAssemblyLoader loader, string language) { _fullPath = fullPath; _tracker = new FileChangeTracker(fileChangeService, fullPath); _tracker.UpdatedOnDisk += OnUpdatedOnDisk; _tracker.StartFileChangeListeningAsync(); _hostDiagnosticUpdateSource = hostDiagnosticUpdateSource; _projectId = projectId; _workspace = workspace; _loader = loader; _language = language; }
internal static DesktopBuildClient CreateBuildClient( RequestLanguage language, CompileFunc compileFunc = null, TextWriter textWriter = null, IAnalyzerAssemblyLoader analyzerAssemblyLoader = null) { compileFunc = compileFunc ?? GetCompileFunc(language); textWriter = textWriter ?? new StringWriter(); analyzerAssemblyLoader = analyzerAssemblyLoader ?? new Mock<IAnalyzerAssemblyLoader>(MockBehavior.Strict).Object; return new DesktopBuildClient(language, compileFunc, analyzerAssemblyLoader); }
internal Csi(string responseFile, string baseDirectory, string[] args, IAnalyzerAssemblyLoader analyzerLoader) : base(CSharpCommandLineParser.Interactive, responseFile, args, Path.GetDirectoryName(typeof(CSharpCompiler).Assembly.Location), baseDirectory, RuntimeEnvironment.GetRuntimeDirectory(), null /* TODO: what to pass as additionalReferencePaths? */, analyzerLoader) { }
private static bool CheckCore(string baseDirectory, IEnumerable<CommandLineAnalyzerReference> analyzerReferences, IAnalyzerAssemblyLoader loader, IEnumerable<string> ignorableReferenceNames) { var resolvedPaths = new List<string>(); foreach (var analyzerReference in analyzerReferences) { string resolvedPath = FileUtilities.ResolveRelativePath(analyzerReference.FilePath, basePath: null, baseDirectory: baseDirectory, searchPaths: SpecializedCollections.EmptyEnumerable<string>(), fileExists: File.Exists); if (File.Exists(resolvedPath)) { resolvedPath = FileUtilities.TryNormalizeAbsolutePath(resolvedPath); if (resolvedPath != null) { resolvedPaths.Add(resolvedPath); } } // Don't worry about paths we can't resolve. The compiler will report an error for that later. } // First, check that the set of references is complete, modulo items in the safe list. foreach (var resolvedPath in resolvedPaths) { var missingDependencies = AssemblyUtilities.IdentifyMissingDependencies(resolvedPath, resolvedPaths); foreach (var missingDependency in missingDependencies) { if (!ignorableReferenceNames.Any(name => missingDependency.Name.StartsWith(name))) { CompilerServerLogger.Log($"Analyzer assembly {resolvedPath} depends on '{missingDependency}' but it was not found."); return false; } } } // Second, load all of the assemblies upfront. foreach (var resolvedPath in resolvedPaths) { loader.AddDependencyLocation(resolvedPath); } var loadedAssemblies = new List<Assembly>(); foreach (var resolvedPath in resolvedPaths) { loadedAssemblies.Add(loader.LoadFromPath(resolvedPath)); } // Third, check that the MVIDs of the files on disk match the MVIDs of the loaded assemblies. for (int i = 0; i < resolvedPaths.Count; i++) { var resolvedPath = resolvedPaths[i]; var loadedAssembly = loadedAssemblies[i]; var resolvedPathMvid = AssemblyUtilities.ReadMvid(resolvedPath); var loadedAssemblyMvid = loadedAssembly.ManifestModule.ModuleVersionId; if (resolvedPathMvid != loadedAssemblyMvid) { CompilerServerLogger.Log($"Analyzer assembly {resolvedPath} has MVID '{resolvedPathMvid}' but loaded assembly '{loadedAssembly.FullName}' has MVID '{loadedAssemblyMvid}'."); return false; } } return true; }
public PhpCompiler(CommandLineParser parser, string responseFile, string[] args, string clientDirectory, string baseDirectory, string sdkDirectory, string additionalReferenceDirectories, IAnalyzerAssemblyLoader analyzerLoader) : base(parser, responseFile, args, clientDirectory, baseDirectory, sdkDirectory, additionalReferenceDirectories, analyzerLoader) { }
internal VisualBasicCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, string clientDirectory, string baseDirectory, string sdkDirectory, string libDirectory, IAnalyzerAssemblyLoader analyzerLoader) : base(VisualBasicCommandLineParser.Default, clientDirectory != null ? Path.Combine(clientDirectory, ResponseFileName) : null, args, clientDirectory, baseDirectory, sdkDirectory, libDirectory, analyzerLoader) { _metadataProvider = metadataProvider; }
public static ProjectInfo CreateProjectInfo(this ProjectFileInfo projectFileInfo, IAnalyzerAssemblyLoader analyzerAssemblyLoader) { var analyzerReferences = ResolveAnalyzerReferencesForProject(projectFileInfo, analyzerAssemblyLoader); return(ProjectInfo.Create( id: projectFileInfo.Id, version: VersionStamp.Create(), name: projectFileInfo.Name, assemblyName: projectFileInfo.AssemblyName, language: LanguageNames.CSharp, filePath: projectFileInfo.FilePath, outputFilePath: projectFileInfo.TargetPath, compilationOptions: projectFileInfo.CreateCompilationOptions(), analyzerReferences: analyzerReferences)); }
public HostAnalyzerManager(Lazy <ImmutableArray <HostDiagnosticAnalyzerPackage> > hostAnalyzerPackages, IAnalyzerAssemblyLoader hostAnalyzerAssemblyLoader, AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource, PrimaryWorkspace primaryWorkspace) : this(new Lazy <ImmutableArray <AnalyzerReference> >(() => CreateAnalyzerReferencesFromPackages(hostAnalyzerPackages.Value, new HostAnalyzerReferenceDiagnosticReporter(hostDiagnosticUpdateSource, primaryWorkspace), hostAnalyzerAssemblyLoader), isThreadSafe : true), hostAnalyzerPackages, hostDiagnosticUpdateSource) { }
internal CSharpCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, BuildPaths buildPaths, string libDirectory, IAnalyzerAssemblyLoader analyzerLoader) : base(CSharpCommandLineParser.Default, buildPaths.ClientDirectory != null ? Path.Combine(buildPaths.ClientDirectory, ResponseFileName) : null, args, buildPaths, libDirectory, analyzerLoader) { _metadataProvider = metadataProvider; }
private AnalyzerFileReference ResolveAnalyzerReference(CommandLineAnalyzerReference reference, IAnalyzerAssemblyLoader analyzerLoader) { string resolvedPath = FileUtilities.ResolveRelativePath(reference.FilePath, basePath: null, baseDirectory: BaseDirectory, searchPaths: ReferencePaths, fileExists: File.Exists); if (resolvedPath != null) { resolvedPath = FileUtilities.TryNormalizeAbsolutePath(resolvedPath); } if (resolvedPath != null) { return(new AnalyzerFileReference(resolvedPath, analyzerLoader)); } return(null); }
internal Csc(string responseFile, BuildPaths buildPaths, string[] args, IAnalyzerAssemblyLoader analyzerLoader) : base(CSharpCommandLineParser.Default, responseFile, args, buildPaths.ClientDirectory, buildPaths.WorkingDirectory, buildPaths.SdkDirectory, Environment.GetEnvironmentVariable("LIB"), analyzerLoader) { }
internal static int Run(IEnumerable <string> arguments, IEnumerable <string> extraArguments, RequestLanguage language, CompileFunc compileFunc, IAnalyzerAssemblyLoader analyzerAssemblyLoader) { var client = new DesktopBuildClient(language, compileFunc, analyzerAssemblyLoader); var clientDir = AppDomain.CurrentDomain.BaseDirectory; var sdkDir = RuntimeEnvironment.GetRuntimeDirectory(); var workingDir = Directory.GetCurrentDirectory(); var buildPaths = new BuildPaths(clientDir: clientDir, workingDir: workingDir, sdkDir: sdkDir); var originalArguments = BuildClient.GetCommandLineArgs(arguments).Concat(extraArguments).ToArray(); return(client.RunCompilation(originalArguments, buildPaths).ExitCode); }
internal CSharpInteractiveCompiler(string responseFile, string baseDirectory, string sdkDirectoryOpt, string[] args, IAnalyzerAssemblyLoader analyzerLoader) // Unlike C# compiler we do not use LIB environment variable. It's only supported for historical reasons. : base(CSharpCommandLineParser.ScriptRunner, responseFile, args, AppContext.BaseDirectory, baseDirectory, sdkDirectoryOpt, null, analyzerLoader) { }
public CommonCompiler(CommandLineParser parser, string responseFile, string[] args, string clientDirectory, string baseDirectory, string sdkDirectoryOpt, string additionalReferenceDirectories, IAnalyzerAssemblyLoader assemblyLoader) { IEnumerable <string> allArgs = args; _clientDirectory = clientDirectory; Debug.Assert(null == responseFile || PathUtilities.IsAbsolute(responseFile)); if (!SuppressDefaultResponseFile(args) && PortableShim.File.Exists(responseFile)) { allArgs = new[] { "@" + responseFile }.Concat(allArgs); } this.Arguments = parser.Parse(allArgs, baseDirectory, sdkDirectoryOpt, additionalReferenceDirectories); this.MessageProvider = parser.MessageProvider; this.AssemblyLoader = assemblyLoader; if (Arguments.ParseOptions.Features.ContainsKey("debug-determinism")) { EmitDeterminismKey(Arguments, args, baseDirectory, parser); } }
private AbstractProject GetOrCreateProjectFromArgumentsAndReferences( IWorkspaceProjectContextFactory workspaceProjectContextFactory, IAnalyzerAssemblyLoader analyzerAssemblyLoader, string projectFilename, IReadOnlyDictionary<string, DeferredProjectInformation> allProjectInfos, IReadOnlyDictionary<string, string> targetPathsToProjectPaths) { var languageName = GetLanguageOfProject(projectFilename); if (languageName == null) { return null; } if (!allProjectInfos.TryGetValue(projectFilename, out var projectInfo)) { // This could happen if we were called recursively about a dangling P2P reference // that isn't actually in the solution. return null; } var commandLineParser = _workspaceServices.GetLanguageServices(languageName).GetService<ICommandLineParserService>(); var projectDirectory = PathUtilities.GetDirectoryName(projectFilename); var commandLineArguments = commandLineParser.Parse( projectInfo.CommandLineArguments, projectDirectory, isInteractive: false, sdkDirectory: RuntimeEnvironment.GetRuntimeDirectory()); // TODO: Should come from sln file? var projectName = PathUtilities.GetFileName(projectFilename, includeExtension: false); // `AbstractProject` only sets the filename if it actually exists. Since we want // our ids to match, mimic that behavior here. var projectId = File.Exists(projectFilename) ? GetOrCreateProjectIdForPath(projectFilename, projectName) : GetOrCreateProjectIdForPath(projectName, projectName); // See if we've already created this project and we're now in a recursive call to // hook up a P2P ref. if (_projectMap.TryGetValue(projectId, out var project)) { return project; } OutputToOutputWindow($"\tCreating '{projectName}':\t{commandLineArguments.SourceFiles.Length} source files,\t{commandLineArguments.MetadataReferences.Length} references."); var solution5 = _serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution5; // If the index is stale, it might give us a path that doesn't exist anymore that the // solution doesn't know about - be resilient to that case. Guid projectGuid; try { projectGuid = solution5.GetGuidOfProjectFile(projectFilename); } catch (ArgumentException) { var message = $"Failed to get the project guid for '{projectFilename}' from the solution, using random guid instead."; Debug.Fail(message); OutputToOutputWindow(message); projectGuid = Guid.NewGuid(); } // NOTE: If the indexing service fails for a project, it will give us an *empty* // target path, which we aren't prepared to handle. Instead, convert it to a *null* // value, which we do handle. var outputPath = projectInfo.TargetPath; if (outputPath == string.Empty) { outputPath = null; } var projectContext = workspaceProjectContextFactory.CreateProjectContext( languageName, projectName, projectFilename, projectGuid: projectGuid, hierarchy: null, binOutputPath: outputPath); project = (AbstractProject)projectContext; projectContext.SetOptions(projectInfo.CommandLineArguments.Join(" ")); foreach (var sourceFile in commandLineArguments.SourceFiles) { projectContext.AddSourceFile(sourceFile.Path); } foreach (var sourceFile in commandLineArguments.AdditionalFiles) { projectContext.AddAdditionalFile(sourceFile.Path); } var addedProjectReferences = new HashSet<string>(); foreach (var projectReferencePath in projectInfo.ReferencedProjectFilePaths) { // NOTE: ImmutableProjects might contain projects for other languages like // Xaml, or Typescript where the project file ends up being identical. var referencedProject = ImmutableProjects.SingleOrDefault( p => (p.Language == LanguageNames.CSharp || p.Language == LanguageNames.VisualBasic) && StringComparer.OrdinalIgnoreCase.Equals(p.ProjectFilePath, projectReferencePath)); if (referencedProject == null) { referencedProject = GetOrCreateProjectFromArgumentsAndReferences( workspaceProjectContextFactory, analyzerAssemblyLoader, projectReferencePath, allProjectInfos, targetPathsToProjectPaths); } var referencedProjectContext = referencedProject as IWorkspaceProjectContext; if (referencedProjectContext != null) { // TODO: Can we get the properties from corresponding metadata reference in // commandLineArguments? addedProjectReferences.Add(projectReferencePath); projectContext.AddProjectReference( referencedProjectContext, new MetadataReferenceProperties()); } else if (referencedProject != null) { // This project was already created by the regular project system. See if we // can find the matching project somehow. var existingReferenceOutputPath = referencedProject?.BinOutputPath; if (existingReferenceOutputPath != null) { addedProjectReferences.Add(projectReferencePath); projectContext.AddMetadataReference( existingReferenceOutputPath, new MetadataReferenceProperties()); } } else { // We don't know how to create this project. Another language or something? OutputToOutputWindow($"Failed to create a project for '{projectReferencePath}'."); } } foreach (var reference in commandLineArguments.ResolveMetadataReferences(project.CurrentCompilationOptions.MetadataReferenceResolver)) { // Some references may fail to be resolved - if they are, we'll still pass them // through, in case they come into existence later (they may be built by other // parts of the build system). var unresolvedReference = reference as UnresolvedMetadataReference; var path = unresolvedReference == null ? ((PortableExecutableReference)reference).FilePath : unresolvedReference.Reference; if (targetPathsToProjectPaths.TryGetValue(path, out var possibleProjectReference) && addedProjectReferences.Contains(possibleProjectReference)) { // We already added a P2P reference for this, we don't need to add the file reference too. continue; } projectContext.AddMetadataReference(path, reference.Properties); } foreach (var reference in commandLineArguments.ResolveAnalyzerReferences(analyzerAssemblyLoader)) { var path = reference.FullPath; if (!PathUtilities.IsAbsolute(path)) { path = PathUtilities.CombineAbsoluteAndRelativePaths( projectDirectory, path); } projectContext.AddAnalyzerReference(path); } return (AbstractProject)projectContext; }