C#: Address more review comments

hvitved · hvitved · commit 1b769ebac9f9 · 2020-09-02T10:52:05.000+02:00
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Modifier.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Modifier.cs
@@ -5,45 +5,24 @@
 
 namespace Semmle.Extraction.CSharp.Entities
 {
-    /// <summary>
-    /// Provide a "Key" object to allow modifiers to exist as entities in the extractor
-    /// hash map. (Raw strings would work as keys but might clash with other types).
-    /// </summary>
-    class ModifierKey : Object
+    class Modifier : Extraction.CachedEntity<string>
     {
-        public readonly string name;
-
-        public ModifierKey(string m)
-        {
-            name = m;
-        }
-
-        public override bool Equals(Object obj)
-        {
-            return obj.GetType() == GetType() && name == ((ModifierKey)obj).name;
-        }
-
-        public override int GetHashCode() => 13 * name.GetHashCode();
-    }
-
-    class Modifier : Extraction.CachedEntity<ModifierKey>
-    {
-        Modifier(Context cx, ModifierKey init)
+        Modifier(Context cx, string init)
             : base(cx, init) { }
 
         public override Microsoft.CodeAnalysis.Location ReportingLocation => null;
 
         public override void WriteId(TextWriter trapFile)
         {
-            trapFile.Write(symbol.name);
+            trapFile.Write(symbol);
             trapFile.Write(";modifier");
         }
 
         public override bool NeedsPopulation => true;
 
         public override void Populate(TextWriter trapFile)
         {
-            trapFile.modifiers(Label, symbol.name);
+            trapFile.modifiers(Label, symbol);
         }
 
         public static string AccessbilityModifier(Accessibility access)
@@ -154,21 +133,20 @@ public static void ExtractModifiers(Context cx, TextWriter trapFile, IEntity key
 
         public static Modifier Create(Context cx, string modifier)
         {
-            var modifierKey = new ModifierKey(modifier);
-            return ModifierFactory.Instance.CreateEntity(cx, modifierKey, modifierKey);
+            return ModifierFactory.Instance.CreateEntity(cx, (typeof(Modifier), modifier), modifier);
         }
 
         public static Modifier Create(Context cx, Accessibility access)
         {
-            var modifierKey = new ModifierKey(AccessbilityModifier(access));
-            return ModifierFactory.Instance.CreateEntity(cx, modifierKey, modifierKey);
+            var modifier = AccessbilityModifier(access);
+            return ModifierFactory.Instance.CreateEntity(cx, (typeof(Modifier), modifier), modifier);
         }
 
-        class ModifierFactory : ICachedEntityFactory<ModifierKey, Modifier>
+        class ModifierFactory : ICachedEntityFactory<string, Modifier>
         {
             public static readonly ModifierFactory Instance = new ModifierFactory();
 
-            public Modifier Create(Context cx, ModifierKey init) => new Modifier(cx, init);
+            public Modifier Create(Context cx, string init) => new Modifier(cx, init);
         }
         public override TrapStackBehaviour TrapStackBehaviour => TrapStackBehaviour.OptionalLabel;
     }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Parameter.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Parameter.cs
@@ -202,8 +202,7 @@ public override bool Equals(object obj)
             return obj != null && obj.GetType() == typeof(VarargsType);
         }
 
-        static readonly object cacheKey = new object();
-        public static VarargsType Create(Context cx) => VarargsTypeFactory.Instance.CreateEntity(cx, cacheKey, null);
+        public static VarargsType Create(Context cx) => VarargsTypeFactory.Instance.CreateEntity(cx, typeof(VarargsType), null);
 
         class VarargsTypeFactory : ICachedEntityFactory<string, VarargsType>
         {
@@ -238,8 +237,7 @@ public override bool Equals(object obj)
             return obj != null && obj.GetType() == typeof(VarargsParam);
         }
 
-        static readonly object cacheKey = new object();
-        public static VarargsParam Create(Context cx, Method method) => VarargsParamFactory.Instance.CreateEntity(cx, cacheKey, method);
+        public static VarargsParam Create(Context cx, Method method) => VarargsParamFactory.Instance.CreateEntity(cx, typeof(VarargsParam), method);
 
         class VarargsParamFactory : ICachedEntityFactory<Method, VarargsParam>
         {
@@ -266,27 +264,8 @@ public override void Populate(TextWriter trapFile)
             trapFile.param_location(this, Original.Location);
         }
 
-        sealed class ConstructedExtensionParameterCacheKey
-        {
-            public readonly IParameterSymbol Parameter;
-            public readonly ITypeSymbol ConstructedType;
-            public ConstructedExtensionParameterCacheKey(IParameterSymbol parameter, ITypeSymbol constructedType)
-            {
-                Parameter = parameter;
-                ConstructedType = constructedType;
-            }
-
-            public override int GetHashCode() =>
-                (Parameter, ConstructedType).GetHashCode();
-
-            public override bool Equals(object obj) =>
-                obj is ConstructedExtensionParameterCacheKey k &&
-                SymbolEqualityComparer.Default.Equals(k.Parameter, Parameter) &&
-                SymbolEqualityComparer.Default.Equals(k.ConstructedType, ConstructedType);
-        }
-
         public static ConstructedExtensionParameter Create(Context cx, Method method, Parameter parameter) =>
-            ExtensionParamFactory.Instance.CreateEntity(cx, new ConstructedExtensionParameterCacheKey(parameter.symbol, method.symbol.ReceiverType), (method, parameter));
+            ExtensionParamFactory.Instance.CreateEntity(cx, (new SymbolEqualityWrapper(parameter.symbol), new SymbolEqualityWrapper(method.symbol.ReceiverType)), (method, parameter));
 
         class ExtensionParamFactory : ICachedEntityFactory<(Method, Parameter), ConstructedExtensionParameter>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Property.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Property.cs
@@ -1,3 +1,4 @@
+using System;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Semmle.Extraction.CSharp.Entities.Expressions;
@@ -11,9 +12,13 @@ namespace Semmle.Extraction.CSharp.Entities
     class Property : CachedSymbol<IPropertySymbol>, IExpressionParentEntity
     {
         protected Property(Context cx, IPropertySymbol init)
-            : base(cx, init) { }
+            : base(cx, init)
+        {
+            type = new Lazy<Type>(() => Type.Create(Context, symbol.Type));
+        }
 
-        Type Type => Type.Create(Context, symbol.Type);
+        readonly Lazy<Type> type;
+        Type Type => type.Value;
 
         public override void WriteId(TextWriter trapFile)
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs
@@ -107,10 +107,25 @@ public override IEnumerable<Extraction.Entities.Location> Locations
 
         public override Microsoft.CodeAnalysis.Location ReportingLocation => GetLocations(symbol).FirstOrDefault();
 
+        bool IsAnonymousType() => symbol.IsAnonymousType || symbol.Name.Contains("__AnonymousType");
+
         public override void WriteId(TextWriter trapFile)
         {
-            symbol.BuildTypeId(Context, trapFile, symbol);
-            trapFile.Write(";type");
+            if (IsAnonymousType())
+                trapFile.Write('*');
+            else
+            {
+                symbol.BuildTypeId(Context, trapFile, symbol);
+                trapFile.Write(";type");
+            }
+        }
+
+        public override void WriteQuotedId(TextWriter trapFile)
+        {
+            if (IsAnonymousType())
+                trapFile.Write('*');
+            else
+                base.WriteQuotedId(trapFile);
         }
 
         /// <summary>
@@ -167,22 +182,10 @@ public NamedTypeRef(Context cx, INamedTypeSymbol symbol) : base(cx, symbol)
             referencedType = Type.Create(cx, symbol);
         }
 
-        sealed class NamedTypeRefCacheKey
-        {
-            public readonly INamedTypeSymbol Symbol;
-            public NamedTypeRefCacheKey(INamedTypeSymbol symbol) => Symbol = symbol;
-
-            public override int GetHashCode() =>
-                11 * Symbol.GetHashCode();
-
-            public override bool Equals(object obj) =>
-                obj is NamedTypeRefCacheKey k && SymbolEqualityComparer.IncludeNullability.Equals(k.Symbol, Symbol);
-        }
-
         public static NamedTypeRef Create(Context cx, INamedTypeSymbol type) =>
             // We need to use a different cache key than `type` to avoid mixing up
             // `NamedType`s and `NamedTypeRef`s
-            NamedTypeRefFactory.Instance.CreateEntity(cx, new NamedTypeRefCacheKey(type), type);
+            NamedTypeRefFactory.Instance.CreateEntity(cx, (typeof(NamedTypeRef), new SymbolEqualityWrapper(type)), type);
 
         class NamedTypeRefFactory : ICachedEntityFactory<INamedTypeSymbol, NamedTypeRef>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NullType.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NullType.cs
@@ -27,8 +27,7 @@ public override bool Equals(object obj)
             return obj != null && obj.GetType() == typeof(NullType);
         }
 
