Rename Extractor to ExtractionContext

tamasvajk · tamasvajk · commit cdca6078284a · 2024-06-12T11:43:19.000+02:00
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Assembly.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Assembly.cs
@@ -17,23 +17,23 @@ private Assembly(Context cx, Microsoft.CodeAnalysis.Location? init)
             isOutputAssembly = init is null;
             if (isOutputAssembly)
             {
-                assemblyPath = cx.Extractor.OutputPath;
+                assemblyPath = cx.ExtractionContext.OutputPath;
                 assembly = cx.Compilation.Assembly;
             }
             else
             {
                 assembly = init!.MetadataModule!.ContainingAssembly;
                 var identity = assembly.Identity;
                 var idString = identity.Name + " " + identity.Version;
-                assemblyPath = cx.Extractor.GetAssemblyFile(idString);
+                assemblyPath = cx.ExtractionContext.GetAssemblyFile(idString);
             }
         }
 
         public override void Populate(TextWriter trapFile)
         {
             if (assemblyPath is not null)
             {
-                var isBuildlessOutputAssembly = isOutputAssembly && Context.Extractor.Mode.HasFlag(ExtractorMode.Standalone);
+                var isBuildlessOutputAssembly = isOutputAssembly && Context.ExtractionContext.Mode.HasFlag(ExtractorMode.Standalone);
                 var identifier = isBuildlessOutputAssembly
                     ? ""
                     : assembly.ToString() ?? "";
@@ -74,7 +74,7 @@ public static Assembly CreateOutputAssembly(Context cx)
 
         public override void WriteId(EscapingTextWriter trapFile)
         {
-            if (isOutputAssembly && Context.Extractor.Mode.HasFlag(ExtractorMode.Standalone))
+            if (isOutputAssembly && Context.ExtractionContext.Mode.HasFlag(ExtractorMode.Standalone))
             {
                 trapFile.Write("buildlessOutputAssembly");
             }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Compilations/Compilation.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Compilations/Compilation.cs
@@ -18,8 +18,8 @@ internal class Compilation : CachedEntity<object>
 #nullable disable warnings
         private Compilation(Context cx) : base(cx, null)
         {
-            cwd = cx.Extractor.Cwd;
-            args = cx.Extractor.Args;
+            cwd = cx.ExtractionContext.Cwd;
+            args = cx.ExtractionContext.Args;
             hashCode = cwd.GetHashCode();
             for (var i = 0; i < args.Length; i++)
             {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Compilations/CompilerDiagnostic.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Compilations/CompilerDiagnostic.cs
@@ -28,7 +28,7 @@ protected override void Populate(TextWriter trapFile)
             {
                 if (messageCount == limit + 1)
                 {
-                    Context.Extractor.Logger.LogWarning($"Stopped logging {key} compiler diagnostics for the current compilation after reaching {limit}");
+                    Context.ExtractionContext.Logger.LogWarning($"Stopped logging {key} compiler diagnostics for the current compilation after reaching {limit}");
                 }
 
                 return;
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Invocation.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Invocation.cs
@@ -133,7 +133,7 @@ public IMethodSymbol? TargetSymbol
                         .Where(method => method.Parameters.Length >= Syntax.ArgumentList.Arguments.Count)
                         .Where(method => method.Parameters.Count(p => !p.HasExplicitDefaultValue) <= Syntax.ArgumentList.Arguments.Count);
 
-                    return Context.Extractor.Mode.HasFlag(ExtractorMode.Standalone) ?
+                    return Context.ExtractionContext.Mode.HasFlag(ExtractorMode.Standalone) ?
                         candidates.FirstOrDefault() :
                         candidates.SingleOrDefault();
                 }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/File.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/File.cs
@@ -61,7 +61,7 @@ public override void Populate(TextWriter trapFile)
                 }
             }
 
-            trapFile.file_extraction_mode(this, Context.Extractor.Mode);
+            trapFile.file_extraction_mode(this, Context.ExtractionContext.Mode);
         }
 
         private bool IsPossiblyTextFile()
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/OrdinaryMethod.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/OrdinaryMethod.cs
@@ -63,7 +63,7 @@ Symbol.ContainingType is INamedTypeSymbol nt &&
         {
             if (method.MethodKind == MethodKind.ReducedExtension)
             {
-                cx.Extractor.Logger.Log(Semmle.Util.Logging.Severity.Warning, "Reduced extension method symbols should not be directly extracted.");
+                cx.ExtractionContext.Logger.Log(Semmle.Util.Logging.Severity.Warning, "Reduced extension method symbols should not be directly extracted.");
             }
 
             return OrdinaryMethodFactory.Instance.CreateEntityFromSymbol(cx, method);
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs
@@ -36,7 +36,7 @@ public override void Populate(TextWriter trapFile)
             if (Symbol.TypeKind == TypeKind.Error)
             {
                 UnknownType.Create(Context); // make sure this exists so we can use it in `TypeRef::getReferencedType`
-                Context.Extractor.MissingType(Symbol.ToString()!, Context.FromSource);
+                Context.ExtractionContext.MissingType(Symbol.ToString()!, Context.FromSource);
                 return;
             }
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/UsingDirective.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/UsingDirective.cs
@@ -36,7 +36,7 @@ protected override void Populate(TextWriter trapFile)
                 }
                 else
                 {
-                    Context.Extractor.MissingNamespace(name.ToFullString(), Context.FromSource);
+                    Context.ExtractionContext.MissingNamespace(name.ToFullString(), Context.FromSource);
                     Context.ModelError(node, "Namespace not found");
                     return;
                 }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Extractor/Analyser.cs b/csharp/extractor/Semmle.Extraction.CSharp/Extractor/Analyser.cs
@@ -19,7 +19,7 @@ namespace Semmle.Extraction.CSharp
     /// </summary>
     public class Analyser : IDisposable
     {
-        protected Extraction.Extractor? extractor;
+        protected ExtractionContext? ExtractionContext;
         protected CSharpCompilation? compilation;
         protected CommonOptions? options;
         private protected Entities.Compilation? compilationEntity;
@@ -108,12 +108,12 @@ protected void SetReferencePaths()
                         var def = reader.GetAssemblyDefinition();
                         assemblyIdentity = reader.GetString(def.Name) + " " + def.Version;
                     }
-                    extractor.SetAssemblyFile(assemblyIdentity, refPath);
+                    ExtractionContext.SetAssemblyFile(assemblyIdentity, refPath);
 
                 }
                 catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
                 {
-                    extractor.Message(new Message("Exception reading reference file", reference.FilePath, null, ex.StackTrace));
+                    ExtractionContext.Message(new Message("Exception reading reference file", reference.FilePath, null, ex.StackTrace));
                 }
             }
         }
