|
8 | 8 | using System.Text; |
9 | 9 | using System.Threading; |
10 | 10 | using System.Threading.Tasks; |
| 11 | +using Basic.CompilerLog.Util; |
11 | 12 | using Microsoft.CodeAnalysis; |
12 | 13 | using Microsoft.CodeAnalysis.CSharp; |
13 | 14 | using Microsoft.CodeAnalysis.Text; |
@@ -102,55 +103,134 @@ public static ExitCode Run(string[] args) |
102 | 103 |
|
103 | 104 | try |
104 | 105 | { |
105 | | - if (options.ProjectsToLoad.Any()) |
| 106 | + var canonicalPathCache = CanonicalPathCache.Create(logger, 1000); |
| 107 | + var pathTransformer = new PathTransformer(canonicalPathCache); |
| 108 | + |
| 109 | + if (options.BinaryLogPath is string binlogPath) |
106 | 110 | { |
107 | | - AddSourceFilesFromProjects(options.ProjectsToLoad, options.CompilerArguments, logger); |
| 111 | + logger.LogInfo(" Running binary log analysis."); |
| 112 | + return RunBinaryLogAnalysis(analyzerStopwatch, options, binlogPath, logger, canonicalPathCache, pathTransformer); |
108 | 113 | } |
109 | | - |
110 | | - var compilerVersion = new CompilerVersion(options); |
111 | | - if (compilerVersion.SkipExtraction) |
| 114 | + else |
112 | 115 | { |
113 | | - logger.LogWarning($" Unrecognized compiler '{compilerVersion.SpecifiedCompiler}' because {compilerVersion.SkipReason}"); |
114 | | - return ExitCode.Ok; |
| 116 | + logger.LogInfo(" Running tracing analysis."); |
| 117 | + return RunTracingAnalysis(analyzerStopwatch, options, logger, canonicalPathCache, pathTransformer); |
115 | 118 | } |
| 119 | + } |
| 120 | + catch (Exception ex) // lgtm[cs/catch-of-all-exceptions] |
| 121 | + { |
| 122 | + logger.LogError($" Unhandled exception: {ex}"); |
| 123 | + return ExitCode.Errors; |
| 124 | + } |
| 125 | + } |
116 | 126 |
|
117 | | - var workingDirectory = Directory.GetCurrentDirectory(); |
118 | | - var compilerArgs = options.CompilerArguments.ToArray(); |
| 127 | + private static ExitCode RunBinaryLogAnalysis(Stopwatch stopwatch, Options options, string binlogPath, ILogger logger, CanonicalPathCache canonicalPathCache, PathTransformer pathTransformer) |
| 128 | + { |
| 129 | + logger.LogInfo($"Reading compiler calls from binary log {binlogPath}"); |
| 130 | + try |
| 131 | + { |
| 132 | + using var fileStream = new FileStream(binlogPath, FileMode.Open, FileAccess.Read, FileShare.Read); |
| 133 | + using var reader = BinaryLogReader.Create(fileStream); |
119 | 134 |
|
120 | | - var canonicalPathCache = CanonicalPathCache.Create(logger, 1000); |
121 | | - var pathTransformer = new PathTransformer(canonicalPathCache); |
| 135 | + // Filter out compiler calls that aren't interesting for examination |
| 136 | + static bool filter(CompilerCall compilerCall) |
| 137 | + { |
| 138 | + return compilerCall.IsCSharp && |
| 139 | + compilerCall.Kind == CompilerCallKind.Regular; |
| 140 | + } |
122 | 141 |
|
123 | | - using var analyser = new TracingAnalyser(new LogProgressMonitor(logger), logger, pathTransformer, canonicalPathCache, options.AssemblySensitiveTrap); |
| 142 | + var allCompilationData = reader.ReadAllCompilationData(filter); |
| 143 | + var allFailed = true; |
124 | 144 |
|
125 | | - var compilerArguments = CSharpCommandLineParser.Default.Parse( |
126 | | - compilerVersion.ArgsWithResponse, |
127 | | - workingDirectory, |
128 | | - compilerVersion.FrameworkPath, |
129 | | - compilerVersion.AdditionalReferenceDirectories |
130 | | - ); |
| 145 | + logger.LogInfo($" Found {allCompilationData.Count} compilations in binary log"); |
131 | 146 |
|
132 | | - if (compilerArguments is null) |
| 147 | + foreach (var compilationData in allCompilationData) |
133 | 148 | { |
134 | | - var sb = new StringBuilder(); |
135 | | - sb.Append(" Failed to parse command line: ").AppendList(" ", compilerArgs); |
136 | | - logger.LogError(sb.ToString()); |
137 | | - ++analyser.CompilationErrors; |
138 | | - return ExitCode.Failed; |
139 | | - } |
| 149 | + if (compilationData.GetCompilationAfterGenerators() is not CSharpCompilation compilation) |
| 150 | + { |
| 151 | + logger.LogError(" Compilation data is not C#"); |
| 152 | + continue; |
| 153 | + } |
140 | 154 |
|
141 | | - if (!analyser.BeginInitialize(compilerVersion.ArgsWithResponse)) |
142 | | - { |
143 | | - logger.LogInfo("Skipping extraction since files have already been extracted"); |
144 | | - return ExitCode.Ok; |
| 155 | + var compilerCall = compilationData.CompilerCall; |
| 156 | + var diagnosticName = compilerCall.GetDiagnosticName(); |
| 157 | + logger.LogInfo($" Processing compilation {diagnosticName}"); |
| 158 | + var compilerArgs = compilerCall.GetArguments(); |
| 159 | + var args = reader.ReadCommandLineArguments(compilerCall); |
| 160 | + |
| 161 | + using var analyser = new BinaryLogAnalyser(new LogProgressMonitor(logger), logger, pathTransformer, canonicalPathCache, options.AssemblySensitiveTrap); |
| 162 | + |
| 163 | + var exit = Analyse(stopwatch, analyser, options, |
| 164 | + references => [() => compilation.References.ForEach(r => references.Add(r))], |
| 165 | + (analyser, syntaxTrees) => [() => syntaxTrees.AddRange(compilation.SyntaxTrees)], |
| 166 | + (syntaxTrees, references) => compilation, |
| 167 | + (compilation, options) => analyser.Initialize(compilerCall.ProjectDirectory, compilerArgs?.ToArray() ?? [], TracingAnalyser.GetOutputName(compilation, args), compilation, options), |
| 168 | + () => { }); |
| 169 | + |
| 170 | + switch (exit) |
| 171 | + { |
| 172 | + case ExitCode.Ok: |
| 173 | + allFailed &= false; |
| 174 | + logger.LogInfo($" Compilation {diagnosticName} succeeded"); |
| 175 | + break; |
| 176 | + case ExitCode.Errors: |
| 177 | + allFailed &= false; |
| 178 | + logger.LogWarning($" Compilation {diagnosticName} had errors"); |
| 179 | + break; |
| 180 | + case ExitCode.Failed: |
| 181 | + logger.LogWarning($" Compilation {diagnosticName} failed"); |
| 182 | + return ExitCode.Failed; |
| 183 | + } |
145 | 184 | } |
| 185 | + return allFailed ? ExitCode.Failed : ExitCode.Ok; |
| 186 | + } |
| 187 | + catch (IOException ex) |
| 188 | + { |
| 189 | + logger.LogError($"Failed to open binary log: {ex.Message}"); |
| 190 | + return ExitCode.Failed; |
| 191 | + } |
| 192 | + } |
| 193 | + |
| 194 | + private static ExitCode RunTracingAnalysis(Stopwatch analyzerStopwatch, Options options, ILogger logger, CanonicalPathCache canonicalPathCache, PathTransformer pathTransformer) |
| 195 | + { |
| 196 | + if (options.ProjectsToLoad.Any()) |
| 197 | + { |
| 198 | + AddSourceFilesFromProjects(options.ProjectsToLoad, options.CompilerArguments, logger); |
| 199 | + } |
146 | 200 |
|
147 | | - return AnalyseTracing(workingDirectory, compilerArgs, analyser, compilerArguments, options, analyzerStopwatch); |
| 201 | + var compilerVersion = new CompilerVersion(options); |
| 202 | + if (compilerVersion.SkipExtraction) |
| 203 | + { |
| 204 | + logger.LogWarning($" Unrecognized compiler '{compilerVersion.SpecifiedCompiler}' because {compilerVersion.SkipReason}"); |
| 205 | + return ExitCode.Ok; |
148 | 206 | } |
149 | | - catch (Exception ex) // lgtm[cs/catch-of-all-exceptions] |
| 207 | + |
| 208 | + var workingDirectory = Directory.GetCurrentDirectory(); |
| 209 | + var compilerArgs = options.CompilerArguments.ToArray(); |
| 210 | + using var analyser = new TracingAnalyser(new LogProgressMonitor(logger), logger, pathTransformer, canonicalPathCache, options.AssemblySensitiveTrap); |
| 211 | + var compilerArguments = CSharpCommandLineParser.Default.Parse( |
| 212 | + compilerVersion.ArgsWithResponse, |
| 213 | + workingDirectory, |
| 214 | + compilerVersion.FrameworkPath, |
| 215 | + compilerVersion.AdditionalReferenceDirectories |
| 216 | + ); |
| 217 | + |
| 218 | + if (compilerArguments is null) |
150 | 219 | { |
151 | | - logger.LogError($" Unhandled exception: {ex}"); |
152 | | - return ExitCode.Errors; |
| 220 | + var sb = new StringBuilder(); |
| 221 | + sb.Append(" Failed to parse command line: ").AppendList(" ", compilerArgs); |
| 222 | + logger.LogError(sb.ToString()); |
| 223 | + ++analyser.CompilationErrors; |
| 224 | + return ExitCode.Failed; |
| 225 | + } |
| 226 | + |
| 227 | + if (!analyser.BeginInitialize(compilerVersion.ArgsWithResponse)) |
| 228 | + { |
| 229 | + logger.LogInfo("Skipping extraction since files have already been extracted"); |
| 230 | + return ExitCode.Ok; |
153 | 231 | } |
| 232 | + |
| 233 | + return AnalyseTracing(workingDirectory, compilerArgs, analyser, compilerArguments, options, analyzerStopwatch); |
154 | 234 | } |
155 | 235 |
|
156 | 236 | private static void AddSourceFilesFromProjects(IEnumerable<string> projectsToLoad, IList<string> compilerArguments, ILogger logger) |
|
0 commit comments