diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Accessor.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Accessor.cs
index 98c021c8a6d6..cc713b5ad2f3 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Accessor.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Accessor.cs
@@ -77,7 +77,7 @@ public override void Populate(TextWriter trapFile)
         }
 
         public new static Accessor Create(Context cx, IMethodSymbol symbol) =>
-            AccessorFactory.Instance.CreateEntity(cx, symbol);
+            AccessorFactory.Instance.CreateEntityFromSymbol(cx, symbol);
 
         class AccessorFactory : ICachedEntityFactory<IMethodSymbol, Accessor>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Constructor.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Constructor.cs
index 298f838cfb93..a9baacbf7287 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Constructor.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Constructor.cs
@@ -104,7 +104,7 @@ ConstructorDeclarationSyntax Syntax
             {
                 case MethodKind.StaticConstructor:
                 case MethodKind.Constructor:
-                    return ConstructorFactory.Instance.CreateEntity(cx, constructor);
+                    return ConstructorFactory.Instance.CreateEntityFromSymbol(cx, constructor);
                 default:
                     throw new InternalError(constructor, "Attempt to create a Constructor from a symbol that isn't a constructor");
             }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Conversion.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Conversion.cs
index e365ca53ae0c..98758fb773f6 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Conversion.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Conversion.cs
@@ -11,7 +11,7 @@ class Conversion : UserOperator
             : base(cx, init) { }
 
         public new static Conversion Create(Context cx, IMethodSymbol symbol) =>
-            ConversionFactory.Instance.CreateEntity(cx, symbol);
+            ConversionFactory.Instance.CreateEntityFromSymbol(cx, symbol);
 
         public override Microsoft.CodeAnalysis.Location ReportingLocation
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Destructor.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Destructor.cs
index 33f3a330f944..65557b16b67f 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Destructor.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Destructor.cs
@@ -24,7 +24,7 @@ public override void Populate(TextWriter trapFile)
         }
 
         public new static Destructor Create(Context cx, IMethodSymbol symbol) =>
-            DestructorFactory.Instance.CreateEntity(cx, symbol);
+            DestructorFactory.Instance.CreateEntityFromSymbol(cx, symbol);
 
         class DestructorFactory : ICachedEntityFactory<IMethodSymbol, Destructor>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Event.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Event.cs
index 224c81b9524b..59f937a6331e 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Event.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Event.cs
@@ -60,7 +60,7 @@ public override void Populate(TextWriter trapFile)
                 TypeMention.Create(Context, syntaxType, this, type);
         }
 
-        public static Event Create(Context cx, IEventSymbol symbol) => EventFactory.Instance.CreateEntity(cx, symbol);
+        public static Event Create(Context cx, IEventSymbol symbol) => EventFactory.Instance.CreateEntityFromSymbol(cx, symbol);
 
         class EventFactory : ICachedEntityFactory<IEventSymbol, Event>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/EventAccessor.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/EventAccessor.cs
index 7dc0a4dfcffa..da858b689dc3 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/EventAccessor.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/EventAccessor.cs
@@ -53,7 +53,7 @@ public override void Populate(TextWriter trapFile)
         }
 
         public new static EventAccessor Create(Context cx, IMethodSymbol symbol) =>
-            EventAccessorFactory.Instance.CreateEntity(cx, symbol);
+            EventAccessorFactory.Instance.CreateEntityFromSymbol(cx, symbol);
 
         class EventAccessorFactory : ICachedEntityFactory<IMethodSymbol, EventAccessor>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Field.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Field.cs
index 7ae4572cd7d0..f126b7ff52f3 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Field.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Field.cs
@@ -18,7 +18,7 @@ class Field : CachedSymbol<IFieldSymbol>, IExpressionParentEntity
             type = new Lazy<AnnotatedType>(() => Entities.Type.Create(cx, symbol.GetAnnotatedType()));
         }
 
-        public static Field Create(Context cx, IFieldSymbol field) => FieldFactory.Instance.CreateEntity(cx, field);
+        public static Field Create(Context cx, IFieldSymbol field) => FieldFactory.Instance.CreateEntityFromSymbol(cx, field);
 
         // Do not populate backing fields.
         // Populate Tuple fields.
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Indexer.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Indexer.cs
index b9ece3d8c8e1..af07c41dd6b7 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Indexer.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Indexer.cs
@@ -71,7 +71,7 @@ public override void Populate(TextWriter trapFile)
                 TypeMention.Create(Context, syntax.Type, this, type);
         }
 
-        public static new Indexer Create(Context cx, IPropertySymbol prop) => IndexerFactory.Instance.CreateEntity(cx, prop);
+        public static new Indexer Create(Context cx, IPropertySymbol prop) => IndexerFactory.Instance.CreateEntityFromSymbol(cx, prop);
 
         public override void WriteId(TextWriter trapFile)
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalFunction.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalFunction.cs
index e570802ab3d8..8b90f6905dd3 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalFunction.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalFunction.cs
@@ -22,7 +22,7 @@ public override void WriteQuotedId(TextWriter trapFile)
             trapFile.Write('*');
         }
 
-        public static new LocalFunction Create(Context cx, IMethodSymbol field) => LocalFunctionFactory.Instance.CreateEntity(cx, field);
+        public static new LocalFunction Create(Context cx, IMethodSymbol field) => LocalFunctionFactory.Instance.CreateEntityFromSymbol(cx, field);
 
         class LocalFunctionFactory : ICachedEntityFactory<IMethodSymbol, LocalFunction>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalVariable.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalVariable.cs
index 6d0f14a014eb..02d89d08a2f7 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalVariable.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalVariable.cs
@@ -43,7 +43,7 @@ symbol is ILocalSymbol l ?
 
         public static LocalVariable Create(Context cx, ISymbol local)
         {
-            return LocalVariableFactory.Instance.CreateEntity(cx, local);
+            return LocalVariableFactory.Instance.CreateEntityFromSymbol(cx, local);
         }
 
         void DefineConstantValue(TextWriter trapFile)
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Method.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Method.cs
index 982d21b25698..dbcae8f1bfe9 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Method.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Method.cs
@@ -129,7 +129,7 @@ protected static void BuildMethodId(Method m, TextWriter trapFile)
                     // Type arguments with different nullability can result in 
                     // a constructed method with different nullability of its parameters and return type,
                     // so we need to create a distinct database entity for it.