@@ -158,7 +158,7 @@ private void DoAnalyseReferenceAssembly(PortableExecutableReference r)
 
                     if (compilation.GetAssemblyOrModuleSymbol(r) is IAssemblySymbol assembly)
                     {
-                        var cx = new Context(extractor, compilation, trapWriter, new AssemblyScope(assembly, assemblyPath), addAssemblyTrapPrefix);
+                        var cx = new Context(ExtractionContext, compilation, trapWriter, new AssemblyScope(assembly, assemblyPath), addAssemblyTrapPrefix);
 
                         foreach (var module in assembly.Modules)
                         {
@@ -201,7 +201,7 @@ private void DoExtractTree(SyntaxTree tree)
 
                 if (!upToDate)
                 {
-                    var cx = new Context(extractor, compilation, trapWriter, new SourceScope(tree), addAssemblyTrapPrefix);
+                    var cx = new Context(ExtractionContext, compilation, trapWriter, new SourceScope(tree), addAssemblyTrapPrefix);
                     // Ensure that the file itself is populated in case the source file is totally empty
                     var root = tree.GetRoot();
                     Entities.File.Create(cx, root.SyntaxTree.FilePath);
@@ -223,15 +223,15 @@ private void DoExtractTree(SyntaxTree tree)
             }
             catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
             {
-                extractor.Message(new Message($"Unhandled exception processing syntax tree. {ex.Message}", tree.FilePath, null, ex.StackTrace));
+                ExtractionContext.Message(new Message($"Unhandled exception processing syntax tree. {ex.Message}", tree.FilePath, null, ex.StackTrace));
             }
         }
 
         private void DoAnalyseCompilation()
         {
             try
             {
-                var assemblyPath = extractor.OutputPath;
+                var assemblyPath = ExtractionContext.OutputPath;
                 var stopwatch = new Stopwatch();
                 stopwatch.Start();
                 var currentTaskId = IncrementTaskCount();
@@ -241,11 +241,11 @@ private void DoAnalyseCompilation()
                 var assembly = compilation.Assembly;
                 var trapWriter = transformedAssemblyPath.CreateTrapWriter(Logger, options.TrapCompression, discardDuplicates: false);
                 compilationTrapFile = trapWriter;  // Dispose later
-                var cx = new Context(extractor, compilation, trapWriter, new AssemblyScope(assembly, assemblyPath), addAssemblyTrapPrefix);
+                var cx = new Context(ExtractionContext, compilation, trapWriter, new AssemblyScope(assembly, assemblyPath), addAssemblyTrapPrefix);
 
                 compilationEntity = Entities.Compilation.Create(cx);
 
-                extractor.CompilationInfos.ForEach(ci => trapWriter.Writer.compilation_info(compilationEntity, ci.key, ci.value));
+                ExtractionContext.CompilationInfos.ForEach(ci => trapWriter.Writer.compilation_info(compilationEntity, ci.key, ci.value));
 
                 ReportProgressTaskDone(currentTaskId, assemblyPath, trapWriter.TrapFile, stopwatch.Elapsed, AnalysisAction.Extracted);
             }
@@ -328,7 +328,7 @@ public virtual void Dispose()
         /// <summary>
         /// Number of errors encountered during extraction.
         /// </summary>
-        private int ExtractorErrors => extractor?.Errors ?? 0;
+        private int ExtractorErrors => ExtractionContext?.Errors ?? 0;
 
         /// <summary>
         /// Number of errors encountered by the compiler.
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Extractor/Context.cs b/csharp/extractor/Semmle.Extraction.CSharp/Extractor/Context.cs
@@ -77,7 +77,7 @@ internal void CacheLambdaParameterSymbol(IParameterSymbol param, SyntaxNode synt
 
         internal CommentProcessor CommentGenerator { get; } = new CommentProcessor();
 
-        public Context(Extraction.Extractor e, Compilation c, TrapWriter trapWriter, IExtractionScope scope, bool addAssemblyTrapPrefix)
+        public Context(ExtractionContext e, Compilation c, TrapWriter trapWriter, IExtractionScope scope, bool addAssemblyTrapPrefix)
             : base(e, trapWriter, addAssemblyTrapPrefix)
         {
             Compilation = c;
@@ -187,13 +187,13 @@ public string TryAdjustRelativeMappedFilePath(string mappedToPath, string mapped
                 try
                 {
                     var fullPath = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(mappedFromPath)!, mappedToPath));
-                    Extractor.Logger.LogDebug($"Found relative path in line mapping: '{mappedToPath}', interpreting it as '{fullPath}'");
+                    ExtractionContext.Logger.LogDebug($"Found relative path in line mapping: '{mappedToPath}', interpreting it as '{fullPath}'");
 
                     mappedToPath = fullPath;
                 }
                 catch (Exception e)
                 {
-                    Extractor.Logger.LogDebug($"Failed to compute absolute path for relative path in line mapping: '{mappedToPath}': {e}");
+                    ExtractionContext.Logger.LogDebug($"Failed to compute absolute path for relative path in line mapping: '{mappedToPath}': {e}");
                 }
             }
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Extractor/StandaloneAnalyser.cs b/csharp/extractor/Semmle.Extraction.CSharp/Extractor/StandaloneAnalyser.cs
@@ -17,17 +17,17 @@ public StandaloneAnalyser(IProgressMonitor pm, ILogger logger, PathTransformer p
         public void Initialize(string outputPath, IEnumerable<(string, string)> compilationInfos, CSharpCompilation compilationIn, CommonOptions options)
         {
             compilation = compilationIn;
-            extractor = new Extraction.Extractor(Directory.GetCurrentDirectory(), [], outputPath, compilationInfos, Logger, PathTransformer, ExtractorMode.Standalone, options.QlTest);
+            ExtractionContext = new ExtractionContext(Directory.GetCurrentDirectory(), [], outputPath, compilationInfos, Logger, PathTransformer, ExtractorMode.Standalone, options.QlTest);
             this.options = options;
             LogExtractorInfo();
             SetReferencePaths();
         }
 
 #nullable disable warnings
 
-        public IEnumerable<string> MissingTypes => extractor.MissingTypes;
+        public IEnumerable<string> MissingTypes => ExtractionContext.MissingTypes;
 
-        public IEnumerable<string> MissingNamespaces => extractor.MissingNamespaces;
+        public IEnumerable<string> MissingNamespaces => ExtractionContext.MissingNamespaces;
 
 #nullable restore warnings
     }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Extractor/TracingAnalyser.cs b/csharp/extractor/Semmle.Extraction.CSharp/Extractor/TracingAnalyser.cs
@@ -47,7 +47,7 @@ public void EndInitialize(
                 throw new InternalError("EndInitialize called without BeginInitialize returning true");
             this.options = options;
             this.compilation = compilation;
-            this.extractor = new Extraction.Extractor(cwd, args, GetOutputName(compilation, commandLineArguments), [], Logger, PathTransformer, ExtractorMode.None, options.QlTest);
+            this.ExtractionContext = new ExtractionContext(cwd, args, GetOutputName(compilation, commandLineArguments), [], Logger, PathTransformer, ExtractorMode.None, options.QlTest);
             var errorCount = LogDiagnostics(compilation);
 
             SetReferencePaths();
diff --git a/csharp/extractor/Semmle.Extraction/Context.cs b/csharp/extractor/Semmle.Extraction/Context.cs
@@ -18,7 +18,7 @@ public class Context
         /// <summary>
         /// Access various extraction functions, e.g. logger, trap writer.
         /// </summary>
-        public Extractor Extractor { get; }
+        public ExtractionContext ExtractionContext { get; }
 
         /// <summary>
         /// Access to the trap file.
@@ -190,9 +190,9 @@ public void PopulateAll()
             }
         }
 
-        protected Context(Extractor extractor, TrapWriter trapWriter, bool shouldAddAssemblyTrapPrefix = false)
+        protected Context(ExtractionContext extractor, TrapWriter trapWriter, bool shouldAddAssemblyTrapPrefix = false)
         {
-            Extractor = extractor;
+            ExtractionContext = extractor;
             TrapWriter = trapWriter;
             ShouldAddAssemblyTrapPrefix = shouldAddAssemblyTrapPrefix;
         }
@@ -274,7 +274,7 @@ private void Populate(ISymbol? optionalSymbol, CachedEntity entity)
 
             bool duplicationGuard, deferred;
 
-            if (Extractor.Mode is ExtractorMode.Standalone)
+            if (ExtractionContext.Mode is ExtractorMode.Standalone)
             {
                 duplicationGuard = false;
                 deferred = false;
@@ -398,7 +398,7 @@ private void ExtractionError(string message, ISymbol? optionalSymbol, Entity opt
         private void ExtractionError(Message msg)
         {
             new ExtractionMessage(this, msg);
-            Extractor.Message(msg);
+            ExtractionContext.Message(msg);
         }
 
         private void ExtractionError(InternalError error)
@@ -408,7 +408,7 @@ private void ExtractionError(InternalError error)
 
         private void ReportError(InternalError error)
         {
-            if (!Extractor.Mode.HasFlag(ExtractorMode.Standalone))
+            if (!ExtractionContext.Mode.HasFlag(ExtractorMode.Standalone))
                 throw error;
 
             ExtractionError(error);
diff --git a/csharp/extractor/Semmle.Extraction/Entities/Base/Entity.cs b/csharp/extractor/Semmle.Extraction/Entities/Base/Entity.cs
@@ -40,7 +40,7 @@ public void DefineLabel(TextWriter trapFile)
             catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
             {
                 trapFile.WriteLine("\"");
-                Context.Extractor.Message(new Message($"Unhandled exception generating id: {ex.Message}", ToString() ?? "", null, ex.StackTrace));
+                Context.ExtractionContext.Message(new Message($"Unhandled exception generating id: {ex.Message}", ToString() ?? "", null, ex.StackTrace));
             }
             trapFile.WriteLine();
         }
diff --git a/csharp/extractor/Semmle.Extraction/Entities/ExtractionMessage.cs b/csharp/extractor/Semmle.Extraction/Entities/ExtractionMessage.cs
@@ -25,7 +25,7 @@ protected override void Populate(TextWriter trapFile)
             {
                 if (messageCount == limit + 1)
                 {
-                    Context.Extractor.Logger.LogWarning($"Stopped logging extractor messages after reaching {limit}");
+                    Context.ExtractionContext.Logger.LogWarning($"Stopped logging extractor messages after reaching {limit}");
                 }
                 return;
             }
diff --git a/csharp/extractor/Semmle.Extraction/Entities/File.cs b/csharp/extractor/Semmle.Extraction/Entities/File.cs
@@ -8,7 +8,7 @@ protected File(Context cx, string path)
             : base(cx, path)
         {
             originalPath = path;
-            transformedPathLazy = new Lazy<PathTransformer.ITransformedPath>(() => Context.Extractor.PathTransformer.Transform(originalPath));
+            transformedPathLazy = new Lazy<PathTransformer.ITransformedPath>(() => Context.ExtractionContext.PathTransformer.Transform(originalPath));
         }
 
         protected readonly string originalPath;
diff --git a/csharp/extractor/Semmle.Extraction/Extractor/ExtractionContext.cs b/csharp/extractor/Semmle.Extraction/Extractor/ExtractionContext.cs
@@ -7,7 +7,7 @@ namespace Semmle.Extraction
     /// <summary>
     /// Implementation of the main extractor state.
     /// </summary>
-    public class Extractor
+    public class ExtractionContext
     {
         public string Cwd { get; init; }
         public string[] Args { get; init; }
@@ -18,7 +18,7 @@ public class Extractor
         /// <summary>
         /// Creates a new extractor instance for one compilation unit.
         /// </summary>
-        public Extractor(string cwd, string[] args, string outputPath, IEnumerable<CompilationInfo> compilationInfos, ILogger logger, PathTransformer pathTransformer, ExtractorMode mode, bool isQlTest)
+        public ExtractionContext(string cwd, string[] args, string outputPath, IEnumerable<CompilationInfo> compilationInfos, ILogger logger, PathTransformer pathTransformer, ExtractorMode mode, bool isQlTest)
         {
             OutputPath = outputPath;
             Logger = logger;

Original file line number	Diff line number	Diff line change
`@@ -17,23 +17,23 @@ private Assembly(Context cx, Microsoft.CodeAnalysis.Location? init)`
`17`	`17`	`isOutputAssembly = init is null;`
`18`	`18`	`if (isOutputAssembly)`
`19`	`19`	`{`
`20`		`- assemblyPath = cx.Extractor.OutputPath;`
	`20`	`+ assemblyPath = cx.ExtractionContext.OutputPath;`
`21`	`21`	`assembly = cx.Compilation.Assembly;`
`22`	`22`	`}`
`23`	`23`	`else`
`24`	`24`	`{`
`25`	`25`	`assembly = init!.MetadataModule!.ContainingAssembly;`
`26`	`26`	`var identity = assembly.Identity;`
`27`	`27`	`var idString = identity.Name + " " + identity.Version;`
`28`		`- assemblyPath = cx.Extractor.GetAssemblyFile(idString);`
	`28`	`+ assemblyPath = cx.ExtractionContext.GetAssemblyFile(idString);`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`public override void Populate(TextWriter trapFile)`
`33`	`33`	`{`
`34`	`34`	`if (assemblyPath is not null)`
`35`	`35`	`{`
`36`		`- var isBuildlessOutputAssembly = isOutputAssembly && Context.Extractor.Mode.HasFlag(ExtractorMode.Standalone);`
	`36`	`+ var isBuildlessOutputAssembly = isOutputAssembly && Context.ExtractionContext.Mode.HasFlag(ExtractorMode.Standalone);`
`37`	`37`	`var identifier = isBuildlessOutputAssembly`
`38`	`38`	`? ""`
`39`	`39`	`: assembly.ToString() ?? "";`
`@@ -74,7 +74,7 @@ public static Assembly CreateOutputAssembly(Context cx)`
`74`	`74`
`75`	`75`	`public override void WriteId(EscapingTextWriter trapFile)`
`76`	`76`	`{`
`77`		`- if (isOutputAssembly && Context.Extractor.Mode.HasFlag(ExtractorMode.Standalone))`
	`77`	`+ if (isOutputAssembly && Context.ExtractionContext.Mode.HasFlag(ExtractorMode.Standalone))`
`78`	`78`	`{`
`79`	`79`	`trapFile.Write("buildlessOutputAssembly");`
`80`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,8 +18,8 @@ internal class Compilation : CachedEntity<object>`
`18`	`18`	`#nullable disable warnings`
`19`	`19`	`private Compilation(Context cx) : base(cx, null)`
`20`	`20`	`{`
`21`		`- cwd = cx.Extractor.Cwd;`
`22`		`- args = cx.Extractor.Args;`
	`21`	`+ cwd = cx.ExtractionContext.Cwd;`
	`22`	`+ args = cx.ExtractionContext.Args;`
`23`	`23`	`hashCode = cwd.GetHashCode();`
`24`	`24`	`for (var i = 0; i < args.Length; i++)`
`25`	`25`	`{`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ protected override void Populate(TextWriter trapFile)`
`28`	`28`	`{`
`29`	`29`	`if (messageCount == limit + 1)`
`30`	`30`	`{`
`31`		`- Context.Extractor.Logger.LogWarning($"Stopped logging {key} compiler diagnostics for the current compilation after reaching {limit}");`
	`31`	`+ Context.ExtractionContext.Logger.LogWarning($"Stopped logging {key} compiler diagnostics for the current compilation after reaching {limit}");`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ public IMethodSymbol? TargetSymbol`
`133`	`133`	`.Where(method => method.Parameters.Length >= Syntax.ArgumentList.Arguments.Count)`
`134`	`134`	`.Where(method => method.Parameters.Count(p => !p.HasExplicitDefaultValue) <= Syntax.ArgumentList.Arguments.Count);`
`135`	`135`
`136`		`- return Context.Extractor.Mode.HasFlag(ExtractorMode.Standalone) ?`
	`136`	`+ return Context.ExtractionContext.Mode.HasFlag(ExtractorMode.Standalone) ?`
`137`	`137`	`candidates.FirstOrDefault() :`
`138`	`138`	`candidates.SingleOrDefault();`
`139`	`139`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ public override void Populate(TextWriter trapFile)`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`		`- trapFile.file_extraction_mode(this, Context.Extractor.Mode);`
	`64`	`+ trapFile.file_extraction_mode(this, Context.ExtractionContext.Mode);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`private bool IsPossiblyTextFile()`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ Symbol.ContainingType is INamedTypeSymbol nt &&`
`63`	`63`	`{`
`64`	`64`	`if (method.MethodKind == MethodKind.ReducedExtension)`
`65`	`65`	`{`
`66`		`- cx.Extractor.Logger.Log(Semmle.Util.Logging.Severity.Warning, "Reduced extension method symbols should not be directly extracted.");`
	`66`	`+ cx.ExtractionContext.Logger.Log(Semmle.Util.Logging.Severity.Warning, "Reduced extension method symbols should not be directly extracted.");`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`return OrdinaryMethodFactory.Instance.CreateEntityFromSymbol(cx, method);`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public override void Populate(TextWriter trapFile)`
`36`	`36`	`if (Symbol.TypeKind == TypeKind.Error)`
`37`	`37`	`{`
`38`	`38`	UnknownType.Create(Context); // make sure this exists so we can use it in `TypeRef::getReferencedType`
`39`		`- Context.Extractor.MissingType(Symbol.ToString()!, Context.FromSource);`
	`39`	`+ Context.ExtractionContext.MissingType(Symbol.ToString()!, Context.FromSource);`
`40`	`40`	`return;`
`41`	`41`	`}`
`42`	`42`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ protected override void Populate(TextWriter trapFile)`
`36`	`36`	`}`
`37`	`37`	`else`
`38`	`38`	`{`
`39`		`- Context.Extractor.MissingNamespace(name.ToFullString(), Context.FromSource);`
	`39`	`+ Context.ExtractionContext.MissingNamespace(name.ToFullString(), Context.FromSource);`
`40`	`40`	`Context.ModelError(node, "Namespace not found");`
`41`	`41`	`return;`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ namespace Semmle.Extraction.CSharp`
`19`	`19`	`/// </summary>`
`20`	`20`	`public class Analyser : IDisposable`
`21`	`21`	`{`
`22`		`- protected Extraction.Extractor? extractor;`
	`22`	`+ protected ExtractionContext? ExtractionContext;`
`23`	`23`	`protected CSharpCompilation? compilation;`
`24`	`24`	`protected CommonOptions? options;`
`25`	`25`	`private protected Entities.Compilation? compilationEntity;`
`@@ -108,12 +108,12 @@ protected void SetReferencePaths()`
`108`	`108`	`var def = reader.GetAssemblyDefinition();`
`109`	`109`	`assemblyIdentity = reader.GetString(def.Name) + " " + def.Version;`
`110`	`110`	`}`
`111`		`- extractor.SetAssemblyFile(assemblyIdentity, refPath);`
	`111`	`+ ExtractionContext.SetAssemblyFile(assemblyIdentity, refPath);`
`112`	`112`
`113`	`113`	`}`
`114`	`114`	`catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`115`	`115`	`{`
`116`		`- extractor.Message(new Message("Exception reading reference file", reference.FilePath, null, ex.StackTrace));`
	`116`	`+ ExtractionContext.Message(new Message("Exception reading reference file", reference.FilePath, null, ex.StackTrace));`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`	`}`
`@@ -158,7 +158,7 @@ private void DoAnalyseReferenceAssembly(PortableExecutableReference r)`
`158`	`158`
`159`	`159`	`if (compilation.GetAssemblyOrModuleSymbol(r) is IAssemblySymbol assembly)`
`160`	`160`	`{`
`161`		`- var cx = new Context(extractor, compilation, trapWriter, new AssemblyScope(assembly, assemblyPath), addAssemblyTrapPrefix);`
	`161`	`+ var cx = new Context(ExtractionContext, compilation, trapWriter, new AssemblyScope(assembly, assemblyPath), addAssemblyTrapPrefix);`
`162`	`162`
`163`	`163`	`foreach (var module in assembly.Modules)`
`164`	`164`	`{`
`@@ -201,7 +201,7 @@ private void DoExtractTree(SyntaxTree tree)`
`201`	`201`
`202`	`202`	`if (!upToDate)`
`203`	`203`	`{`
`204`		`- var cx = new Context(extractor, compilation, trapWriter, new SourceScope(tree), addAssemblyTrapPrefix);`
	`204`	`+ var cx = new Context(ExtractionContext, compilation, trapWriter, new SourceScope(tree), addAssemblyTrapPrefix);`
`205`	`205`	`// Ensure that the file itself is populated in case the source file is totally empty`
`206`	`206`	`var root = tree.GetRoot();`
`207`	`207`	`Entities.File.Create(cx, root.SyntaxTree.FilePath);`
`@@ -223,15 +223,15 @@ private void DoExtractTree(SyntaxTree tree)`
`223`	`223`	`}`
`224`	`224`	`catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`225`	`225`	`{`
`226`		`- extractor.Message(new Message($"Unhandled exception processing syntax tree. {ex.Message}", tree.FilePath, null, ex.StackTrace));`
	`226`	`+ ExtractionContext.Message(new Message($"Unhandled exception processing syntax tree. {ex.Message}", tree.FilePath, null, ex.StackTrace));`
`227`	`227`	`}`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`private void DoAnalyseCompilation()`
`231`	`231`	`{`
`232`	`232`	`try`
`233`	`233`	`{`
`234`		`- var assemblyPath = extractor.OutputPath;`
	`234`	`+ var assemblyPath = ExtractionContext.OutputPath;`
`235`	`235`	`var stopwatch = new Stopwatch();`
`236`	`236`	`stopwatch.Start();`
`237`	`237`	`var currentTaskId = IncrementTaskCount();`
`@@ -241,11 +241,11 @@ private void DoAnalyseCompilation()`
`241`	`241`	`var assembly = compilation.Assembly;`
`242`	`242`	`var trapWriter = transformedAssemblyPath.CreateTrapWriter(Logger, options.TrapCompression, discardDuplicates: false);`
`243`	`243`	`compilationTrapFile = trapWriter; // Dispose later`
`244`		`- var cx = new Context(extractor, compilation, trapWriter, new AssemblyScope(assembly, assemblyPath), addAssemblyTrapPrefix);`
	`244`	`+ var cx = new Context(ExtractionContext, compilation, trapWriter, new AssemblyScope(assembly, assemblyPath), addAssemblyTrapPrefix);`
`245`	`245`
`246`	`246`	`compilationEntity = Entities.Compilation.Create(cx);`
`247`	`247`
`248`		`- extractor.CompilationInfos.ForEach(ci => trapWriter.Writer.compilation_info(compilationEntity, ci.key, ci.value));`
	`248`	`+ ExtractionContext.CompilationInfos.ForEach(ci => trapWriter.Writer.compilation_info(compilationEntity, ci.key, ci.value));`
`249`	`249`
`250`	`250`	`ReportProgressTaskDone(currentTaskId, assemblyPath, trapWriter.TrapFile, stopwatch.Elapsed, AnalysisAction.Extracted);`
`251`	`251`	`}`
`@@ -328,7 +328,7 @@ public virtual void Dispose()`
`328`	`328`	`/// <summary>`
`329`	`329`	`/// Number of errors encountered during extraction.`
`330`	`330`	`/// </summary>`
`331`		`- private int ExtractorErrors => extractor?.Errors ?? 0;`
	`331`	`+ private int ExtractorErrors => ExtractionContext?.Errors ?? 0;`
`332`	`332`
`333`	`333`	`/// <summary>`
`334`	`334`	`/// Number of errors encountered by the compiler.`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ internal void CacheLambdaParameterSymbol(IParameterSymbol param, SyntaxNode synt`
`77`	`77`
`78`	`78`	`internal CommentProcessor CommentGenerator { get; } = new CommentProcessor();`
`79`	`79`
`80`		`- public Context(Extraction.Extractor e, Compilation c, TrapWriter trapWriter, IExtractionScope scope, bool addAssemblyTrapPrefix)`
	`80`	`+ public Context(ExtractionContext e, Compilation c, TrapWriter trapWriter, IExtractionScope scope, bool addAssemblyTrapPrefix)`
`81`	`81`	`: base(e, trapWriter, addAssemblyTrapPrefix)`
`82`	`82`	`{`
`83`	`83`	`Compilation = c;`
`@@ -187,13 +187,13 @@ public string TryAdjustRelativeMappedFilePath(string mappedToPath, string mapped`
`187`	`187`	`try`
`188`	`188`	`{`
`189`	`189`	`var fullPath = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(mappedFromPath)!, mappedToPath));`
`190`		`- Extractor.Logger.LogDebug($"Found relative path in line mapping: '{mappedToPath}', interpreting it as '{fullPath}'");`
	`190`	`+ ExtractionContext.Logger.LogDebug($"Found relative path in line mapping: '{mappedToPath}', interpreting it as '{fullPath}'");`
`191`	`191`
`192`	`192`	`mappedToPath = fullPath;`
`193`	`193`	`}`
`194`	`194`	`catch (Exception e)`
`195`	`195`	`{`
`196`		`- Extractor.Logger.LogDebug($"Failed to compute absolute path for relative path in line mapping: '{mappedToPath}': {e}");`
	`196`	`+ ExtractionContext.Logger.LogDebug($"Failed to compute absolute path for relative path in line mapping: '{mappedToPath}': {e}");`
`197`	`197`	`}`
`198`	`198`	`}`
`199`	`199`