Extend base context in CIL project

tamasvajk · tamasvajk · commit 539fdf952a82 · 2021-02-24T16:21:19.000+01:00
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Context.Factories.cs b/csharp/extractor/Semmle.Extraction.CIL/Context.Factories.cs
@@ -27,10 +27,10 @@ public T Populate<T>(T e) where T : IExtractedEntity
             }
             else
             {
-                e.Label = Cx.GetNewLabel();
-                Cx.DefineLabel(e, Cx.TrapWriter.Writer, Cx.Extractor);
+                e.Label = GetNewLabel();
+                DefineLabel(e, TrapWriter.Writer, Extractor);
                 ids.Add(e, e.Label);
-                Cx.PopulateLater(() =>
+                PopulateLater(() =>
                 {
                     foreach (var c in e.Contents)
                         c.Extract(this);
@@ -42,7 +42,7 @@ public T Populate<T>(T e) where T : IExtractedEntity
 
                 if (debugLabels.TryGetValue(id, out var previousEntity))
                 {
-                    Cx.Extractor.Message(new Message("Duplicate trap ID", id, null, severity: Util.Logging.Severity.Warning));
+                    Extractor.Message(new Message("Duplicate trap ID", id, null, severity: Util.Logging.Severity.Warning));
                 }
                 else
                 {
@@ -74,9 +74,9 @@ public PrimitiveType Create(PrimitiveTypeCode code)
             {
                 e = new PrimitiveType(this, code)
                 {
-                    Label = Cx.GetNewLabel()
+                    Label = GetNewLabel()
                 };
-                Cx.DefineLabel(e, Cx.TrapWriter.Writer, Cx.Extractor);
+                DefineLabel(e, TrapWriter.Writer, Extractor);
                 primitiveTypes[(int)code] = e;
             }
 
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Context.cs b/csharp/extractor/Semmle.Extraction.CIL/Context.cs
@@ -10,12 +10,10 @@ namespace Semmle.Extraction.CIL
     /// Adds additional context that is specific for CIL extraction.
     /// One context = one DLL/EXE.
     /// </summary>
-    public sealed partial class Context : IDisposable
+    public sealed partial class Context : Extraction.Context, IDisposable
     {
         private readonly FileStream stream;
         private Entities.Assembly? assemblyNull;
-
-        public Extraction.Context Cx { get; }
         public MetadataReader MdReader { get; }
         public PEReader PeReader { get; }
         public string AssemblyPath { get; }
@@ -26,9 +24,9 @@ public Entities.Assembly Assembly
         }
         public PDB.IPdb? Pdb { get; }
 
-        public Context(Extraction.Context cx, string assemblyPath, bool extractPdbs)
+        public Context(Extractor extractor, TrapWriter trapWriter, string assemblyPath, bool extractPdbs)
+            : base(extractor, trapWriter)
         {
-            this.Cx = cx;
             this.AssemblyPath = assemblyPath;
             stream = File.OpenRead(assemblyPath);
             PeReader = new PEReader(stream, PEStreamOptions.PrefetchEntireImage);
@@ -51,7 +49,7 @@ public Context(Extraction.Context cx, string assemblyPath, bool extractPdbs)
                 Pdb = PDB.PdbReader.Create(assemblyPath, PeReader);
                 if (Pdb != null)
                 {
-                    cx.Extractor.Logger.Log(Util.Logging.Severity.Info, string.Format("Found PDB information for {0}", assemblyPath));
+                    Extractor.Logger.Log(Util.Logging.Severity.Info, string.Format("Found PDB information for {0}", assemblyPath));
                 }
             }
         }
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/Assembly.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/Assembly.cs
@@ -76,7 +76,7 @@ public override IEnumerable<IExtractionProduct> Contents
                     }
                     catch (InternalError e)
                     {
-                        Cx.Cx.ExtractionError("Error processing type definition", e.Message, GeneratedLocation.Create(Cx.Cx), e.StackTrace);
+                        Cx.ExtractionError("Error processing type definition", e.Message, GeneratedLocation.Create(Cx), e.StackTrace);
                     }
 
                     // Limitation of C#: Cannot yield return inside a try-catch.
@@ -93,7 +93,7 @@ public override IEnumerable<IExtractionProduct> Contents
                     }
                     catch (InternalError e)
                     {
-                        Cx.Cx.ExtractionError("Error processing bytecode", e.Message, GeneratedLocation.Create(Cx.Cx), e.StackTrace);
+                        Cx.ExtractionError("Error processing bytecode", e.Message, GeneratedLocation.Create(Cx), e.StackTrace);
                     }
 
                     if (product != null)
@@ -102,11 +102,11 @@ public override IEnumerable<IExtractionProduct> Contents
             }
         }
 