-                    trapFile.BuildList(",", m.symbol.GetAnnotatedTypeArguments(), (ta, tb0) => { AddSignatureTypeToId(m.Context, tb0, m.symbol, ta.Symbol); trapFile.Write((int)ta.Nullability); });
+                    trapFile.BuildList(",", m.symbol.GetAnnotatedTypeArguments(), (ta, tb0) => { ta.Symbol.BuildNestedTypeId(m.Context, tb0, m.symbol); trapFile.Write((int)ta.Nullability); });
                     trapFile.Write('>');
                 }
             }
@@ -163,50 +163,6 @@ public override void WriteId(TextWriter trapFile)
             BuildMethodId(this, trapFile);
         }
 
-        /// <summary>
-        /// Adds an appropriate label ID to the trap builder <paramref name="trapFile"/>
-        /// for the type <paramref name="type"/> belonging to the signature of method
-        /// <paramref name="method"/>.
-        ///
-        /// For methods without type parameters this will always add the key of the
-        /// corresponding type.
-        ///
-        /// For methods with type parameters, this will add the key of the
-        /// corresponding type if the type does *not* contain one of the method
-        /// type parameters, otherwise it will add a textual representation of
-        /// the type. This distinction is required because type parameter IDs
-        /// refer to their declaring methods.
-        ///
-        /// Example:
-        ///
-        /// <code>
-        /// int Count&lt;T&gt;(IEnumerable<T> items)
-        /// </code>
-        ///
-        /// The label definitions for <code>Count</code> (<code>#4</code>) and <code>T</code>
-        /// (<code>#5</code>) will look like:
-        ///
-        /// <code>
-        /// #1=&lt;label for System.Int32&gt;
-        /// #2=&lt;label for type containing Count&gt;
-        /// #3=&lt;label for IEnumerable`1&gt;
-        /// #4=@"{#1} {#2}.Count`2(#3<T>);method"
-        /// #5=@"{#4}T;typeparameter"
-        /// </code>
-        ///
-        /// Note how <code>int</code> is referenced in the label definition <code>#3</code> for
-        /// <code>Count</code>, while <code>T[]</code> is represented textually in order
-        /// to make the reference to <code>#3</code> in the label definition <code>#4</code> for
-        /// <code>T</code> valid.
-        /// </summary>
-        protected static void AddSignatureTypeToId(Context cx, TextWriter trapFile, IMethodSymbol method, ITypeSymbol type)
-        {
-            if (type.ContainsTypeParameters(cx, method))
-                type.BuildTypeId(cx, trapFile, (cx0, tb0, type0) => AddSignatureTypeToId(cx, tb0, method, type0));
-            else
-                trapFile.WriteSubId(Type.Create(cx, type));
-        }
-
         protected static void AddParametersToId(Context cx, TextWriter trapFile, IMethodSymbol method)
         {
             trapFile.Write('(');
@@ -215,13 +171,13 @@ protected static void AddParametersToId(Context cx, TextWriter trapFile, IMethod
             if (method.MethodKind == MethodKind.ReducedExtension)
             {
                 trapFile.WriteSeparator(",", ref index);
-                AddSignatureTypeToId(cx, trapFile, method, method.ReceiverType);
+                method.ReceiverType.BuildNestedTypeId(cx, trapFile, method);
             }
 
             foreach (var param in method.Parameters)
             {
                 trapFile.WriteSeparator(",", ref index);
-                AddSignatureTypeToId(cx, trapFile, method, param.Type);
+                param.Type.BuildNestedTypeId(cx, trapFile, method);
                 switch (param.RefKind)
                 {
                     case RefKind.Out:
@@ -244,9 +200,10 @@ protected static void AddParametersToId(Context cx, TextWriter trapFile, IMethod
 
         public static void AddExplicitInterfaceQualifierToId(Context cx, System.IO.TextWriter trapFile, IEnumerable<ISymbol> explicitInterfaceImplementations)
         {
-            if (explicitInterfaceImplementations.Any())
+            foreach (var i in explicitInterfaceImplementations)
             {
-                trapFile.AppendList(",", explicitInterfaceImplementations.Select(impl => cx.CreateEntity(impl.ContainingType)));
+                trapFile.Write(';');
+                i.ContainingType.BuildNestedTypeId(cx, trapFile, null);
             }
         }
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/OrdinaryMethod.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/OrdinaryMethod.cs
index cb12918e72e7..74e7de35a162 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/OrdinaryMethod.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/OrdinaryMethod.cs
@@ -49,7 +49,7 @@ public override void Populate(TextWriter trapFile)
             ExtractCompilerGenerated(trapFile);
         }
 
-        public new static OrdinaryMethod Create(Context cx, IMethodSymbol method) => OrdinaryMethodFactory.Instance.CreateEntity(cx, method);
+        public new static OrdinaryMethod Create(Context cx, IMethodSymbol method) => OrdinaryMethodFactory.Instance.CreateEntityFromSymbol(cx, method);
 
         class OrdinaryMethodFactory : ICachedEntityFactory<IMethodSymbol, OrdinaryMethod>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Property.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Property.cs
index e5e2cc8ab261..05ff97db8050 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Property.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Property.cs
@@ -113,7 +113,7 @@ public static Property Create(Context cx, IPropertySymbol prop)
         {
             bool isIndexer = prop.IsIndexer || prop.Parameters.Any();
 
-            return isIndexer ? Indexer.Create(cx, prop) : PropertyFactory.Instance.CreateEntity(cx, prop);
+            return isIndexer ? Indexer.Create(cx, prop) : PropertyFactory.Instance.CreateEntityFromSymbol(cx, prop);
         }
 
         public void VisitDeclaration(Context cx, PropertyDeclarationSyntax p)
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/ArrayType.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/ArrayType.cs
index c4a79a7764b0..9e2116603441 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/ArrayType.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/ArrayType.cs
@@ -36,7 +36,7 @@ public override void WriteId(TextWriter trapFile)
             trapFile.Write(";type");
         }
 
-        public static ArrayType Create(Context cx, IArrayTypeSymbol symbol) => ArrayTypeFactory.Instance.CreateEntity(cx, symbol);
+        public static ArrayType Create(Context cx, IArrayTypeSymbol symbol) => ArrayTypeFactory.Instance.CreateEntityFromSymbol(cx, symbol);
 
         class ArrayTypeFactory : ICachedEntityFactory<IArrayTypeSymbol, ArrayType>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/DynamicType.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/DynamicType.cs
index f5b6bf36c440..bfaba1cff85c 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/DynamicType.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/DynamicType.cs
@@ -9,7 +9,7 @@ class DynamicType : Type<IDynamicTypeSymbol>
         DynamicType(Context cx, IDynamicTypeSymbol init)
             : base(cx, init) { }
 
-        public static DynamicType Create(Context cx, IDynamicTypeSymbol type) => DynamicTypeFactory.Instance.CreateEntity(cx, type);
+        public static DynamicType Create(Context cx, IDynamicTypeSymbol type) => DynamicTypeFactory.Instance.CreateEntityFromSymbol(cx, type);
 
         public override Microsoft.CodeAnalysis.Location ReportingLocation => Context.Compilation.ObjectType.Locations.FirstOrDefault();
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs
index 93c13726750e..cc43687b3101 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs
@@ -17,7 +17,7 @@ class NamedType : Type<INamedTypeSymbol>
             typeArgumentsLazy = new Lazy<Type[]>(() => symbol.TypeArguments.Select(t => Create(cx, t)).ToArray());
         }
 
-        public static NamedType Create(Context cx, INamedTypeSymbol type) => NamedTypeFactory.Instance.CreateEntity(cx, type);
+        public static NamedType Create(Context cx, INamedTypeSymbol type) => NamedTypeFactory.Instance.CreateEntityFromSymbol(cx, type);
 
         public override bool NeedsPopulation => base.NeedsPopulation || symbol.TypeKind == TypeKind.Error;
 
@@ -29,7 +29,8 @@ public override void Populate(TextWriter trapFile)
                 return;
             }
 
-            trapFile.typeref_type((NamedTypeRef)TypeRef, this);
+            if (UsesTypeRef)
+                trapFile.typeref_type((NamedTypeRef)TypeRef, this);
 
             if (symbol.IsGenericType)
             {
@@ -108,7 +109,7 @@ public override IEnumerable<Extraction.Entities.Location> Locations
 
         public override void WriteId(TextWriter trapFile)
         {
-            symbol.BuildTypeId(Context, trapFile, (cx0, tb0, sub) => tb0.WriteSubId(Create(cx0, sub)));
+            symbol.BuildTypeId(Context, trapFile, true, symbol, (cx0, tb0, sub, _) => tb0.WriteSubId(Create(cx0, sub)));
             trapFile.Write(";type");
         }
 
@@ -148,7 +149,14 @@ class NamedTypeFactory : ICachedEntityFactory<INamedTypeSymbol, NamedType>
             public NamedType Create(Context cx, INamedTypeSymbol init) => new NamedType(cx, init);
         }
 
-        public override Type TypeRef => NamedTypeRef.Create(Context, symbol);
+        // Do not create typerefs of constructed generics as they are always in the current trap file, and there is a possibility
+        // that a generic could make the typedef ambiguous which leads to performance problems in QL.
+        // Create typerefs for constructed error types in case they are fully defined elsewhere.
+        // We cannot use `!this.NeedsPopulation` because this would not be stable as it would depend on
+        // the assembly that was being extracted at the time.
+        bool UsesTypeRef => symbol.TypeKind == TypeKind.Error || SymbolEqualityComparer.Default.Equals(symbol.OriginalDefinition, symbol);
+
+        public override Type TypeRef => UsesTypeRef ? (Type)NamedTypeRef.Create(Context, symbol) : this;
     }
 
     class NamedTypeRef : Type<INamedTypeSymbol>