-        static readonly object cacheKey = new object();
-        public static AnnotatedType Create(Context cx) => new AnnotatedType(NullTypeFactory.Instance.CreateEntity(cx, cacheKey, null), NullableAnnotation.None);
+        public static AnnotatedType Create(Context cx) => new AnnotatedType(NullTypeFactory.Instance.CreateEntity(cx, typeof(NullType), null), NullableAnnotation.None);
 
         class NullTypeFactory : ICachedEntityFactory<ITypeSymbol, NullType>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/Type.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/Type.cs
@@ -292,22 +292,10 @@ class DelegateTypeParameter : Parameter
             DelegateTypeParameter(Context cx, IParameterSymbol init, IEntity parent, Parameter original)
                 : base(cx, init, parent, original) { }
 
-            sealed class DelegateTypeParameterCacheKey
-            {
-                public readonly IParameterSymbol Symbol;
-                public DelegateTypeParameterCacheKey(IParameterSymbol symbol) => Symbol = symbol;
-
-                public override int GetHashCode() =>
-                    13 * Symbol.GetHashCode();
-
-                public override bool Equals(object obj) =>
-                    obj is DelegateTypeParameterCacheKey k && SymbolEqualityComparer.IncludeNullability.Equals(k.Symbol, Symbol);
-            }
-
             new public static DelegateTypeParameter Create(Context cx, IParameterSymbol param, IEntity parent, Parameter original = null) =>
                 // We need to use a different cache key than `param` to avoid mixing up
                 // `DelegateTypeParameter`s and `Parameter`s