-        private static void ExtractCIL(Extraction.Context cx, string assemblyPath, bool extractPdbs)
+        private static void ExtractCIL(Extractor extractor, TrapWriter trapWriter, bool extractPdbs)
         {
-            using var cilContext = new Context(cx, assemblyPath, extractPdbs);
+            using var cilContext = new Context(extractor, trapWriter, extractor.OutputPath, extractPdbs);
             cilContext.Populate(new Assembly(cilContext));
-            cilContext.Cx.PopulateAll();
+            cilContext.PopulateAll();
         }
 
         /// <summary>
@@ -135,8 +135,7 @@ public static void ExtractCIL(Layout layout, string assemblyPath, ILogger logger
                 trapFile = trapWriter.TrapFile;
                 if (nocache || !System.IO.File.Exists(trapFile))
                 {
-                    var cx = new Extraction.Context(extractor, trapWriter);
-                    ExtractCIL(cx, assemblyPath, extractPdbs);
+                    ExtractCIL(extractor, trapWriter, extractPdbs);
                     extracted = true;
                 }
             }
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/Attribute.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/Attribute.cs
@@ -45,7 +45,7 @@ public override IEnumerable<IExtractionProduct> Contents
                 }
                 catch
                 {
-                    Cx.Cx.Extractor.Logger.Log(Util.Logging.Severity.Info,
+                    Cx.Extractor.Logger.Log(Util.Logging.Severity.Info,
                         $"Attribute decoding is partial. Decoding attribute {constructor.DeclaringType.GetQualifiedName()} failed on {@object}.");
                     yield break;
                 }
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/Base/LabelledEntity.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/Base/LabelledEntity.cs
@@ -11,11 +11,10 @@ namespace Semmle.Extraction.CIL
     public abstract class LabelledEntity : Extraction.LabelledEntity, IExtractedEntity
     {
         // todo: with .NET 5 this can override the base context, and change the return type.
-        public Context Cx { get; }
+        public Context Cx => (Context)base.Context;
 
-        protected LabelledEntity(Context cx) : base(cx.Cx)
+        protected LabelledEntity(Context cx) : base(cx)
         {
-            this.Cx = cx;
         }
 
         public override Microsoft.CodeAnalysis.Location ReportingLocation => throw new NotImplementedException();
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/Base/Tuple.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/Base/Tuple.cs
@@ -14,7 +14,7 @@ public Tuple(string name, params object[] args)
 
         public void Extract(Context cx)
         {
-            cx.Cx.TrapWriter.Emit(tuple);
+            cx.TrapWriter.Emit(tuple);
         }
 
         public override string ToString() => tuple.ToString();
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/Base/UnlabelledEntity.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/Base/UnlabelledEntity.cs
@@ -10,11 +10,10 @@ namespace Semmle.Extraction.CIL
     public abstract class UnlabelledEntity : Extraction.UnlabelledEntity, IExtractedEntity
     {
         // todo: with .NET 5 this can override the base context, and change the return type.
-        public Context Cx { get; }
+        public Context Cx => (Context)base.Context;
 
-        protected UnlabelledEntity(Context cx) : base(cx.Cx)
+        protected UnlabelledEntity(Context cx) : base(cx)
         {
-            Cx = cx;
         }
 
         public override Microsoft.CodeAnalysis.Location ReportingLocation => throw new NotImplementedException();
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/CustomAttributeDecoder.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/CustomAttributeDecoder.cs
@@ -40,11 +40,11 @@ public PrimitiveTypeCode GetUnderlyingEnumType(Type type)
 
             if (wellKnownEnums.TryGetValue(name, out var code))
             {
-                cx.Cx.Extractor.Logger.Log(Util.Logging.Severity.Debug, $"Using hard coded underlying enum type for {name}");
+                cx.Extractor.Logger.Log(Util.Logging.Severity.Debug, $"Using hard coded underlying enum type for {name}");
                 return code;
             }
 
-            cx.Cx.Extractor.Logger.Log(Util.Logging.Severity.Info, $"Couldn't get underlying enum type for {name}");
+            cx.Extractor.Logger.Log(Util.Logging.Severity.Info, $"Couldn't get underlying enum type for {name}");
 
             // We can't fall back to Int32, because the type returned here defines how many bytes are read from the
             // stream and how those bytes are interpreted.
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/File.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/File.cs
@@ -11,7 +11,7 @@ public class File : LabelledEntity, IFileOrFolder
         public File(Context cx, string path) : base(cx)
         {
             this.OriginalPath = path;
-            TransformedPath = cx.Cx.Extractor.PathTransformer.Transform(OriginalPath);
+            TransformedPath = Cx.Extractor.PathTransformer.Transform(OriginalPath);
         }
 
         public override void WriteId(TextWriter trapFile)
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/Instruction.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/Instruction.cs
@@ -476,7 +476,7 @@ public IEnumerable<IExtractionProduct> JumpContents(Dictionary<int, Instruction>
                 // TODO: Find a solution to this.
 
                 // For now, just log the error
-                Cx.Cx.ExtractionError("A CIL instruction jumps outside the current method", null, Extraction.Entities.GeneratedLocation.Create(Cx.Cx), "", Util.Logging.Severity.Warning);
+                Cx.ExtractionError("A CIL instruction jumps outside the current method", null, Extraction.Entities.GeneratedLocation.Create(Cx), "", Util.Logging.Severity.Warning);
             }
         }
     }
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/PdbSourceFile.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/PdbSourceFile.cs
@@ -21,9 +21,9 @@ public override IEnumerable<IExtractionProduct> Contents
                 var text = file.Contents;
 
                 if (text == null)
-                    Cx.Cx.Extractor.Logger.Log(Util.Logging.Severity.Warning, string.Format("PDB source file {0} could not be found", OriginalPath));
+                    Cx.Extractor.Logger.Log(Util.Logging.Severity.Warning, string.Format("PDB source file {0} could not be found", OriginalPath));
                 else
-                    Cx.Cx.TrapWriter.Archive(TransformedPath, text);
+                    Cx.TrapWriter.Archive(TransformedPath, text);
 
                 yield return Tuples.file_extraction_mode(this, 2);
             }

Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,10 @@ public T Populate<T>(T e) where T : IExtractedEntity`
`27`	`27`	`}`
`28`	`28`	`else`
`29`	`29`	`{`
`30`		`- e.Label = Cx.GetNewLabel();`
`31`		`- Cx.DefineLabel(e, Cx.TrapWriter.Writer, Cx.Extractor);`
	`30`	`+ e.Label = GetNewLabel();`
	`31`	`+ DefineLabel(e, TrapWriter.Writer, Extractor);`
`32`	`32`	`ids.Add(e, e.Label);`
`33`		`- Cx.PopulateLater(() =>`
	`33`	`+ PopulateLater(() =>`
`34`	`34`	`{`
`35`	`35`	`foreach (var c in e.Contents)`
`36`	`36`	`c.Extract(this);`
`@@ -42,7 +42,7 @@ public T Populate<T>(T e) where T : IExtractedEntity`
`42`	`42`
`43`	`43`	`if (debugLabels.TryGetValue(id, out var previousEntity))`
`44`	`44`	`{`
`45`		`- Cx.Extractor.Message(new Message("Duplicate trap ID", id, null, severity: Util.Logging.Severity.Warning));`
	`45`	`+ Extractor.Message(new Message("Duplicate trap ID", id, null, severity: Util.Logging.Severity.Warning));`
`46`	`46`	`}`
`47`	`47`	`else`
`48`	`48`	`{`
`@@ -74,9 +74,9 @@ public PrimitiveType Create(PrimitiveTypeCode code)`
`74`	`74`	`{`
`75`	`75`	`e = new PrimitiveType(this, code)`
`76`	`76`	`{`
`77`		`- Label = Cx.GetNewLabel()`
	`77`	`+ Label = GetNewLabel()`
`78`	`78`	`};`
`79`		`- Cx.DefineLabel(e, Cx.TrapWriter.Writer, Cx.Extractor);`
	`79`	`+ DefineLabel(e, TrapWriter.Writer, Extractor);`
`80`	`80`	`primitiveTypes[(int)code] = e;`
`81`	`81`	`}`
`82`	`82`
Original file line number	Diff line number	Diff line change
`@@ -10,12 +10,10 @@ namespace Semmle.Extraction.CIL`
`10`	`10`	`/// Adds additional context that is specific for CIL extraction.`
`11`	`11`	`/// One context = one DLL/EXE.`
`12`	`12`	`/// </summary>`
`13`		`- public sealed partial class Context : IDisposable`
	`13`	`+ public sealed partial class Context : Extraction.Context, IDisposable`
`14`	`14`	`{`
`15`	`15`	`private readonly FileStream stream;`
`16`	`16`	`private Entities.Assembly? assemblyNull;`
`17`		`-`
`18`		`- public Extraction.Context Cx { get; }`
`19`	`17`	`public MetadataReader MdReader { get; }`
`20`	`18`	`public PEReader PeReader { get; }`
`21`	`19`	`public string AssemblyPath { get; }`
`@@ -26,9 +24,9 @@ public Entities.Assembly Assembly`
`26`	`24`	`}`
`27`	`25`	`public PDB.IPdb? Pdb { get; }`
`28`	`26`
`29`		`- public Context(Extraction.Context cx, string assemblyPath, bool extractPdbs)`
	`27`	`+ public Context(Extractor extractor, TrapWriter trapWriter, string assemblyPath, bool extractPdbs)`
	`28`	`+ : base(extractor, trapWriter)`
`30`	`29`	`{`
`31`		`- this.Cx = cx;`
`32`	`30`	`this.AssemblyPath = assemblyPath;`
`33`	`31`	`stream = File.OpenRead(assemblyPath);`
`34`	`32`	`PeReader = new PEReader(stream, PEStreamOptions.PrefetchEntireImage);`
`@@ -51,7 +49,7 @@ public Context(Extraction.Context cx, string assemblyPath, bool extractPdbs)`
`51`	`49`	`Pdb = PDB.PdbReader.Create(assemblyPath, PeReader);`
`52`	`50`	`if (Pdb != null)`
`53`	`51`	`{`
`54`		`- cx.Extractor.Logger.Log(Util.Logging.Severity.Info, string.Format("Found PDB information for {0}", assemblyPath));`
	`52`	`+ Extractor.Logger.Log(Util.Logging.Severity.Info, string.Format("Found PDB information for {0}", assemblyPath));`
`55`	`53`	`}`
`56`	`54`	`}`
`57`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ public override IEnumerable<IExtractionProduct> Contents`
`76`	`76`	`}`
`77`	`77`	`catch (InternalError e)`
`78`	`78`	`{`
`79`		`- Cx.Cx.ExtractionError("Error processing type definition", e.Message, GeneratedLocation.Create(Cx.Cx), e.StackTrace);`
	`79`	`+ Cx.ExtractionError("Error processing type definition", e.Message, GeneratedLocation.Create(Cx), e.StackTrace);`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`// Limitation of C#: Cannot yield return inside a try-catch.`
`@@ -93,7 +93,7 @@ public override IEnumerable<IExtractionProduct> Contents`
`93`	`93`	`}`
`94`	`94`	`catch (InternalError e)`
`95`	`95`	`{`
`96`		`- Cx.Cx.ExtractionError("Error processing bytecode", e.Message, GeneratedLocation.Create(Cx.Cx), e.StackTrace);`
	`96`	`+ Cx.ExtractionError("Error processing bytecode", e.Message, GeneratedLocation.Create(Cx), e.StackTrace);`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`if (product != null)`
`@@ -102,11 +102,11 @@ public override IEnumerable<IExtractionProduct> Contents`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`		`- private static void ExtractCIL(Extraction.Context cx, string assemblyPath, bool extractPdbs)`
	`105`	`+ private static void ExtractCIL(Extractor extractor, TrapWriter trapWriter, bool extractPdbs)`
`106`	`106`	`{`
`107`		`- using var cilContext = new Context(cx, assemblyPath, extractPdbs);`
	`107`	`+ using var cilContext = new Context(extractor, trapWriter, extractor.OutputPath, extractPdbs);`
`108`	`108`	`cilContext.Populate(new Assembly(cilContext));`
`109`		`- cilContext.Cx.PopulateAll();`
	`109`	`+ cilContext.PopulateAll();`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`/// <summary>`
`@@ -135,8 +135,7 @@ public static void ExtractCIL(Layout layout, string assemblyPath, ILogger logger`
`135`	`135`	`trapFile = trapWriter.TrapFile;`
`136`	`136`	`if (nocache \|\| !System.IO.File.Exists(trapFile))`
`137`	`137`	`{`
`138`		`- var cx = new Extraction.Context(extractor, trapWriter);`
`139`		`- ExtractCIL(cx, assemblyPath, extractPdbs);`
	`138`	`+ ExtractCIL(extractor, trapWriter, extractPdbs);`
`140`	`139`	`extracted = true;`
`141`	`140`	`}`
`142`	`141`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public override IEnumerable<IExtractionProduct> Contents`
`45`	`45`	`}`
`46`	`46`	`catch`
`47`	`47`	`{`
`48`		`- Cx.Cx.Extractor.Logger.Log(Util.Logging.Severity.Info,`
	`48`	`+ Cx.Extractor.Logger.Log(Util.Logging.Severity.Info,`
`49`	`49`	`$"Attribute decoding is partial. Decoding attribute {constructor.DeclaringType.GetQualifiedName()} failed on {@object}.");`
`50`	`50`	`yield break;`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,10 @@ namespace Semmle.Extraction.CIL`
`11`	`11`	`public abstract class LabelledEntity : Extraction.LabelledEntity, IExtractedEntity`
`12`	`12`	`{`
`13`	`13`	`// todo: with .NET 5 this can override the base context, and change the return type.`
`14`		`- public Context Cx { get; }`
	`14`	`+ public Context Cx => (Context)base.Context;`
`15`	`15`
`16`		`- protected LabelledEntity(Context cx) : base(cx.Cx)`
	`16`	`+ protected LabelledEntity(Context cx) : base(cx)`
`17`	`17`	`{`
`18`		`- this.Cx = cx;`
`19`	`18`	`}`
`20`	`19`
`21`	`20`	`public override Microsoft.CodeAnalysis.Location ReportingLocation => throw new NotImplementedException();`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public Tuple(string name, params object[] args)`
`14`	`14`
`15`	`15`	`public void Extract(Context cx)`
`16`	`16`	`{`
`17`		`- cx.Cx.TrapWriter.Emit(tuple);`
	`17`	`+ cx.TrapWriter.Emit(tuple);`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`public override string ToString() => tuple.ToString();`
Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,10 @@ namespace Semmle.Extraction.CIL`
`10`	`10`	`public abstract class UnlabelledEntity : Extraction.UnlabelledEntity, IExtractedEntity`
`11`	`11`	`{`
`12`	`12`	`// todo: with .NET 5 this can override the base context, and change the return type.`
`13`		`- public Context Cx { get; }`
	`13`	`+ public Context Cx => (Context)base.Context;`
`14`	`14`
`15`		`- protected UnlabelledEntity(Context cx) : base(cx.Cx)`
	`15`	`+ protected UnlabelledEntity(Context cx) : base(cx)`
`16`	`16`	`{`
`17`		`- Cx = cx;`
`18`	`17`	`}`
`19`	`18`
`20`	`19`	`public override Microsoft.CodeAnalysis.Location ReportingLocation => throw new NotImplementedException();`
Original file line number	Diff line number	Diff line change
`@@ -40,11 +40,11 @@ public PrimitiveTypeCode GetUnderlyingEnumType(Type type)`
`40`	`40`
`41`	`41`	`if (wellKnownEnums.TryGetValue(name, out var code))`
`42`	`42`	`{`
`43`		`- cx.Cx.Extractor.Logger.Log(Util.Logging.Severity.Debug, $"Using hard coded underlying enum type for {name}");`
	`43`	`+ cx.Extractor.Logger.Log(Util.Logging.Severity.Debug, $"Using hard coded underlying enum type for {name}");`
`44`	`44`	`return code;`
`45`	`45`	`}`
`46`	`46`
`47`		`- cx.Cx.Extractor.Logger.Log(Util.Logging.Severity.Info, $"Couldn't get underlying enum type for {name}");`
	`47`	`+ cx.Extractor.Logger.Log(Util.Logging.Severity.Info, $"Couldn't get underlying enum type for {name}");`
`48`	`48`
`49`	`49`	`// We can't fall back to Int32, because the type returned here defines how many bytes are read from the`
`50`	`50`	`// stream and how those bytes are interpreted.`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ public class File : LabelledEntity, IFileOrFolder`
`11`	`11`	`public File(Context cx, string path) : base(cx)`
`12`	`12`	`{`
`13`	`13`	`this.OriginalPath = path;`
`14`		`- TransformedPath = cx.Cx.Extractor.PathTransformer.Transform(OriginalPath);`
	`14`	`+ TransformedPath = Cx.Extractor.PathTransformer.Transform(OriginalPath);`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public override void WriteId(TextWriter trapFile)`
Original file line number	Diff line number	Diff line change
`@@ -476,7 +476,7 @@ public IEnumerable<IExtractionProduct> JumpContents(Dictionary<int, Instruction>`
`476`	`476`	`// TODO: Find a solution to this.`
`477`	`477`
`478`	`478`	`// For now, just log the error`
`479`		`- Cx.Cx.ExtractionError("A CIL instruction jumps outside the current method", null, Extraction.Entities.GeneratedLocation.Create(Cx.Cx), "", Util.Logging.Severity.Warning);`
	`479`	`+ Cx.ExtractionError("A CIL instruction jumps outside the current method", null, Extraction.Entities.GeneratedLocation.Create(Cx), "", Util.Logging.Severity.Warning);`
`480`	`480`	`}`
`481`	`481`	`}`
`482`	`482`	`}`