@@ -174,7 +182,7 @@ class NamedTypeRefFactory : ICachedEntityFactory<INamedTypeSymbol, NamedTypeRef>
 
         public override void WriteId(TextWriter trapFile)
         {
-            trapFile.WriteSubId(referencedType);
+            referencedType.symbol.BuildNestedTypeId(Context, trapFile, referencedType.symbol);
             trapFile.Write(";typeRef");
         }
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/PointerType.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/PointerType.cs
index db8b5ff8c23b..229666e6260e 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/PointerType.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/PointerType.cs
@@ -29,7 +29,7 @@ public override void Populate(TextWriter trapFile)
 
         public Type PointedAtType { get; private set; }
 
-        public static PointerType Create(Context cx, IPointerTypeSymbol symbol) => PointerTypeFactory.Instance.CreateEntity(cx, symbol);
+        public static PointerType Create(Context cx, IPointerTypeSymbol symbol) => PointerTypeFactory.Instance.CreateEntityFromSymbol(cx, symbol);
 
         class PointerTypeFactory : ICachedEntityFactory<IPointerTypeSymbol, PointerType>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TupleType.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TupleType.cs
index de6ea2170849..ae9d3139a5c2 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TupleType.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TupleType.cs
@@ -13,7 +13,7 @@ namespace Semmle.Extraction.CSharp.Entities
     /// </summary>
     class TupleType : Type<INamedTypeSymbol>
     {
-        public static TupleType Create(Context cx, INamedTypeSymbol type) => TupleTypeFactory.Instance.CreateEntity(cx, type);
+        public static TupleType Create(Context cx, INamedTypeSymbol type) => TupleTypeFactory.Instance.CreateEntityFromSymbol(cx, type);
 
         class TupleTypeFactory : ICachedEntityFactory<INamedTypeSymbol, TupleType>
         {
@@ -32,7 +32,7 @@ class TupleTypeFactory : ICachedEntityFactory<INamedTypeSymbol, TupleType>
 
         public override void WriteId(TextWriter trapFile)
         {
-            symbol.BuildTypeId(Context, trapFile, (cx0, tb0, sub) => tb0.WriteSubId(Create(cx0, sub)));
+            symbol.BuildTypeId(Context, trapFile, false, symbol, (cx0, tb0, sub, _) => tb0.WriteSubId(Create(cx0, sub)));
             trapFile.Write(";tuple");
         }
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/Type.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/Type.cs
index 7d9f5e3651e8..857d3def9456 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/Type.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/Type.cs
@@ -324,6 +324,14 @@ public virtual IEnumerable<Type> TypeMentions
         }
 
         public override TrapStackBehaviour TrapStackBehaviour => TrapStackBehaviour.NoLabel;
+
+        public override bool Equals(object obj)
+        {
+            var other = obj as Type;
+            return other?.GetType() == GetType() && SymbolEqualityComparer.IncludeNullability.Equals(other.symbol, symbol);
+        }
+
+        public override int GetHashCode() => SymbolEqualityComparer.IncludeNullability.GetHashCode(symbol);
     }
 
     abstract class Type<T> : Type where T : ITypeSymbol
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TypeParameter.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TypeParameter.cs
index 2fdb8cd3a834..2c7c63731434 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TypeParameter.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TypeParameter.cs
@@ -88,7 +88,7 @@ public override void Populate(TextWriter trapFile)
         }
 
         static public TypeParameter Create(Context cx, ITypeParameterSymbol p) =>