-                DelegateTypeParameterFactory.Instance.CreateEntity(cx, new DelegateTypeParameterCacheKey(param), (param, parent, original));
+                DelegateTypeParameterFactory.Instance.CreateEntity(cx, (typeof(DelegateTypeParameter), new SymbolEqualityWrapper(param)), (param, parent, original));
 
             class DelegateTypeParameterFactory : ICachedEntityFactory<(IParameterSymbol, IEntity, Parameter), DelegateTypeParameter>
             {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs b/csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs
@@ -212,7 +212,7 @@ static void BuildOrWriteId(this ISymbol symbol, Context cx, TextWriter trapFile,
             // #123 = @"C`1 : IEnumerable<__self___T>"
             // ``` 
             if (SymbolEqualityComparer.Default.Equals(symbol, symbolBeingDefined))
-                trapFile.Write($"__self__");
+                trapFile.Write("__self__");
             else if (symbol is ITypeSymbol type && type.IdDependsOn(cx, symbolBeingDefined))
                 type.BuildTypeId(cx, trapFile, symbolBeingDefined, addBaseClass);
             else
@@ -294,12 +294,7 @@ void AddContaining()
                 }
             }
 
-            if (named.IsAnonymousType)
-            {
-                AddContaining();
-                named.BuildAnonymousName(cx, trapFile, (s0, cx0, trapFile0) => BuildOrWriteId(s0, cx0, trapFile0, symbolBeingDefined, addBaseClass), true);
-            }
-            else if (named.TypeParameters.IsEmpty)
+            if (named.TypeParameters.IsEmpty)
             {
                 AddContaining();
                 trapFile.Write(named.Name);
@@ -310,20 +305,6 @@ void AddContaining()
                 trapFile.Write(named.Name);
                 trapFile.Write("`");
                 trapFile.Write(named.TypeParameters.Length);
-                // Some types such as `<>f__AnonymousType0` are not considered anonymous types by Roslyn,
-                // perhaps because they contain type parameters. We still need to treat them like anonymous
-                // types, though, by adding the underlying properties, in order to disambiguate them
-                if (named.Name.Contains("__AnonymousType"))
-                {
-                    trapFile.Write('<');
-                    trapFile.BuildList(",", named.GetMembers().OfType<IPropertySymbol>(), (prop, tb0) =>
-                        {
-                            tb0.Write(prop.Name);
-                            tb0.Write(" ");
-                            prop.Type.BuildOrWriteId(cx, tb0, symbolBeingDefined, addBaseClass);
-                        });
-                    trapFile.Write('>');
-                }
             }
             else
             {
@@ -364,22 +345,14 @@ static void BuildNamespace(this INamespaceSymbol ns, Context cx, TextWriter trap
             trapFile.Write('.');
         }
 
-        static void BuildAnonymousName(this INamedTypeSymbol type, Context cx, TextWriter trapFile, Action<ITypeSymbol, Context, TextWriter> subTermAction, bool includeParamName)
+        static void BuildAnonymousName(this INamedTypeSymbol type, Context cx, TextWriter trapFile)
         {
-            var buildParam = includeParamName
-                ? (prop, tb0) =>
-                {
-                    tb0.Write(prop.Name);
-                    tb0.Write(' ');
-                    subTermAction(prop.Type, cx, tb0);
-                }
-            : (Action<IPropertySymbol, TextWriter>)((prop, tb0) => subTermAction(prop.Type, cx, tb0));
             int memberCount = type.GetMembers().OfType<IPropertySymbol>().Count();
             int hackTypeNumber = memberCount == 1 ? 1 : 0;
             trapFile.Write("<>__AnonType");
             trapFile.Write(hackTypeNumber);
             trapFile.Write('<');
-            trapFile.BuildList(",", type.GetMembers().OfType<IPropertySymbol>(), buildParam);
+            trapFile.BuildList(",", type.GetMembers().OfType<IPropertySymbol>(), (prop, tb0) => BuildDisplayName(prop.Type, cx, tb0));
             trapFile.Write('>');
         }
 
@@ -444,11 +417,9 @@ public static void BuildNamedTypeDisplayName(this INamedTypeSymbol namedType, Co
             }
 
             if (namedType.IsAnonymousType)
-            {
-                namedType.BuildAnonymousName(cx, trapFile, (sub, cx0, tb0) => sub.BuildDisplayName(cx0, tb0), false);
-            }
-
-            trapFile.Write(namedType.Name);
+                namedType.BuildAnonymousName(cx, trapFile);
+            else
+                trapFile.Write(namedType.Name);
             if (namedType.IsGenericType && namedType.TypeKind != TypeKind.Error && namedType.TypeArguments.Any())
             {
                 trapFile.Write('<');
diff --git a/csharp/extractor/Semmle.Extraction/Entities/File.cs b/csharp/extractor/Semmle.Extraction/Entities/File.cs
@@ -89,8 +89,7 @@ public static string PathAsDatabaseId(string path)
 
         public static string PathAsDatabaseString(string path) => path.Replace('\\', '/');
 
-        static readonly object cacheKey = new object();
-        public static File Create(Context cx, string path) => FileFactory.Instance.CreateEntity(cx, (cacheKey, path), path);
+        public static File Create(Context cx, string path) => FileFactory.Instance.CreateEntity(cx, (typeof(File), path), path);
 
         public static File CreateGenerated(Context cx) => GeneratedFile.Create(cx);
 
@@ -112,7 +111,7 @@ public override void WriteId(TextWriter trapFile)
             }
 
             public static GeneratedFile Create(Context cx) =>
-                GeneratedFileFactory.Instance.CreateEntity(cx, cacheKey, null);
+                GeneratedFileFactory.Instance.CreateEntity(cx, typeof(GeneratedFile), null);
 
             class GeneratedFileFactory : ICachedEntityFactory<string?, GeneratedFile>
             {
diff --git a/csharp/extractor/Semmle.Extraction/Entities/GeneratedLocation.cs b/csharp/extractor/Semmle.Extraction/Entities/GeneratedLocation.cs
@@ -28,8 +28,7 @@ public override void WriteId(TextWriter trapFile)
 
         public override bool Equals(object? obj) => obj != null && obj.GetType() == typeof(GeneratedLocation);
 
-        static readonly object cacheKey = new object();
-        public static GeneratedLocation Create(Context cx) => GeneratedLocationFactory.Instance.CreateEntity(cx, cacheKey, null);
+        public static GeneratedLocation Create(Context cx) => GeneratedLocationFactory.Instance.CreateEntity(cx, typeof(GeneratedLocation), null);
 
         class GeneratedLocationFactory : ICachedEntityFactory<string?, GeneratedLocation>
         {
diff --git a/csharp/extractor/Semmle.Extraction/Symbol.cs b/csharp/extractor/Semmle.Extraction/Symbol.cs
@@ -1,4 +1,5 @@
 using System.IO;
+using Microsoft.CodeAnalysis;
 
 namespace Semmle.Extraction
 {
@@ -75,4 +76,20 @@ public override bool Equals(object? obj)
 
         public abstract TrapStackBehaviour TrapStackBehaviour { get; }
     }
+
+    /// <summary>
+    /// A class used to wrap an `ISymbol` object, which uses `SymbolEqualityComparer.Default`
+    /// for comparison.
+    /// </summary>
+    public sealed class SymbolEqualityWrapper
+    {
+        public ISymbol Symbol { get; }
+
+        public SymbolEqualityWrapper(ISymbol symbol) { Symbol = symbol; }
+
+        public override bool Equals(object? other) =>
+            other is SymbolEqualityWrapper sew && SymbolEqualityComparer.Default.Equals(Symbol, sew.Symbol);
+
+        public override int GetHashCode() => 11 * Symbol.GetHashCode();
+    }
 }
diff --git a/csharp/ql/src/semmle/code/csharp/controlflow/internal/NonReturning.qll b/csharp/ql/src/semmle/code/csharp/controlflow/internal/NonReturning.qll
@@ -56,17 +56,7 @@ private class ThrowingCall extends NonReturningCall {
 }
 
 /** Holds if accessor `a` has an auto-implementation. */
-private predicate hasAccessorAutoImplementation(Accessor a) {
-  exists(SourceLocation sl | sl = a.getALocation() |
-    not exists(ControlFlowElement cfe, Location l | sl.getFile() = l.getFile() |
-      stmt_parent_top_level(cfe, _, a) and
-      stmt_location(cfe, l)
-      or
-      expr_parent_top_level_adjusted(cfe, 0, a) and
-      expr_location(cfe, l)
-    )
-  )
-}
+private predicate hasAccessorAutoImplementation(Accessor a) { not a.hasBody() }
 
 abstract private class NonReturningCallable extends Callable {
   NonReturningCallable() {

Original file line number	Diff line number	Diff line change
`@@ -5,45 +5,24 @@`
`5`	`5`
`6`	`6`	`namespace Semmle.Extraction.CSharp.Entities`
`7`	`7`	`{`
`8`		`- /// <summary>`
`9`		`- /// Provide a "Key" object to allow modifiers to exist as entities in the extractor`
`10`		`- /// hash map. (Raw strings would work as keys but might clash with other types).`
`11`		`- /// </summary>`
`12`		`- class ModifierKey : Object`
	`8`	`+ class Modifier : Extraction.CachedEntity<string>`
`13`	`9`	`{`
`14`		`- public readonly string name;`
`15`		`-`
`16`		`- public ModifierKey(string m)`
`17`		`- {`
`18`		`- name = m;`
`19`		`- }`
`20`		`-`
`21`		`- public override bool Equals(Object obj)`
`22`		`- {`
`23`		`- return obj.GetType() == GetType() && name == ((ModifierKey)obj).name;`
`24`		`- }`
`25`		`-`
`26`		`- public override int GetHashCode() => 13 * name.GetHashCode();`
`27`		`- }`
`28`		`-`
`29`		`- class Modifier : Extraction.CachedEntity<ModifierKey>`
`30`		`- {`
`31`		`- Modifier(Context cx, ModifierKey init)`
	`10`	`+ Modifier(Context cx, string init)`
`32`	`11`	`: base(cx, init) { }`
`33`	`12`
`34`	`13`	`public override Microsoft.CodeAnalysis.Location ReportingLocation => null;`
`35`	`14`
`36`	`15`	`public override void WriteId(TextWriter trapFile)`
`37`	`16`	`{`
`38`		`- trapFile.Write(symbol.name);`
	`17`	`+ trapFile.Write(symbol);`
`39`	`18`	`trapFile.Write(";modifier");`
`40`	`19`	`}`
`41`	`20`
`42`	`21`	`public override bool NeedsPopulation => true;`
`43`	`22`
`44`	`23`	`public override void Populate(TextWriter trapFile)`
`45`	`24`	`{`
`46`		`- trapFile.modifiers(Label, symbol.name);`
	`25`	`+ trapFile.modifiers(Label, symbol);`
`47`	`26`	`}`
`48`	`27`
`49`	`28`	`public static string AccessbilityModifier(Accessibility access)`
`@@ -154,21 +133,20 @@ public static void ExtractModifiers(Context cx, TextWriter trapFile, IEntity key`
`154`	`133`
`155`	`134`	`public static Modifier Create(Context cx, string modifier)`
`156`	`135`	`{`
`157`		`- var modifierKey = new ModifierKey(modifier);`
`158`		`- return ModifierFactory.Instance.CreateEntity(cx, modifierKey, modifierKey);`
	`136`	`+ return ModifierFactory.Instance.CreateEntity(cx, (typeof(Modifier), modifier), modifier);`
`159`	`137`	`}`
`160`	`138`
`161`	`139`	`public static Modifier Create(Context cx, Accessibility access)`
`162`	`140`	`{`
`163`		`- var modifierKey = new ModifierKey(AccessbilityModifier(access));`
`164`		`- return ModifierFactory.Instance.CreateEntity(cx, modifierKey, modifierKey);`
	`141`	`+ var modifier = AccessbilityModifier(access);`
	`142`	`+ return ModifierFactory.Instance.CreateEntity(cx, (typeof(Modifier), modifier), modifier);`
`165`	`143`	`}`
`166`	`144`
`167`		`- class ModifierFactory : ICachedEntityFactory<ModifierKey, Modifier>`
	`145`	`+ class ModifierFactory : ICachedEntityFactory<string, Modifier>`
`168`	`146`	`{`
`169`	`147`	`public static readonly ModifierFactory Instance = new ModifierFactory();`
`170`	`148`
`171`		`- public Modifier Create(Context cx, ModifierKey init) => new Modifier(cx, init);`
	`149`	`+ public Modifier Create(Context cx, string init) => new Modifier(cx, init);`
`172`	`150`	`}`
`173`	`151`	`public override TrapStackBehaviour TrapStackBehaviour => TrapStackBehaviour.OptionalLabel;`
`174`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,7 @@ public override bool Equals(object obj)`
`27`	`27`	`return obj != null && obj.GetType() == typeof(NullType);`
`28`	`28`	`}`
`29`	`29`
`30`		`- static readonly object cacheKey = new object();`
`31`		`- public static AnnotatedType Create(Context cx) => new AnnotatedType(NullTypeFactory.Instance.CreateEntity(cx, cacheKey, null), NullableAnnotation.None);`
	`30`	`+ public static AnnotatedType Create(Context cx) => new AnnotatedType(NullTypeFactory.Instance.CreateEntity(cx, typeof(NullType), null), NullableAnnotation.None);`
`32`	`31`
`33`	`32`	`class NullTypeFactory : ICachedEntityFactory<ITypeSymbol, NullType>`
`34`	`33`	`{`
Original file line number	Diff line number	Diff line change
`@@ -89,8 +89,7 @@ public static string PathAsDatabaseId(string path)`
`89`	`89`
`90`	`90`	`public static string PathAsDatabaseString(string path) => path.Replace('\\', '/');`
`91`	`91`
`92`		`- static readonly object cacheKey = new object();`
`93`		`- public static File Create(Context cx, string path) => FileFactory.Instance.CreateEntity(cx, (cacheKey, path), path);`
	`92`	`+ public static File Create(Context cx, string path) => FileFactory.Instance.CreateEntity(cx, (typeof(File), path), path);`
`94`	`93`
`95`	`94`	`public static File CreateGenerated(Context cx) => GeneratedFile.Create(cx);`
`96`	`95`
`@@ -112,7 +111,7 @@ public override void WriteId(TextWriter trapFile)`
`112`	`111`	`}`
`113`	`112`
`114`	`113`	`public static GeneratedFile Create(Context cx) =>`
`115`		`- GeneratedFileFactory.Instance.CreateEntity(cx, cacheKey, null);`
	`114`	`+ GeneratedFileFactory.Instance.CreateEntity(cx, typeof(GeneratedFile), null);`
`116`	`115`
`117`	`116`	`class GeneratedFileFactory : ICachedEntityFactory<string?, GeneratedFile>`
`118`	`117`	`{`
Original file line number	Diff line number	Diff line change
`@@ -28,8 +28,7 @@ public override void WriteId(TextWriter trapFile)`
`28`	`28`
`29`	`29`	`public override bool Equals(object? obj) => obj != null && obj.GetType() == typeof(GeneratedLocation);`
`30`	`30`
`31`		`- static readonly object cacheKey = new object();`
`32`		`- public static GeneratedLocation Create(Context cx) => GeneratedLocationFactory.Instance.CreateEntity(cx, cacheKey, null);`
	`31`	`+ public static GeneratedLocation Create(Context cx) => GeneratedLocationFactory.Instance.CreateEntity(cx, typeof(GeneratedLocation), null);`
`33`	`32`
`34`	`33`	`class GeneratedLocationFactory : ICachedEntityFactory<string?, GeneratedLocation>`
`35`	`34`	`{`