C#: Add file instead of generated location for extraction errors when possible

Author: tamasvajk

csharp/extractor/Semmle.Extraction/AssemblyScope.cs

@@ -0,0 +1,30 @@
+using Microsoft.CodeAnalysis;
+
+namespace Semmle.Extraction
+{
+    /// <summary>
+    /// The scope of symbols in an assembly.
+    /// </summary>
+    public class AssemblyScope : IExtractionScope
+    {
+        private readonly IAssemblySymbol assembly;
+        private readonly string filepath;
+
+        public AssemblyScope(IAssemblySymbol symbol, string path, bool isOutput)
+        {
+            assembly = symbol;
+            filepath = path;
+            IsGlobalScope = isOutput;
+        }
+
+        public bool IsGlobalScope { get; }
+
+        public bool InFileScope(string path) => path == filepath;
+
+        public bool InScope(ISymbol symbol) =>
+            SymbolEqualityComparer.Default.Equals(symbol.ContainingAssembly, assembly) ||
+            SymbolEqualityComparer.Default.Equals(symbol, assembly);
+
+        public bool FromSource => false;
+    }
+}

csharp/extractor/Semmle.Extraction/Context.cs

@@ -215,7 +215,7 @@ public void PopulateAll()
                 }
                 catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
                 {
-                    ExtractionError("Uncaught exception", ex.Message, GeneratedLocation.Create(this), ex.StackTrace);
+                    ExtractionError("Uncaught exception", ex.Message, Entities.Location.Create(this), ex.StackTrace);
                 }
             }
         }
@@ -250,6 +250,8 @@ public Context(IExtractor e, Compilation c, TrapWriter trapWriter, IExtractionSc
 
         private IExtractionScope scope { get; }
 
+        public SyntaxTree? SourceTree => scope is SourceScope sc ? sc.SourceTree : null;
+
         /// <summary>
         ///     Whether the given symbol needs to be defined in this context.
         ///     This is the case if the symbol is contained in the source/assembly, or
@@ -451,7 +453,7 @@ public void ExtractionError(string message, ISymbol? optionalSymbol, IEntity opt
             }
             else
             {
-                ExtractionError(message, "", GeneratedLocation.Create(this));
+                ExtractionError(message, "", Entities.Location.Create(this));
             }
         }
 
@@ -522,13 +524,21 @@ public static void Try(this Context context, SyntaxNode? node, ISymbol? symbol,
                 Message message;
 
                 if (node != null)
+                {
                     message = Message.Create(context, ex.Message, node, ex.StackTrace);
+                }
                 else if (symbol != null)
+                {
                     message = Message.Create(context, ex.Message, symbol, ex.StackTrace);
+                }
                 else if (ex is InternalError ie)
+                {
                     message = new Message(ie.Text, ie.EntityText, Entities.Location.Create(context, ie.Location), ex.StackTrace);
+                }
                 else
-                    message = new Message("Uncaught exception", ex.Message, GeneratedLocation.Create(context), ex.StackTrace);
+                {
+                    message = new Message("Uncaught exception", ex.Message, Entities.Location.Create(context), ex.StackTrace);
+                }
 
                 context.ExtractionError(message);
             }

csharp/extractor/Semmle.Extraction/Entities/ExtractionError.cs

@@ -14,7 +14,7 @@ public ExtractionMessage(Context cx, Message msg) : base(cx)
 
         protected override void Populate(TextWriter trapFile)
         {
-            trapFile.extractor_messages(this, msg.Severity, "C# extractor", msg.Text, msg.EntityText, msg.Location ?? GeneratedLocation.Create(cx), msg.StackTrace);
+            trapFile.extractor_messages(this, msg.Severity, "C# extractor", msg.Text, msg.EntityText, msg.Location ?? Location.Create(cx), msg.StackTrace);
         }
 
         public override TrapStackBehaviour TrapStackBehaviour => TrapStackBehaviour.NoLabel;

csharp/extractor/Semmle.Extraction/Entities/Location.cs

@@ -1,4 +1,6 @@
 
+using Microsoft.CodeAnalysis.Text;
+
 namespace Semmle.Extraction.Entities
 {
     public abstract class Location : CachedEntity<Microsoft.CodeAnalysis.Location?>
@@ -13,6 +15,14 @@ public static Location Create(Context cx, Microsoft.CodeAnalysis.Location? loc)
                     ? NonGeneratedSourceLocation.Create(cx, loc)
                     : Assembly.Create(cx, loc);
 
+        public static Location Create(Context cx)
+        {
+            return cx.SourceTree == null
+                ? GeneratedLocation.Create(cx)
+                : Create(cx, Microsoft.CodeAnalysis.Location.Create(cx.SourceTree, TextSpan.FromBounds(0, 0)));
+
+        }
+
         public override Microsoft.CodeAnalysis.Location? ReportingLocation => symbol;
 
         public override TrapStackBehaviour TrapStackBehaviour => TrapStackBehaviour.OptionalLabel;

csharp/extractor/Semmle.Extraction/ExtractionScope.cs

@@ -0,0 +1,30 @@
+using Microsoft.CodeAnalysis;
+
+namespace Semmle.Extraction
+{
+    /// <summary>
+    /// Defines which entities belong in the trap file
+    /// for the currently extracted entity. This is used to ensure that
+    /// trap files do not contain redundant information. Generally a symbol
+    /// should have an affinity with exactly one trap file, except for constructed
+    /// symbols.
+    /// </summary>
+    public interface IExtractionScope
+    {
+        /// <summary>
+        /// Whether the given symbol belongs in the trap file.
+        /// </summary>
+        /// <param name="symbol">The symbol to populate.</param>
+        bool InScope(ISymbol symbol);
+
+        /// <summary>
+        /// Whether the given file belongs in the trap file.
+        /// </summary>
+        /// <param name="path">The path to populate.</param>
+        bool InFileScope(string path);
+
+        bool IsGlobalScope { get; }
+
+        bool FromSource { get; }
+    }
+}

csharp/extractor/Semmle.Extraction/IExtractionScope.cs

@@ -0,0 +1,27 @@
+using Microsoft.CodeAnalysis;
+using System.Linq;
+
+namespace Semmle.Extraction
+{
+
+    /// <summary>
+    /// The scope of symbols in a source file.
+    /// </summary>
+    public class SourceScope : IExtractionScope
+    {
+        public SyntaxTree SourceTree { get; }
+
+        public SourceScope(SyntaxTree tree)
+        {
+            SourceTree = tree;
+        }
+
+        public bool IsGlobalScope => false;
+
+        public bool InFileScope(string path) => path == SourceTree.FilePath;
+
+        public bool InScope(ISymbol symbol) => symbol.Locations.Any(loc => loc.SourceTree == SourceTree);
+
+        public bool FromSource => true;
+    }
+}