-            TypeParameterFactory.Instance.CreateEntity(cx, p);
+            TypeParameterFactory.Instance.CreateEntityFromSymbol(cx, p);
 
         /// <summary>
         /// The variance of this type parameter.
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/UserOperator.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/UserOperator.cs
index 2a64a29fa0d2..bebcffd4dd7a 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/Entities/UserOperator.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/Entities/UserOperator.cs
@@ -51,7 +51,7 @@ public override Type ContainingType
 
         public override void WriteId(TextWriter trapFile)
         {
-            AddSignatureTypeToId(Context, trapFile, symbol, symbol.ReturnType); // Needed for op_explicit(), which differs only by return type.
+            symbol.ReturnType.BuildNestedTypeId(Context, trapFile, symbol); // Needed for op_explicit(), which differs only by return type.
             trapFile.Write(' ');
             BuildMethodId(this, trapFile);
         }
@@ -190,7 +190,7 @@ public static string OperatorSymbol(Context cx, string methodName)
             return result;
         }
 
-        public new static UserOperator Create(Context cx, IMethodSymbol symbol) => UserOperatorFactory.Instance.CreateEntity(cx, symbol);
+        public new static UserOperator Create(Context cx, IMethodSymbol symbol) => UserOperatorFactory.Instance.CreateEntityFromSymbol(cx, symbol);
 
         class UserOperatorFactory : ICachedEntityFactory<IMethodSymbol, UserOperator>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs b/csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs
index 6050ad910a52..17a493771c63 100644
--- a/csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs
+++ b/csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs
@@ -122,6 +122,24 @@ public static bool ContainsTypeParameters(this ITypeSymbol type, Context cx, ISy
             }
         }
 
+        /// <summary>
+        /// Write the identifier for the symbol <paramref name="type"/> to the trapfile <paramref name="trapFile"/>.
+        /// If any nested types are found in the identifier, then they are written out explicitly, without
+        /// prefixing the assembly ID.
+        /// </summary>
+        /// <param name="type">The type to write.</param>
+        /// <param name="cx">The extraction context.</param>
+        /// <param name="trapFile">The trap file to write to.</param>
+        /// <param name="symbolBeingDefined">The outer symbol being defined (to avoid recursive ids).</param>
+        public static void BuildNestedTypeId(this ITypeSymbol type, Context cx, TextWriter trapFile, ISymbol symbolBeingDefined)
+        {
+            void WriteType(Context cx, TextWriter trapFile, ITypeSymbol symbol, ISymbol symbolBeingDefined)
+            {
+                symbol.BuildTypeId(cx, trapFile, false, symbolBeingDefined, WriteType);
+            }
+            WriteType(cx, trapFile, type, symbolBeingDefined);
+        }
+
         /// <summary>
         /// Constructs a unique string for this type symbol.
         ///
@@ -130,10 +148,12 @@ public static bool ContainsTypeParameters(this ITypeSymbol type, Context cx, ISy
         /// </summary>
         /// <param name="cx">The extraction context.</param>
         /// <param name="trapFile">The trap builder used to store the result.</param>
+        /// <param name="prefix">Whether to prefix the type ID with the assembly ID.</param>
+        /// <param name="symbolBeingDefined">The outer symbol being defined (to avoid recursive ids).</param>
         /// <param name="subTermAction">The action to apply to syntactic sub terms of this type.</param>
-        public static void BuildTypeId(this ITypeSymbol type, Context cx, TextWriter trapFile, Action<Context, TextWriter, ITypeSymbol> subTermAction)
+        public static void BuildTypeId(this ITypeSymbol type, Context cx, TextWriter trapFile, bool prefix, ISymbol symbolBeingDefined, Action<Context, TextWriter, ITypeSymbol, ISymbol> subTermAction)
         {
-            if (type.SpecialType != SpecialType.None)
+            if (type.SpecialType != SpecialType.None && !(type is INamedTypeSymbol n && n.IsGenericType))
             {
                 /*
                  * Use the keyword ("int" etc) for the built-in types.
@@ -150,7 +170,7 @@ public static void BuildTypeId(this ITypeSymbol type, Context cx, TextWriter tra
                 {
                     case TypeKind.Array:
                         var array = (IArrayTypeSymbol)type;
-                        subTermAction(cx, trapFile, array.ElementType);
+                        subTermAction(cx, trapFile, array.ElementType, symbolBeingDefined);
                         array.BuildArraySuffix(trapFile);
                         return;
                     case TypeKind.Class:
@@ -160,15 +180,30 @@ public static void BuildTypeId(this ITypeSymbol type, Context cx, TextWriter tra
                     case TypeKind.Delegate:
                     case TypeKind.Error:
                         var named = (INamedTypeSymbol)type;
-                        named.BuildNamedTypeId(cx, trapFile, subTermAction);
+                        named.BuildNamedTypeId(cx, trapFile, prefix, symbolBeingDefined, subTermAction);
                         return;
                     case TypeKind.Pointer:
                         var ptr = (IPointerTypeSymbol)type;
-                        subTermAction(cx, trapFile, ptr.PointedAtType);
+                        subTermAction(cx, trapFile, ptr.PointedAtType, symbolBeingDefined);
                         trapFile.Write('*');
                         return;
                     case TypeKind.TypeParameter:
                         var tp = (ITypeParameterSymbol)type;
+                        if (!SymbolEqualityComparer.Default.Equals(tp.ContainingSymbol, symbolBeingDefined))
+                        {
+                            switch (tp.TypeParameterKind)
+                            {
+                                case TypeParameterKind.Method:
+                                    var method = Method.Create(cx, (IMethodSymbol)tp.ContainingSymbol);
+                                    trapFile.WriteSubId(method);
+                                    trapFile.Write('_');
+                                    break;
+                                case TypeParameterKind.Type:
+                                    subTermAction(cx, trapFile, tp.ContainingType, symbolBeingDefined);
+                                    trapFile.Write('_');
+                                    break;
+                            }
+                        }
                         trapFile.Write(tp.Name);
                         return;
                     case TypeKind.Dynamic:
@@ -211,9 +246,8 @@ private static void BuildAssembly(IAssemblySymbol asm, TextWriter trapFile, bool
             trapFile.Write("::");
         }
 
-        static void BuildNamedTypeId(this INamedTypeSymbol named, Context cx, TextWriter trapFile, Action<Context, TextWriter, ITypeSymbol> subTermAction)
+        static void BuildNamedTypeId(this INamedTypeSymbol named, Context cx, TextWriter trapFile, bool prefixAssembly, ISymbol symbolBeingDefined, Action<Context, TextWriter, ITypeSymbol, ISymbol> subTermAction)
         {
-            bool prefixAssembly = true;
             if (named.ContainingAssembly is null) prefixAssembly = false;
 
             if (named.IsTupleType)
@@ -224,7 +258,7 @@ static void BuildNamedTypeId(this INamedTypeSymbol named, Context cx, TextWriter
                     {
                         trapFile.Write(f.Name);
                         trapFile.Write(":");
-                        subTermAction(cx, tb0, f.Type);
+                        subTermAction(cx, tb0, f.Type, symbolBeingDefined);
                     }
                     );
                 trapFile.Write(")");
@@ -233,7 +267,7 @@ static void BuildNamedTypeId(this INamedTypeSymbol named, Context cx, TextWriter
 
             if (named.ContainingType != null)
             {
-                subTermAction(cx, trapFile, named.ContainingType);
+                subTermAction(cx, trapFile, named.ContainingType, symbolBeingDefined);
                 trapFile.Write('.');
             }
             else if (named.ContainingNamespace != null)
@@ -255,14 +289,14 @@ static void BuildNamedTypeId(this INamedTypeSymbol named, Context cx, TextWriter
             }
             else
             {
-                subTermAction(cx, trapFile, named.ConstructedFrom);
+                subTermAction(cx, trapFile, named.ConstructedFrom, symbolBeingDefined);
                 trapFile.Write('<');
                 // Encode the nullability of the type arguments in the label.
                 // Type arguments with different nullability can result in 
                 // a constructed type with different nullability of its members and methods,
                 // so we need to create a distinct database entity for it.
                 trapFile.BuildList(",", named.GetAnnotatedTypeArguments(),
-                    (ta, tb0) => subTermAction(cx, tb0, ta.Symbol)
+                    (ta, tb0) => subTermAction(cx, tb0, ta.Symbol, symbolBeingDefined)
                     );
                 trapFile.Write('>');
             }
@@ -274,16 +308,16 @@ static void BuildNamespace(this INamespaceSymbol ns, Context cx, TextWriter trap
             trapFile.Write('.');
         }
 
-        static void BuildAnonymousName(this ITypeSymbol type, Context cx, TextWriter trapFile, Action<Context, TextWriter, ITypeSymbol> subTermAction, bool includeParamName)
+        static void BuildAnonymousName(this ITypeSymbol type, Context cx, TextWriter trapFile, Action<Context, TextWriter, ITypeSymbol, ISymbol> subTermAction, bool includeParamName)
         {
             var buildParam = includeParamName
                 ? (prop, tb0) =>
                 {
                     tb0.Write(prop.Name);
                     tb0.Write(' ');
-                    subTermAction(cx, tb0, prop.Type);
+                    subTermAction(cx, tb0, prop.Type, null);
                 }
-            : (Action<IPropertySymbol, TextWriter>)((prop, tb0) => subTermAction(cx, tb0, prop.Type));
+            : (Action<IPropertySymbol, TextWriter>)((prop, tb0) => subTermAction(cx, tb0, prop.Type, null));
             int memberCount = type.GetMembers().OfType<IPropertySymbol>().Count();
             int hackTypeNumber = memberCount == 1 ? 1 : 0;
             trapFile.Write("<>__AnonType");
@@ -355,7 +389,7 @@ public static void BuildNamedTypeDisplayName(this INamedTypeSymbol namedType, Co
 
             if (namedType.IsAnonymousType)
             {
-                namedType.BuildAnonymousName(cx, trapFile, (cx0, tb0, sub) => sub.BuildDisplayName(cx0, tb0), false);
+                namedType.BuildAnonymousName(cx, trapFile, (cx0, tb0, sub, _) => sub.BuildDisplayName(cx0, tb0), false);
             }
 
             trapFile.Write(namedType.Name);
diff --git a/csharp/extractor/Semmle.Extraction/CommentProcessing.cs b/csharp/extractor/Semmle.Extraction/CommentProcessing.cs
index 2067f8694717..6cc122e92c11 100644
--- a/csharp/extractor/Semmle.Extraction/CommentProcessing.cs
+++ b/csharp/extractor/Semmle.Extraction/CommentProcessing.cs
@@ -35,7 +35,7 @@ public void AddComment(ICommentLine comment)
 
         class LocationComparer : IComparer<Location>
         {
-            public int Compare(Location l1, Location l2) => CommentProcessor.Compare(l1, l2);
+            int IComparer<Location>.Compare(Location? l1, Location? l2) => l1 is null ? (l2 is null ? 0 : -1) : l2 is null ? 1 : CommentProcessor.Compare(l1, l2);
         }
 
         /// <summary>
diff --git a/csharp/extractor/Semmle.Extraction/Context.cs b/csharp/extractor/Semmle.Extraction/Context.cs
index 3e55c1068e2c..1ec2f0db14aa 100644
--- a/csharp/extractor/Semmle.Extraction/Context.cs
+++ b/csharp/extractor/Semmle.Extraction/Context.cs
@@ -62,7 +62,7 @@ public Entity CreateEntity<Type, Entity>(ICachedEntityFactory<Type, Entity> fact
         /// <returns>The new/existing entity.</returns>
         public Entity CreateNullableEntity<Type, Entity>(ICachedEntityFactory<Type, Entity> factory, Type init) where Entity : ICachedEntity
         {
-            return init == null ? CreateEntity2(factory, init) : CreateNonNullEntity(factory, init);
+            return init == null ? CreateEntity2(factory, init) : CreateNonNullEntity(factory, init, objectEntityCache);
         }
 
         /// <summary>
@@ -75,7 +75,7 @@ public Entity CreateEntityFromSymbol<Type, Entity>(ICachedEntityFactory<Type, En
             where Entity : ICachedEntity
             where Type: ISymbol
         {
-            return init == null ? CreateEntity2(factory, init) : CreateNonNullEntity(factory, init);
+            return init == null ? CreateEntity2(factory, init) : CreateNonNullEntity(factory, init, symbolEntityCache);
         }
 
         // A recursion guard against writing to the trap file whilst writing an id to the trap file.
@@ -161,10 +161,15 @@ private void CheckEntityHasUniqueLabel(string id, ICachedEntity entity)
 
         public Entity CreateNonNullEntity<Type, Entity>(ICachedEntityFactory<Type, Entity> factory, Type init)
             where Entity : ICachedEntity
+            where Type : notnull
+            => CreateNonNullEntity(factory, init, objectEntityCache);
+
+        private Entity CreateNonNullEntity<Type, Entity>(ICachedEntityFactory<Type, Entity> factory, Type init, IDictionary<object, ICachedEntity> dictionary)
+            where Entity : ICachedEntity
         {
             if (init is null) throw new ArgumentException("Unexpected null value", nameof(init));
 
-            if (objectEntityCache.TryGetValue(init, out var cached))
+            if (dictionary.TryGetValue(init, out var cached))
                 return (Entity)cached;
 
             using (StackGuard)
@@ -173,7 +178,7 @@ public Entity CreateNonNullEntity<Type, Entity>(ICachedEntityFactory<Type, Entit
                 var entity = factory.Create(this, init);
                 entity.Label = label;
 
-                objectEntityCache[init] = entity;
+                dictionary[init] = entity;
 
                 DefineLabel(entity, TrapWriter.Writer, Extractor);
                 if (entity.NeedsPopulation)
@@ -227,7 +232,19 @@ public void AddFreshLabel(IEntity entity)
 #if DEBUG_LABELS
         readonly Dictionary<string, ICachedEntity> idLabelCache = new Dictionary<string, ICachedEntity>();
 #endif
-        readonly Dictionary<object, ICachedEntity> objectEntityCache = new Dictionary<object, ICachedEntity>();
+
+        // Adaptor to convert IEqualityComparer<ISymbol> to IEqualityComparer<object>
+        class SymbolComparer : IEqualityComparer<object>
+        {
+            IEqualityComparer<ISymbol> comparer = SymbolEqualityComparer.IncludeNullability;
+
+            bool IEqualityComparer<object>.Equals(object? x, object? y) => comparer.Equals(x as ISymbol, y as ISymbol);
+
+            int IEqualityComparer<object>.GetHashCode(object obj) => comparer.GetHashCode((ISymbol)obj);
+        }
+
+        readonly IDictionary<object, ICachedEntity> objectEntityCache = new Dictionary<object, ICachedEntity>();
+        readonly IDictionary<object, ICachedEntity> symbolEntityCache = new Dictionary<object, ICachedEntity>(10000, new SymbolComparer());
         readonly Dictionary<ICachedEntity, Label> entityLabelCache = new Dictionary<ICachedEntity, Label>();
         readonly HashSet<Label> extractedGenerics = new HashSet<Label>();
 
diff --git a/csharp/extractor/Semmle.Extraction/Entity.cs b/csharp/extractor/Semmle.Extraction/Entity.cs
index 616929dd47cd..d2315432c3eb 100644
--- a/csharp/extractor/Semmle.Extraction/Entity.cs
+++ b/csharp/extractor/Semmle.Extraction/Entity.cs
@@ -133,6 +133,19 @@ public static Entity CreateEntity<Type, Entity>(this ICachedEntityFactory<Type,
         public static Entity CreateNullableEntity<Type, Entity>(this ICachedEntityFactory<Type, Entity> factory, Context cx, Type init)
             where Entity : ICachedEntity => cx.CreateNullableEntity(factory, init);
 
+        /// <summary>
+        /// Creates and populates a new entity, or returns the existing one from the cache.
+        /// </summary>
+        /// <typeparam name="Type">The symbol type used to construct the entity.</typeparam>
+        /// <typeparam name="Entity">The type of the entity to create.</typeparam>
+        /// <param name="cx">The extractor context.</param>
+        /// <param name="factory">The factory used to construct the entity.</param>
+        /// <param name="init">The initializer for the entity, which may not be null.</param>
+        /// <returns>The entity.</returns>
+        public static Entity CreateEntityFromSymbol<Type, Entity>(this ICachedEntityFactory<Type, Entity> factory, Context cx, Type init)
+            where Entity : ICachedEntity
+            where Type : ISymbol => cx.CreateEntityFromSymbol(factory, init);
+
         /// <summary>
         /// Creates and populates a new entity, but uses a different cache.
         /// </summary>
diff --git a/csharp/ql/src/semmle/code/csharp/AnnotatedType.qll b/csharp/ql/src/semmle/code/csharp/AnnotatedType.qll
index 413e04f50177..0e5c512057a7 100644
--- a/csharp/ql/src/semmle/code/csharp/AnnotatedType.qll
+++ b/csharp/ql/src/semmle/code/csharp/AnnotatedType.qll
@@ -7,6 +7,7 @@
  */
 
 import csharp
+private import TypeRef
 
 private module Annotations {
   newtype TAnnotation =
diff --git a/csharp/ql/src/semmle/code/csharp/Attribute.qll b/csharp/ql/src/semmle/code/csharp/Attribute.qll
index fd19423441e2..89e5ccea97ef 100644
--- a/csharp/ql/src/semmle/code/csharp/Attribute.qll
+++ b/csharp/ql/src/semmle/code/csharp/Attribute.qll
@@ -4,6 +4,7 @@
 
 import Type
 private import semmle.code.csharp.ExprOrStmtParent
+private import TypeRef
 
 /**
  * An element that can have attributes. Either an assembly (`Assembly`), a field (`Field`),
diff --git a/csharp/ql/src/semmle/code/csharp/Callable.qll b/csharp/ql/src/semmle/code/csharp/Callable.qll
index 4e0ee381dbe9..20633435a316 100644
--- a/csharp/ql/src/semmle/code/csharp/Callable.qll
+++ b/csharp/ql/src/semmle/code/csharp/Callable.qll
@@ -3,13 +3,14 @@
  * such as methods and operators.
  */
 
-import Type
 import Member
 import Stmt
+import Type
 import exprs.Call
 private import dotnet
 private import semmle.code.csharp.ExprOrStmtParent
 private import semmle.code.csharp.metrics.Complexity
+private import TypeRef
 
 /**
  * An element that can be called.
diff --git a/csharp/ql/src/semmle/code/csharp/Event.qll b/csharp/ql/src/semmle/code/csharp/Event.qll
index 6b4ecc391907..f504811a4080 100644
--- a/csharp/ql/src/semmle/code/csharp/Event.qll
+++ b/csharp/ql/src/semmle/code/csharp/Event.qll
@@ -4,6 +4,7 @@
 
 import Member
 import Type
+private import TypeRef
 
 /**
  * An event, for example `E` on line 3 in
diff --git a/csharp/ql/src/semmle/code/csharp/Generics.qll b/csharp/ql/src/semmle/code/csharp/Generics.qll
index 9efdb46b8676..36e7efca6ffa 100644
--- a/csharp/ql/src/semmle/code/csharp/Generics.qll
+++ b/csharp/ql/src/semmle/code/csharp/Generics.qll
@@ -16,6 +16,7 @@
 import Location
 import Namespace
 private import dotnet
+private import TypeRef
 
 /**
  * A generic declaration. Either an unbound generic (`UnboundGeneric`) or a
diff --git a/csharp/ql/src/semmle/code/csharp/Member.qll b/csharp/ql/src/semmle/code/csharp/Member.qll
index 6f29ee5924af..6df943a51b9a 100644
--- a/csharp/ql/src/semmle/code/csharp/Member.qll
+++ b/csharp/ql/src/semmle/code/csharp/Member.qll
@@ -1,11 +1,12 @@
 /** Provides classes relating to declarations and type members. */
 
-import Element
-import Variable
 import Callable
+import Element
 import Modifier
-private import Implements
+import Variable
 private import dotnet
+private import Implements
+private import TypeRef
 
 /**
  * A declaration.
diff --git a/csharp/ql/src/semmle/code/csharp/Property.qll b/csharp/ql/src/semmle/code/csharp/Property.qll
index d71a10342264..a06f37f19d2b 100644
--- a/csharp/ql/src/semmle/code/csharp/Property.qll
+++ b/csharp/ql/src/semmle/code/csharp/Property.qll
@@ -2,12 +2,13 @@
  * Provides classes for properties, indexers, and accessors.
  */
 
-import Type
 import Member
 import Stmt
-private import semmle.code.csharp.ExprOrStmtParent
-private import dotnet
+import Type
 private import cil
+private import dotnet
+private import semmle.code.csharp.ExprOrStmtParent
+private import TypeRef
 
 /**
  * A declaration that may have accessors. Either an event (`Event`), a property
diff --git a/csharp/ql/src/semmle/code/csharp/Stmt.qll b/csharp/ql/src/semmle/code/csharp/Stmt.qll
index d020e9afebff..5e32a0cb10f8 100644
--- a/csharp/ql/src/semmle/code/csharp/Stmt.qll
+++ b/csharp/ql/src/semmle/code/csharp/Stmt.qll
@@ -4,12 +4,13 @@
  * All statements have the common base class `Stmt`.
  */
 
-import Location
 import Element
+import Location
 import Member
 import exprs.Expr
 private import semmle.code.csharp.Enclosing::Internal
 private import semmle.code.csharp.frameworks.System
+private import TypeRef
 
 /**
  * A statement.
diff --git a/csharp/ql/src/semmle/code/csharp/Type.qll b/csharp/ql/src/semmle/code/csharp/Type.qll
index 41127586a894..a24cffd1271d 100644
--- a/csharp/ql/src/semmle/code/csharp/Type.qll
+++ b/csharp/ql/src/semmle/code/csharp/Type.qll
@@ -1,14 +1,15 @@
 /** Provides classes for types. */
 
-import Location
-import Namespace
 import Callable
-import Property
 import Event
 import Generics
+import Location
+import Namespace
+import Property
 private import Conversion
-private import semmle.code.csharp.metrics.Coupling
 private import dotnet
+private import semmle.code.csharp.metrics.Coupling
+private import TypeRef
 
 /**
  * A type.
@@ -984,15 +985,3 @@ class TypeMention extends @type_mention {
   /** Gets the location of this type mention. */
   Location getLocation() { type_mention_location(this, result) }
 }
-
-/**
- * INTERNAL: Do not use.
- * Gets a type reference for a given type `type`.
- * This is used for extensionals that can be supplied
- * as either type references or types.
- */
-@type_or_ref getTypeRef(@type type) {
-  result = type
-  or
-  typeref_type(result, type)
-}
diff --git a/csharp/ql/src/semmle/code/csharp/TypeRef.qll b/csharp/ql/src/semmle/code/csharp/TypeRef.qll
new file mode 100644
index 000000000000..ca9b10be6008
--- /dev/null
+++ b/csharp/ql/src/semmle/code/csharp/TypeRef.qll
@@ -0,0 +1,67 @@
+/**
+ * INTERNAL: Do not use.
+ * Provides support for type-references.
+ */
+
+import csharp
+
+/**
+ * INTERNAL: Do not use.
+ * Gets a type reference for a given type `type`.
+ * This is used for extensionals that can be supplied
+ * as either type references or types.
+ */
+cached
+@type_or_ref getTypeRef(@type type) {
+  result = type
+  or
+  type = result.(TypeRefs::TypeRef).getCanonicalType()
+}
+
+private module TypeRefs {
+  /**
+   * A typeref is a reference to a type in some assembly.
+   * Often, a type can be present in multiple assemblies.
+   */
+  class TypeRef extends @typeref {
+    string getName() { typerefs(this, result) }
+
+    string toString() { result = getName() }
+
+    Type getAType() { typeref_type(this, result) }
+
+    /**
+     * Gets the "canonical type" represented by a typeref.
+     * This is because a typeref can reference multiple types, or a type with the same
+     * fully qualified name can exist in multiple assemblies.
+     * The canonical type is an arbitrarily chosen type from the list of candidate types.
+     */
+    Type getCanonicalType() {
+      result = this.getAType() and
+      not locationIsBetter(canonicalTypeLocation(result), canonicalTypeLocation(this.getAType()))
+    }
+  }
+
+  /** Gets a location of a type. */
+  private Location typeLocation(Type t) {
+    type_location(t, result)
+    or
+    exists(Type decl | constructed_generic(decl, t) and result = typeLocation(decl))
+  }
+
+  /** Gets the "canonical location" for a type. A type has only one canonical location. */
+  private Location canonicalTypeLocation(Type t) {
+    result = typeLocation(t) and
+    not locationIsBetter(result, typeLocation(t))
+  }
+
+  pragma[inline]
+  private predicate locationIsBetter(Location typeLocation, Location betterLocation) {
+    typeLocation.(Assembly).getFullName() < betterLocation.(Assembly).getFullName()
+    or
+    typeLocation instanceof Assembly and betterLocation instanceof SourceLocation
+    or
+    typeLocation.(SourceLocation).getFile().getAbsolutePath() <
+      betterLocation.(SourceLocation).getFile().getAbsolutePath()
+  }
+}
diff --git a/csharp/ql/src/semmle/code/csharp/Using.qll b/csharp/ql/src/semmle/code/csharp/Using.qll
index cc165873d416..c27f1a7180b7 100644
--- a/csharp/ql/src/semmle/code/csharp/Using.qll
+++ b/csharp/ql/src/semmle/code/csharp/Using.qll
@@ -5,6 +5,7 @@
  */
 
 import Element
+private import TypeRef
 
 /**
  * A `using` directive. Either a namespace `using` directive
diff --git a/csharp/ql/src/semmle/code/csharp/Variable.qll b/csharp/ql/src/semmle/code/csharp/Variable.qll
index 183d08c1eaa0..fdc11d9abacf 100644
--- a/csharp/ql/src/semmle/code/csharp/Variable.qll
+++ b/csharp/ql/src/semmle/code/csharp/Variable.qll
@@ -3,12 +3,13 @@
  * constants.
  */
 
-import Element
+import Assignable
 import Callable
+import Element
 import Type
-import Assignable
 private import dotnet
 private import semmle.code.csharp.ExprOrStmtParent
+private import TypeRef
 
 /**
  * A variable. Either a variable with local scope (`LocalScopeVariable`) or a field (`Field`).
diff --git a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowPrivate.qll b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowPrivate.qll
index 244bada9f26a..25b6393c1b97 100644
--- a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowPrivate.qll
+++ b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowPrivate.qll
@@ -738,7 +738,16 @@ private module Cached {
     or
     getATypeParameterSubType(t1) = getATypeParameterSubType(t2)
     or
-    getANonTypeParameterSubType(t1) = getANonTypeParameterSubType(t2)
+    t1 = getANonTypeParameterSubType(t2)
+    or
+    t2 = getANonTypeParameterSubType(t1)
+    or
+    exists(ValueOrRefType i1, ValueOrRefType i2 |
+      t1 = Gvn::getGlobalValueNumber(i1) and
+      t2 = Gvn::getGlobalValueNumber(i2) and
+      exists(ValueOrRefType common | i1 = common.getABaseType+() and i2 = common.getABaseType+()) and
+      (i1 instanceof Interface or i2 instanceof Interface)
+    )
   }
 
   cached
diff --git a/csharp/ql/src/semmle/code/csharp/exprs/Expr.qll b/csharp/ql/src/semmle/code/csharp/exprs/Expr.qll
index cf95a524350b..38fcbef2306a 100644
--- a/csharp/ql/src/semmle/code/csharp/exprs/Expr.qll
+++ b/csharp/ql/src/semmle/code/csharp/exprs/Expr.qll
@@ -4,10 +4,6 @@
  * All expressions have the common base class `Expr`.
  */
 
-import semmle.code.csharp.Location
-import semmle.code.csharp.Stmt
-import semmle.code.csharp.Callable
-import semmle.code.csharp.Type
 import Access
 import ArithmeticOperation
 import Assignment
@@ -19,9 +15,14 @@ import Dynamic
 import Literal
 import LogicalOperation
 import semmle.code.csharp.controlflow.ControlFlowElement
+import semmle.code.csharp.Callable
+import semmle.code.csharp.Location
+import semmle.code.csharp.Stmt
+import semmle.code.csharp.Type
+private import dotnet
 private import semmle.code.csharp.Enclosing::Internal
 private import semmle.code.csharp.frameworks.System
-private import dotnet
+private import semmle.code.csharp.TypeRef
 
 /**
  * An expression. Either an access (`Access`), a call (`Call`), an object or
diff --git a/csharp/ql/test/library-tests/aliases/aliases2.expected b/csharp/ql/test/library-tests/aliases/aliases2.expected
index 45870c5dda24..50cfbf37f1ed 100644
--- a/csharp/ql/test/library-tests/aliases/aliases2.expected
+++ b/csharp/ql/test/library-tests/aliases/aliases2.expected
@@ -1,3 +1,3 @@
-| Program.cs:18:21:18:22 | c1 | Assembly1.dll:0:0:0:0 | Class |
-| Program.cs:19:21:19:22 | c2 | Assembly2.dll:0:0:0:0 | Class |
+| Program.cs:18:21:18:22 | c1 | Program.cs:10:7:10:11 | Class |
+| Program.cs:19:21:19:22 | c2 | Program.cs:10:7:10:11 | Class |
 | Program.cs:20:15:20:16 | c3 | Program.cs:10:7:10:11 | Class |
diff --git a/csharp/ql/test/library-tests/csharp8/NullableRefTypes.expected b/csharp/ql/test/library-tests/csharp8/NullableRefTypes.expected
index db4f3c6fb5d8..891ba1602cb0 100644
--- a/csharp/ql/test/library-tests/csharp8/NullableRefTypes.expected
+++ b/csharp/ql/test/library-tests/csharp8/NullableRefTypes.expected
@@ -243,7 +243,7 @@ expressionTypes
 | NullableRefTypes.cs:19:33:19:36 | this access | MyClass! |
 | NullableRefTypes.cs:26:44:26:53 | throw ... | MyClass![]! |
 | NullableRefTypes.cs:26:50:26:53 | null | null |
-| NullableRefTypes.cs:27:44:27:53 | throw ... | MyClass![]! |
+| NullableRefTypes.cs:27:44:27:53 | throw ... | MyClass?[]! |
 | NullableRefTypes.cs:27:50:27:53 | null | null |
 | NullableRefTypes.cs:30:21:30:24 | null | null |
 | NullableRefTypes.cs:31:20:31:23 | this access | MyClass! |