Merge pull request #2245 from calumgrant/cs/nullability-refactor

C#: Store nullability on the side

csharp/extractor/Semmle.Extraction.CIL/Entities/Type.cs

@@ -920,7 +920,8 @@ namespace Semmle.Extraction.CIL.Entities
         {
             elementType.GetId(trapFile, inContext);
             trapFile.Write('[');
-            trapFile.Write(rank);
+            for (int i = 1; i < rank; ++i)
+                trapFile.Write(',');
             trapFile.Write(']');
         }
 
@@ -1206,7 +1207,10 @@ namespace Semmle.Extraction.CIL.Entities
             public void WriteId(TextWriter trapFile, GenericContext gc)
             {
                 elementType.WriteId(trapFile, gc);
-                trapFile.Write("[]");
+                trapFile.Write('[');
+                for (int i=1; i<shape.Rank; ++i)
+                    trapFile.Write(',');
+                trapFile.Write(']');
             }
         }
 

csharp/extractor/Semmle.Extraction.CSharp/Entities/Event.cs

@@ -21,7 +21,7 @@ namespace Semmle.Extraction.CSharp.Entities
 
         public override void Populate(TextWriter trapFile)
         {
-            PopulateNullability(trapFile, symbol.NullableAnnotation);
+            PopulateNullability(trapFile, symbol.GetAnnotatedType());
 
             var type = Type.Create(Context, symbol.Type);
             trapFile.events(this, symbol.GetName(), ContainingType, type.TypeRef, Create(Context, symbol.OriginalDefinition));

csharp/extractor/Semmle.Extraction.CSharp/Entities/Field.cs

@@ -30,7 +30,7 @@ namespace Semmle.Extraction.CSharp.Entities
             PopulateMetadataHandle(trapFile);
             PopulateAttributes();
             ContainingType.PopulateGenerics();
-            PopulateNullability(trapFile, symbol.NullableAnnotation);
+            PopulateNullability(trapFile, symbol.GetAnnotatedType());
 
             Field unboundFieldKey = Field.Create(Context, symbol.OriginalDefinition);
             trapFile.fields(this, (symbol.IsConst ? 2 : 1), symbol.Name, ContainingType, Type.Type.TypeRef, unboundFieldKey);

csharp/extractor/Semmle.Extraction.CSharp/Entities/Indexer.cs

@@ -14,7 +14,7 @@ namespace Semmle.Extraction.CSharp.Entities
 
         public override void Populate(TextWriter trapFile)
         {
-            PopulateNullability(trapFile, symbol.NullableAnnotation);
+            PopulateNullability(trapFile, symbol.GetAnnotatedType());
 
             var type = Type.Create(Context, symbol.Type);
             trapFile.indexers(this, symbol.GetName(useMetadataName: true), ContainingType, type.TypeRef, OriginalDefinition);

csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalVariable.cs

@@ -31,7 +31,7 @@ namespace Semmle.Extraction.CSharp.Entities
         {
             if (symbol is ILocalSymbol local)
             {
-                PopulateNullability(trapFile, local.NullableAnnotation);
+                PopulateNullability(trapFile, local.GetAnnotatedType());
                 if (local.IsRef)
                     trapFile.type_annotation(this, Kinds.TypeAnnotation.Ref);
             }

csharp/extractor/Semmle.Extraction.CSharp/Entities/Method.cs

@@ -264,7 +264,7 @@ namespace Semmle.Extraction.CSharp.Entities
 
             var methodKind = methodDecl.MethodKind;
 
-            if(methodKind == MethodKind.ExplicitInterfaceImplementation)
+            if (methodKind == MethodKind.ExplicitInterfaceImplementation)
             {
                 // Retrieve the original method kind
                 methodKind = methodDecl.ExplicitInterfaceImplementations.Select(m => m.MethodKind).FirstOrDefault();
@@ -345,11 +345,12 @@ namespace Semmle.Extraction.CSharp.Entities
                     foreach (var tp in symbol.GetAnnotatedTypeArguments())
                     {
                         trapFile.type_arguments(Type.Create(Context, tp.Symbol), child, this);
-                        var ta = tp.Nullability.GetTypeAnnotation();
-                        if (ta != Kinds.TypeAnnotation.None)
-                            trapFile.type_argument_annotation(this, child, ta);
                         child++;
                     }
+
+                    var nullability = new Nullability(symbol);
+                    if (!nullability.IsOblivious)
+                        trapFile.type_nullability(this, NullabilityEntity.Create(Context, nullability));
                 }
                 else
                 {
@@ -380,7 +381,7 @@ namespace Semmle.Extraction.CSharp.Entities
             PopulateMethodBody(trapFile);
             PopulateGenerics(trapFile);
             PopulateMetadataHandle(trapFile);
-            PopulateNullability(trapFile, symbol.ReturnNullableAnnotation);
+            PopulateNullability(trapFile, symbol.GetAnnotatedReturnType());
         }
 
         public override TrapStackBehaviour TrapStackBehaviour => TrapStackBehaviour.PushesLabel;

csharp/extractor/Semmle.Extraction.CSharp/Entities/Parameter.cs

@@ -103,7 +103,7 @@ namespace Semmle.Extraction.CSharp.Entities
         public override void Populate(TextWriter trapFile)
         {
             PopulateAttributes();
-            PopulateNullability(trapFile, symbol.NullableAnnotation);
+            PopulateNullability(trapFile, symbol.GetAnnotatedType());
             PopulateRefKind(trapFile, symbol.RefKind);
 
             if (symbol.Name != Original.symbol.Name)

csharp/extractor/Semmle.Extraction.CSharp/Entities/Property.cs

@@ -28,7 +28,7 @@ namespace Semmle.Extraction.CSharp.Entities
             PopulateAttributes();
             PopulateModifiers(trapFile);
             BindComments();
-            PopulateNullability(trapFile, symbol.NullableAnnotation);
+            PopulateNullability(trapFile, symbol.GetAnnotatedType());
             PopulateRefKind(trapFile, symbol.RefKind);
 
             var type = Type.Create(Context, symbol.Type);

csharp/extractor/Semmle.Extraction.CSharp/Entities/Symbol.cs

@@ -28,11 +28,13 @@ namespace Semmle.Extraction.CSharp.Entities
                 Attribute.ExtractAttributes(Context, symbol, this);
         }
 
-        protected void PopulateNullability(TextWriter trapFile, NullableAnnotation annotation)
+        protected void PopulateNullability(TextWriter trapFile, AnnotatedTypeSymbol type)
         {
-            var ta = annotation.GetTypeAnnotation();
-            if (ta != Kinds.TypeAnnotation.None)
-                trapFile.type_annotation(this, ta);
+            var n = NullabilityEntity.Create(Context, Nullability.Create(type));
+            if (!type.HasObliviousNullability())
+            {
+                trapFile.type_nullability(this, n);
+            }
         }
 
         protected void PopulateRefKind(TextWriter trapFile, RefKind kind)

csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/ArrayType.cs

@@ -27,13 +27,11 @@ namespace Semmle.Extraction.CSharp.Entities
         {
             trapFile.array_element_type(this, Dimension, Rank, element.Type.TypeRef);
             PopulateType(trapFile);
-            PopulateNullability(trapFile, symbol.ElementNullableAnnotation);
         }
 
         public override void WriteId(TextWriter trapFile)
         {
             trapFile.WriteSubId(element.Type);
-            trapFile.Write((int)symbol.ElementNullableAnnotation);
             symbol.BuildArraySuffix(trapFile);
             trapFile.Write(";type");
         }

csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs

@@ -57,9 +57,6 @@ namespace Semmle.Extraction.CSharp.Entities
 
                     for (int i = 0; i < symbol.TypeArguments.Length; ++i)
                     {
-                        var ta = symbol.TypeArgumentsNullableAnnotations[i].GetTypeAnnotation();
-                        if (ta != Kinds.TypeAnnotation.None)
-                            trapFile.type_argument_annotation(this, i, ta);
                         trapFile.type_arguments(TypeArguments[i].TypeRef, i, this);
                     }
                 }
@@ -166,7 +163,8 @@ namespace Semmle.Extraction.CSharp.Entities
             referencedType = Type.Create(cx, symbol);
         }
 
-        public static NamedTypeRef Create(Context cx, INamedTypeSymbol type) => NamedTypeRefFactory.Instance.CreateEntity2(cx, type);
+        public static NamedTypeRef Create(Context cx, INamedTypeSymbol type) =>
+            NamedTypeRefFactory.Instance.CreateEntity2(cx, type);
 
         class NamedTypeRefFactory : ICachedEntityFactory<INamedTypeSymbol, NamedTypeRef>
         {

csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/Nullability.cs

@@ -0,0 +1,269 @@
+using Microsoft.CodeAnalysis;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Semmle.Extraction.CSharp.Entities
+{
+    public sealed class Nullability
+    {
+        public int Annotation { get; }
+
+        static readonly Nullability[] EmptyArray = new Nullability[0];
+        public readonly Nullability[] NullableParameters;
+
+        public static Nullability Create(AnnotatedTypeSymbol ts)
+        {
+            if (ts.HasConsistentNullability())
+            {
+                switch (ts.Nullability)
+                {
+                    case NullableAnnotation.Annotated:
+                        return annotated;
+                    case NullableAnnotation.NotAnnotated:
+                        return notannotated;
+                    default:
+                        return oblivious;
+                }
+            }
+
+            return new Nullability(ts);
+        }
+
+        public bool IsOblivious => Annotation == 0 && NullableParameters.Length == 0;
+
+        static readonly Nullability oblivious = new Nullability(NullableAnnotation.Disabled);
+        static readonly Nullability annotated = new Nullability(NullableAnnotation.Annotated);
+        static readonly Nullability notannotated = new Nullability(NullableAnnotation.NotAnnotated);
+
+        private Nullability(NullableAnnotation n)
+        {
+            switch (n)
+            {
+                case NullableAnnotation.NotAnnotated:
+                    Annotation = 1;
+                    break;
+                case NullableAnnotation.Annotated:
+                    Annotation = 2;
+                    break;
+                default:
+                    Annotation = 0;
+                    break;
+            }
+            NullableParameters = EmptyArray;
+        }
+
+        private Nullability(AnnotatedTypeSymbol ts) : this(ts.Nullability)
+        {
+            NullableParameters = ts.HasConsistentNullability() ? EmptyArray : ts.GetAnnotatedTypeArguments().Select(Create).ToArray();
+        }
+
+        public Nullability(IMethodSymbol method)
+        {
+            Annotation = 0;
+            NullableParameters = method.GetAnnotatedTypeArguments().Select(a => new Nullability(a)).ToArray();
+        }
+
+        public override bool Equals(object other)
+        {
+            return other is Nullability n && Annotation == n.Annotation && NullableParameters.SequenceEqual(n.NullableParameters);
+        }
+
+        public override int GetHashCode()
+        {
+            int h = Annotation;
+
+            foreach (var t in NullableParameters)
+                h = h * 5 + t.GetHashCode();
+
+            return h;
+        }
+
+        public void WriteId(TextWriter trapFile)
+        {
+            trapFile.Write(Annotation);
+            trapFile.Write('(');
+            foreach (var s in NullableParameters)
+                s.WriteId(trapFile);
+            trapFile.Write(')');
+        }
+
+        public override string ToString()
+        {
+            using (var w = new StringWriter())
+            {
+                WriteId(w);
+                return w.ToString();
+            }
+        }
+    }
+
+    public class NullabilityEntity : CachedEntity<Nullability>
+    {
+        public NullabilityEntity(Context cx, Nullability init) : base(cx, init)
+        {
+        }
+
+        public override Location ReportingLocation => throw new System.NotImplementedException();
+
+        public override bool NeedsPopulation => true;
+
+        public override TrapStackBehaviour TrapStackBehaviour => TrapStackBehaviour.NoLabel;
+
+        public override void Populate(TextWriter trapFile)
+        {
+            trapFile.nullability(this, symbol.Annotation);
+
+            int i = 0;
+            foreach (var s in symbol.NullableParameters)
+            {
+                trapFile.nullability_parent(Create(Context, s), i, this);
+                i++;
+            }
+        }
+
+        public override void WriteId(TextWriter trapFile)
+        {
+            symbol.WriteId(trapFile);
+        }
+
+        public static NullabilityEntity Create(Context cx, Nullability init) => NullabilityFactory.Instance.CreateEntity(cx, init);
+
+        class NullabilityFactory : ICachedEntityFactory<Nullability, NullabilityEntity>
+        {
+            public static readonly NullabilityFactory Instance = new NullabilityFactory();
+
+            public NullabilityEntity Create(Context cx, Nullability init) => new NullabilityEntity(cx, init);
+        }
+    }
+
+    public static class NullabilityExtensions
+    {
+        /// <summary>
+        /// Gets the annotated type of an ILocalSymbol.
+        /// This has not yet been exposed on the public API.
+        /// </summary>
+        public static AnnotatedTypeSymbol GetAnnotatedType(this ILocalSymbol symbol) => new AnnotatedTypeSymbol(symbol.Type, symbol.NullableAnnotation);
+
+        /// <summary>
+        /// Gets the annotated type of an IParameterSymbol.
+        /// This has not yet been exposed on the public API.
+        /// </summary>
+        public static AnnotatedTypeSymbol GetAnnotatedType(this IParameterSymbol symbol) => new AnnotatedTypeSymbol(symbol.Type, symbol.NullableAnnotation);
+
+        /// <summary>
+        /// Gets the annotated type of an IPropertySymbol.
+        /// This has not yet been exposed on the public API.
+        /// </summary>
+        public static AnnotatedTypeSymbol GetAnnotatedType(this IPropertySymbol symbol) => new AnnotatedTypeSymbol(symbol.Type, symbol.NullableAnnotation);
+
+        /// <summary>
+        /// Gets the annotated type of an IEventSymbol.
+        /// This has not yet been exposed on the public API.
+        /// </summary>
+        public static AnnotatedTypeSymbol GetAnnotatedType(this IEventSymbol symbol) => new AnnotatedTypeSymbol(symbol.Type, symbol.NullableAnnotation);
+
+        /// <summary>
+        /// Gets the annotated type of an IFieldSymbol.
+        /// This has not yet been exposed on the public API.
+        /// </summary>
+        public static AnnotatedTypeSymbol GetAnnotatedType(this IFieldSymbol symbol) => new AnnotatedTypeSymbol(symbol.Type, symbol.NullableAnnotation);
+
+        /// <summary>
+        /// Gets the annotated return type of an IMethodSymbol.
+        /// This has not yet been exposed on the public API.
+        /// </summary>
+        public static AnnotatedTypeSymbol GetAnnotatedReturnType(this IMethodSymbol symbol) => new AnnotatedTypeSymbol(symbol.ReturnType, symbol.ReturnNullableAnnotation);
+
+        /// <summary>
+        /// Gets the type annotation for a NullableAnnotation.
+        /// </summary>
+        public static Kinds.TypeAnnotation GetTypeAnnotation(this NullableAnnotation na)
+        {
+            switch (na)
+            {
+                case NullableAnnotation.Annotated:
+                    return Kinds.TypeAnnotation.Annotated;
+                case NullableAnnotation.NotAnnotated:
+                    return Kinds.TypeAnnotation.NotAnnotated;
+                default:
+                    return Kinds.TypeAnnotation.None;
+            }
+        }
+
+        public static IEnumerable<AnnotatedTypeSymbol> GetAnnotatedTypeArguments(this AnnotatedTypeSymbol at)
+        {
+            switch (at.Symbol)
+            {
+                case IArrayTypeSymbol array:
+                    yield return array.GetAnnotatedElementType();
+                    break;
+                case INamedTypeSymbol named:
+                    foreach (var n in named.GetAnnotatedTypeArguments())
+                        yield return n;
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Checks if this type has consistent nullability, which is the most common case.
+        /// Either the code is oblivious to nullability, or is non-nullable.
+        /// This is so that we can avoid populating nullability in most cases.
+        /// For example,
+        /// <code>
+        /// IEnumerable&lt;string?&gt // false
+        /// IEnumerable&lt;string?&gt? // true
+        /// string? // true
+        /// string[] // true
+        /// string?[] // false
+        /// string?[]? // true
+        /// </code>
+        /// </summary>
+        /// <param name="at">The annotated type.</param>
+        /// <returns>If the nullability is consistent in the type.</returns>
+        public static bool HasConsistentNullability(this AnnotatedTypeSymbol at) =>
+            at.GetAnnotatedTypeArguments().All(a => a.Nullability == at.Nullability && a.HasConsistentNullability());
+
+        /// <summary>
+        /// Holds if the type symbol is completely oblivious to nullability.
+        /// </summary>
+        /// <param name="at">The annotated type symbol.</param>
+        /// <returns>If at is oblivious.</returns>
+        public static bool HasObliviousNullability(this AnnotatedTypeSymbol at) =>
+            at.Nullability.GetTypeAnnotation() == Kinds.TypeAnnotation.None && at.HasConsistentNullability();
+
+        /// <summary>
+        /// Gets the annotated element type of an IArrayTypeSymbol.
+        /// This has not yet been exposed on the public API.
+        /// </summary>
+        public static AnnotatedTypeSymbol GetAnnotatedElementType(this IArrayTypeSymbol symbol) =>
+            new AnnotatedTypeSymbol(symbol.ElementType, symbol.ElementNullableAnnotation);
+
+        /// <summary>
+        /// Gets the annotated type arguments of an INamedTypeSymbol.
+        /// This has not yet been exposed on the public API.
+        /// </summary>
+        public static IEnumerable<AnnotatedTypeSymbol> GetAnnotatedTypeArguments(this INamedTypeSymbol symbol) =>
+            symbol.TypeArguments.Zip(symbol.TypeArgumentsNullableAnnotations, (t, a) => new AnnotatedTypeSymbol(t, a));
+
+        /// <summary>
+        /// Gets the annotated type arguments of an IMethodSymbol.
+        /// This has not yet been exposed on the public API.
+        /// </summary>
+        public static IEnumerable<AnnotatedTypeSymbol> GetAnnotatedTypeArguments(this IMethodSymbol symbol) =>
+            symbol.TypeArguments.Zip(symbol.TypeArgumentsNullableAnnotations, (t, a) => new AnnotatedTypeSymbol(t, a));
+
+        /// <summary>
+        /// Gets the annotated type constraints of an ITypeParameterSymbol.
+        /// This has not yet been exposed on the public API.
+        /// </summary>
+        public static IEnumerable<AnnotatedTypeSymbol> GetAnnotatedTypeConstraints(this ITypeParameterSymbol symbol) =>
+            symbol.ConstraintTypes.Zip(symbol.ConstraintNullableAnnotations, (t, a) => new AnnotatedTypeSymbol(t, a));
+
+        /// <summary>
+        /// Creates an AnnotatedTypeSymbol from an ITypeSymbol.
+        /// </summary>
+        public static AnnotatedTypeSymbol WithAnnotation(this ITypeSymbol symbol, NullableAnnotation annotation) =>
+            new AnnotatedTypeSymbol(symbol, annotation);
+    }
+}

csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TypeParameter.cs

@@ -51,11 +51,11 @@ namespace Semmle.Extraction.CSharp.Entities
                     baseType = abase.Symbol;
                 var t = Create(Context, abase.Symbol);
                 trapFile.specific_type_parameter_constraints(constraints, t.TypeRef);
-                if (abase.Nullability.GetTypeAnnotation() != Kinds.TypeAnnotation.None)
-                    trapFile.specific_type_parameter_annotation(constraints, t.TypeRef, abase.Nullability.GetTypeAnnotation());
+                if (!abase.HasObliviousNullability())
+                    trapFile.specific_type_parameter_nullability(constraints, t.TypeRef, NullabilityEntity.Create(Context, Nullability.Create(abase)));
             }
 
-            trapFile.types(this, Semmle.Extraction.Kinds.TypeKind.TYPE_PARAMETER, symbol.Name);
+            trapFile.types(this, Kinds.TypeKind.TYPE_PARAMETER, symbol.Name);
             trapFile.extend(this, Create(Context, baseType).TypeRef);
 
             Namespace parentNs = Namespace.Create(Context, symbol.TypeParameterKind == TypeParameterKind.Method ? Context.Compilation.GlobalNamespace : symbol.ContainingNamespace);
@@ -66,7 +66,7 @@ namespace Semmle.Extraction.CSharp.Entities
                 trapFile.type_location(this, Context.Create(l));
             }
 
-            if (this.IsSourceDeclaration)
+            if (IsSourceDeclaration)
             {
                 var declSyntaxReferences = symbol.DeclaringSyntaxReferences.Select(d => d.GetSyntax()).
                     Select(s => s.Parent).Where(p => p != null).Select(p => p.Parent).ToArray();

csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs

@@ -262,7 +262,9 @@ namespace Semmle.Extraction.CSharp
                 // 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); trapFile.Write((int)ta.Nullability); });
+                trapFile.BuildList(",", named.GetAnnotatedTypeArguments(),
+                    (ta, tb0) => subTermAction(cx, tb0, ta.Symbol)
+                    );
                 trapFile.Write('>');
             }
         }
@@ -279,7 +281,7 @@ namespace Semmle.Extraction.CSharp
                 ? (prop, tb0) =>
                 {
                     tb0.Write(prop.Name);
-                    trapFile.Write(' ');
+                    tb0.Write(' ');
                     subTermAction(cx, tb0, prop.Type);
                 }
             : (Action<IPropertySymbol, TextWriter>)((prop, tb0) => subTermAction(cx, tb0, prop.Type));
@@ -457,30 +459,6 @@ namespace Semmle.Extraction.CSharp
         public static SymbolInfo GetSymbolInfo(this Context cx, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode node) =>
             cx.GetModel(node).GetSymbolInfo(node);
 
-        /// <summary>
-        /// Gets the symbol for a particular syntax node.
-        /// Throws an exception if the symbol is not found.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// This gives a nicer message than a "null pointer exception",
-        /// and should be used where we require a symbol to be resolved.
-        /// </remarks>
-        ///
-        /// <param name="cx">The extraction context.</param>
-        /// <param name="node">The syntax node.</param>
-        /// <returns>The resolved symbol.</returns>
-        public static ISymbol GetSymbol(this Context cx, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode node)
-        {
-            var info = GetSymbolInfo(cx, node);
-            if (info.Symbol == null)
-            {
-                throw new InternalError(node, "Could not resolve symbol");
-            }
-
-            return info.Symbol;
-        }
-
         /// <summary>
         /// Determines the type of a node, or default
         /// if the type could not be determined.
@@ -494,78 +472,11 @@ namespace Semmle.Extraction.CSharp
             return new AnnotatedTypeSymbol(info.Type.DisambiguateType(), info.Nullability.Annotation);
         }
 
-        /// <summary>
-        /// Gets the annotated type of an ILocalSymbol.
-        /// This has not yet been exposed on the public API.
-        /// </summary>
-        public static AnnotatedTypeSymbol GetAnnotatedType(this ILocalSymbol symbol) => new AnnotatedTypeSymbol(symbol.Type, symbol.NullableAnnotation);
-
-        /// <summary>
-        /// Gets the annotated type of an IPropertySymbol.
-        /// This has not yet been exposed on the public API.
-        /// </summary>
-        public static AnnotatedTypeSymbol GetAnnotatedType(this IPropertySymbol symbol) => new AnnotatedTypeSymbol(symbol.Type, symbol.NullableAnnotation);
-
-        /// <summary>
-        /// Gets the annotated type of an IFieldSymbol.
-        /// This has not yet been exposed on the public API.
-        /// </summary>
-        public static AnnotatedTypeSymbol GetAnnotatedType(this IFieldSymbol symbol) => new AnnotatedTypeSymbol(symbol.Type, symbol.NullableAnnotation);
-
-        /// <summary>
-        /// Gets the annotated return type of an IMethodSymbol.
-        /// This has not yet been exposed on the public API.
-        /// </summary>
-        public static AnnotatedTypeSymbol GetAnnotatedReturnType(this IMethodSymbol symbol) => new AnnotatedTypeSymbol(symbol.ReturnType, symbol.ReturnNullableAnnotation);
-
-        /// <summary>
-        /// Gets the type annotation for a NullableAnnotation.
-        /// </summary>
-        public static Kinds.TypeAnnotation GetTypeAnnotation(this NullableAnnotation na)
-        {
-            switch(na)
-            {
-                case NullableAnnotation.Annotated:
-                    return Kinds.TypeAnnotation.Annotated;
-                case NullableAnnotation.NotAnnotated:
-                    return Kinds.TypeAnnotation.NotAnnotated;
-                default:
-                    return Kinds.TypeAnnotation.None;
-            }
-        }
-
-        /// <summary>
-        /// Gets the annotated element type of an IArrayTypeSymbol.
-        /// This has not yet been exposed on the public API.
-        /// </summary>
-        public static AnnotatedTypeSymbol GetAnnotatedElementType(this IArrayTypeSymbol symbol) =>
-            new AnnotatedTypeSymbol(symbol.ElementType, symbol.ElementNullableAnnotation);
-
         /// <summary>
         /// Gets the annotated type arguments of an INamedTypeSymbol.
         /// This has not yet been exposed on the public API.
         /// </summary>
         public static IEnumerable<AnnotatedTypeSymbol> GetAnnotatedTypeArguments(this INamedTypeSymbol symbol) =>
             symbol.TypeArguments.Zip(symbol.TypeArgumentsNullableAnnotations, (t, a) => new AnnotatedTypeSymbol(t, a));
-
-        /// <summary>
-        /// Gets the annotated type arguments of an IMethodSymbol.
-        /// This has not yet been exposed on the public API.
-        /// </summary>
-        public static IEnumerable<AnnotatedTypeSymbol> GetAnnotatedTypeArguments(this IMethodSymbol symbol) =>
-            symbol.TypeArguments.Zip(symbol.TypeArgumentsNullableAnnotations, (t, a) => new AnnotatedTypeSymbol(t, a));
-
-        /// <summary>
-        /// Gets the annotated type constraints of an ITypeParameterSymbol.
-        /// This has not yet been exposed on the public API.
-        /// </summary>
-        public static IEnumerable<AnnotatedTypeSymbol> GetAnnotatedTypeConstraints(this ITypeParameterSymbol symbol) =>
-            symbol.ConstraintTypes.Zip(symbol.ConstraintNullableAnnotations, (t, a) => new AnnotatedTypeSymbol(t, a));
-
-        /// <summary>
-        /// Creates an AnnotatedTypeSymbol from an ITypeSymbol.
-        /// </summary>
-        public static AnnotatedTypeSymbol WithAnnotation(this ITypeSymbol symbol, NullableAnnotation annotation) =>
-            new AnnotatedTypeSymbol(symbol, annotation);
     }
 }

csharp/extractor/Semmle.Extraction.CSharp/Tuples.cs

@@ -381,6 +381,16 @@ namespace Semmle.Extraction.CSharp
             trapFile.WriteTuple("nullable_underlying_type", nullableType, underlyingType);
         }
 
+        internal static void nullability(this TextWriter trapFile, NullabilityEntity nullability, int annotation)
+        {
+            trapFile.WriteTuple("nullability", nullability, annotation);
+        }
+
+        internal static void nullability_parent(this TextWriter trapFile, NullabilityEntity nullability, int index, NullabilityEntity parent)
+        {
+            trapFile.WriteTuple("nullability_parent", nullability, index, parent);
+        }
+
         internal static void numlines(this TextWriter trapFile, IEntity label, LineCounts lineCounts)
         {
             trapFile.WriteTuple("numlines", label, lineCounts.Total, lineCounts.Code, lineCounts.Comment);
@@ -446,9 +456,9 @@ namespace Semmle.Extraction.CSharp
             trapFile.WriteTuple("specific_type_parameter_constraints", constraints, baseType);
         }
 
-        internal static void specific_type_parameter_annotation(this TextWriter trapFile, TypeParameterConstraints constraints, Type baseType, TypeAnnotation annotation)
+        internal static void specific_type_parameter_nullability(this TextWriter trapFile, TypeParameterConstraints constraints, Type baseType, NullabilityEntity nullability)
         {
-            trapFile.WriteTuple("specific_type_parameter_annotation", constraints, baseType, (int)annotation);
+            trapFile.WriteTuple("specific_type_parameter_nullability", constraints, baseType, nullability);
         }
 
         internal static void stmt_location(this TextWriter trapFile, Statement stmt, Location location)
@@ -481,9 +491,14 @@ namespace Semmle.Extraction.CSharp
             trapFile.WriteTuple("type_annotation", element, (int)annotation);
         }
 
-        internal static void type_argument_annotation(this TextWriter trapFile, IEntity element, int index, Kinds.TypeAnnotation annotation)
+        internal static void type_arguments(this TextWriter trapFile, Type arg, int n, IEntity typeOrMethod)
         {
-            trapFile.WriteTuple("type_argument_annotation", element, index, (int)annotation);
+            trapFile.WriteTuple("type_arguments", arg, n, typeOrMethod);
+        }
+
+        internal static void type_location(this TextWriter trapFile, Type type, Location location)
+        {
+            trapFile.WriteTuple("type_location", type, location);
         }
 
         internal static void type_mention(this TextWriter trapFile, TypeMention ta, Type type, IEntity parent)
@@ -496,14 +511,9 @@ namespace Semmle.Extraction.CSharp
             trapFile.WriteTuple("type_mention_location", ta, loc);
         }
 
-        internal static void type_arguments(this TextWriter trapFile, Type arg, int n, IEntity typeOrMethod)
+        internal static void type_nullability(this TextWriter trapFile, IEntity element, NullabilityEntity nullability)
         {
-            trapFile.WriteTuple("type_arguments", arg, n, typeOrMethod);
-        }
-
-        internal static void type_location(this TextWriter trapFile, Type type, Location location)
-        {
-            trapFile.WriteTuple("type_location", type, location);
+            trapFile.WriteTuple("type_nullability", element, nullability);
         }
 
         internal static void type_parameter_constraints(this TextWriter trapFile, TypeParameterConstraints constraints, TypeParameter typeParam)

csharp/ql/src/semmle/code/csharp/AnnotatedType.qll

@@ -10,120 +10,223 @@ import csharp
 
 private module Annotations {
   newtype TAnnotation =
-    TNotNullableRefType() or
-    TNullableRefType() or
     TReadonlyRefType() or
     TRefType() or
-    TOutType()
+    TOutType() or
+    TNullability(@nullability n)
 
   /** An annotation on a type. */
   class TypeAnnotation extends TAnnotation {
-    /** Holds if this string should prefix the type string. */
-    predicate isPrefix() { none() }
+    /** Gets the bit position in the bit-field, also used to order the annotations in the text format. */
+    int getBit() { none() }
 
-    /** Holds if this string should suffix the type string. */
-    predicate isSuffix() { none() }
+    /** Gets the string prefixing the type, if any. */
+    string getPrefix() { none() }
 
-    /** Gets the bit position in the bit-field. */
-    abstract int getBit();
+    /** Gets the string suffixing the type, if any. */
+    string getSuffix() { none() }
 
     /** Gets a string representation of this type annotation. */
-    abstract string toString();
-  }
-
-  /** An annotation indicating that the type is not nullable. */
-  class NonNullableRefType extends TypeAnnotation, TNotNullableRefType {
-    override predicate isSuffix() { any() }
-
-    override string toString() { result = "!" }
-
-    override int getBit() { result = 2 }
-  }
-
-  /** An annotation indicating that the type is a nullable reference type. */
-  class NullableRefType extends TypeAnnotation, TNullableRefType {
-    override predicate isSuffix() { any() }
-
-    override string toString() { result = "?" }
-
-    override int getBit() { result = 3 }
+    string toString() { none() }
   }
 
   /** An annotation indicating that the type is a readonly reference. */
   class ReadonlyRefType extends TypeAnnotation, TReadonlyRefType {
-    override predicate isPrefix() { any() }
+    override string getPrefix() { result = "readonly " }
 
-    override string toString() { result = "readonly " }
+    override string toString() { result = "readonly ref" }
 
     override int getBit() { result = 4 }
   }
 
   /** An annotation indicating that the variable or return is by `ref`. */
   class RefTypeAnnotation extends TypeAnnotation, TRefType {
-    override predicate isPrefix() { any() }
+    override string getPrefix() { result = "ref " }
 
-    override string toString() { result = "ref " }
+    override string toString() { result = "ref" }
 
     override int getBit() { result = 5 }
   }
 
   /** An annotation indicating that the parameter is `out`. */
   class OutType extends TypeAnnotation, TOutType {
-    override predicate isPrefix() { any() }
+    override string getPrefix() { result = "out " }
 
-    override string toString() { result = "out " }
+    override string toString() { result = "out" }
 
     override int getBit() { result = 6 }
   }
 
-  newtype TAnnotations =
-    TAnnotationFlags(int flags) {
-      flags = getElementTypeFlags(_) or
-      flags = getTypeArgumentFlags(_, _) or
-      flags = getTypeParameterFlags(_, _)
+  /**
+   * A structured type annotation representing type nullability.
+   * For example, `IDictionary<string!,string?>?` has nullability `<!,?>?`.
+   */
+  class Nullability extends TypeAnnotation, TNullability {
+    @nullability nullability;
+
+    Nullability() { this = TNullability(nullability) }
+
+    override string toString() { result = getMemberString() + getSelfNullability() }
+
+    language[monotonicAggregates]
+    private string getMemberString() {
+      if nullability_parent(_, _, nullability)
+      then
+        result = "<" +
+            concat(int i, Nullability child |
+              nullability_parent(getNullability(child), i, nullability)
+            |
+              child.toString(), "," order by i
+            ) + ">"
+      else result = ""
     }
 
-  /** A set of annotations on a type. */
+    /**
+     * Gets a string representing the nullability, disregarding child nullability.
+     * For example, `IDictionary<string!,string?>?` has nullability `?`.
+     */
+    string getSelfNullability() { none() }
+
+    override int getBit() { none() }
+  }
+
+  @nullability getNullability(Nullability n) { n = TNullability(result) }
+
+  private newtype TAnnotations =
+    TAnnotationFlags(int flags, Nullability n) {
+      exists(Element e |
+        flags = getElementTypeFlags(e) and
+        n = getElementNullability(e)
+      )
+    } or
+    TAnnotationsNoFlags(Nullability n)
+
+  /** A collection of type annotations. */
   class TypeAnnotations extends TAnnotations {
-    int flags;
-
-    TypeAnnotations() { this = TAnnotationFlags(flags) }
-
-    /** Gets an annotation in this set of annotations. */
-    TypeAnnotation getAnAnnotation() { isSet(result.getBit()) }
-
-    private predicate isSet(int bit) {
-      isBit(bit) and
-      exists(int mask | mask = getBitMask(bit) | flags.bitAnd(mask) = mask)
+    /** Gets the nullability of this type annotation. */
+    Nullability getNullability() {
+      this = TAnnotationFlags(_, result)
+      or
+      this = TAnnotationsNoFlags(result)
     }
 
     /** Gets text to be displayed before the type. */
     string getTypePrefix() {
       result = concat(TypeAnnotation a |
-          a = this.getAnAnnotation() and a.isPrefix()
+          a = this.getAnAnnotation()
         |
-          a.toString(), "" order by a.getBit()
+          a.getPrefix(), "" order by a.getBit()
         )
     }
 
     /** Gets text to be displayed after the type. */
     string getTypeSuffix() {
       result = concat(TypeAnnotation a |
-          a = this.getAnAnnotation() and a.isSuffix()
+          a = this.getAnAnnotation()
         |
-          a.toString(), "" order by a.getBit()
+          a.getSuffix(), "" order by a.getBit()
         )
     }
 
     /** Gets a textual representation of this type annotation. */
-    string toString() { result = getTypePrefix() + getTypeSuffix() }
+    string toString() { result = getTypePrefix() + getNullability() + getTypeSuffix() }
+
+    private int getFlags() { this = TAnnotationFlags(result, _) }
+
+    private predicate isSet(int bit) {
+      isBit(bit) and
+      exists(int mask | mask = getBitMask(bit) | this.getFlags().bitAnd(mask) = mask)
+    }
+
+    /** Gets an annotation in this set of annotations. */
+    TypeAnnotation getAnAnnotation() {
+      isSet(result.getBit())
+      or
+      result = this.getNullability()
+    }
+  }
+
+  /** Gets the nullability with no additional flags. */
+  Nullability getNoFlagsNullability(TypeAnnotations annotations) {
+    annotations = TAnnotationsNoFlags(result)
+  }
+
+  /**
+   * Gets the `i`th child of type annotations `annotations`.
+   * This is used to represent structured datatypes, where the structure
+   * of the type annotation mirrors the structure of the annotated type.
+   */
+  bindingset[i]
+  TypeAnnotations getChild(TypeAnnotations annotations, int i) {
+    getNoFlagsNullability(result) = getChildNullability(annotations.getNullability(), i)
+  }
+
+  /**
+   * Gets the `i`th child of nullability `n`.
+   * Returns `n` if the nullability is not explicitly
+   * stored in the database, since many type annotations will have consistent
+   * nullability.
+   */
+  bindingset[i]
+  Nullability getChildNullability(Nullability n, int i) {
+    if nullability_parent(_, i, getNullability(n))
+    then nullability_parent(getNullability(result), i, getNullability(n))
+    else result = n
+  }
+
+  /**
+   * A type that is "oblivious", either because nullability is not
+   * applicable, because the code was not compiled in a nullable context, or
+   * because the C# language version is less than 8.
+   */
+  class ObliviousNullability extends Nullability {
+    ObliviousNullability() { nullability instanceof @oblivious }
+
+    override string getSelfNullability() { result = "_" }
+  }
+
+  /**
+   * A type that is "fully" oblivious. The type itself is oblivious
+   * and all type arguments are oblivious.
+   */
+  class NoNullability extends ObliviousNullability {
+    NoNullability() { not nullability_parent(_, _, nullability) }
+  }
+
+  /** A type with annotated nullablity, `?`. */
+  class AnnotatedNullability extends Nullability {
+    AnnotatedNullability() { nullability instanceof @annotated }
+
+    override string getSelfNullability() { result = "?" }
+
+    override int getBit() { result = 3 }
+
+    override string getSuffix() { result = "?" }
+  }
+
+  /**
+   * A ref type not annotated with `?` in a nullable context.
+   */
+  class NotAnnotatedNullability extends Nullability {
+    NotAnnotatedNullability() { nullability instanceof @not_annotated }
+
+    override string getSelfNullability() { result = "!" }
+
+    override int getBit() { result = 2 }
+
+    override string getSuffix() { result = "!" }
   }
 
   /** Holds if the type annotations `annotations` apply to type `type` on element `element`. */
   predicate elementTypeAnnotations(
     @has_type_annotation element, Type type, TypeAnnotations annotations
   ) {
-    annotations = TAnnotationFlags(getElementTypeFlags(element)) and
+    (
+      annotations = TAnnotationFlags(getElementTypeFlags(element), getElementNullability(element))
+      or
+      not exists(getElementTypeFlags(element)) and
+      getNoFlagsNullability(annotations) = getElementNullability(element)
+    ) and
     (
       type = element.(Assignable).getType()
       or
@@ -131,8 +234,6 @@ private module Annotations {
       or
       type = element.(Expr).getType()
       or
-      type = element.(ArrayType).getElementType()
-      or
       type = element.(DelegateType).getReturnType()
     )
   }
@@ -147,32 +248,49 @@ private int getBitMask(int bit) {
 }
 
 private int getElementTypeFlags(@has_type_annotation element) {
-  result = sum(int b | type_annotation(element, b) | b)
+  result = strictsum(int b | type_annotation(element, b) | b)
 }
 
-private int getTypeArgumentFlags(ConstructedGeneric generic, int argument) {
-  exists(generic.getTypeArgument(argument)) and
-  result = sum(int b | type_argument_annotation(generic, argument, b) | b)
+private Annotations::Nullability getTypeParameterNullability(
+  TypeParameterConstraints constraints, Type type
+) {
+  if specific_type_parameter_nullability(constraints, getTypeRef(type), _)
+  then
+    specific_type_parameter_nullability(constraints, getTypeRef(type),
+      Annotations::getNullability(result))
+  else (
+    specific_type_parameter_constraints(constraints, getTypeRef(type)) and
+    result instanceof Annotations::NoNullability
+  )
 }
 
-private int getTypeParameterFlags(TypeParameterConstraints constraints, Type type) {
-  specific_type_parameter_annotation(constraints, getTypeRef(type), _) and
-  result = sum(int b | specific_type_parameter_annotation(constraints, getTypeRef(type), b) | b)
+private Annotations::Nullability getElementNullability(@has_type_annotation element) {
+  if type_nullability(element, _)
+  then type_nullability(element, Annotations::getNullability(result))
+  else result instanceof Annotations::NoNullability
 }
 
 private newtype TAnnotatedType =
   TAnnotatedTypeNullability(Type type, Annotations::TypeAnnotations annotations) {
     Annotations::elementTypeAnnotations(_, type, annotations)
     or
-    exists(ConstructedGeneric c, int i |
-      type = c.getTypeArgument(i) and
-      annotations = Annotations::TAnnotationFlags(getTypeArgumentFlags(c, i))
+    exists(AnnotatedConstructedType c, int i |
+      type = c.getType().(ConstructedType).getTypeArgument(i) and
+      annotations = Annotations::getChild(c.getAnnotations(), i)
     )
     or
-    annotations = Annotations::TAnnotationFlags(getTypeParameterFlags(_, type))
+    Annotations::getNoFlagsNullability(annotations) = getTypeParameterNullability(_, type)
+    or
+    // All types have at least one annotated type
+    Annotations::getNoFlagsNullability(annotations) instanceof Annotations::NoNullability
+    or
+    exists(AnnotatedArrayType at |
+      type = at.getType().(ArrayType).getElementType() and
+      annotations = Annotations::getChild(at.getAnnotations(), 0)
+    )
   }
 
-/** A type with additional information. */
+/** A type with additional type information. */
 class AnnotatedType extends TAnnotatedType {
   Type type;
   Annotations::TypeAnnotations annotations;
@@ -192,7 +310,7 @@ class AnnotatedType extends TAnnotatedType {
    * Gets the unannotated type, for example `string` in `string?`.
    * Note that this might be a nullable value type (`System.Nullable`).
    */
-  final Type getType() { result = type }
+  Type getType() { result = type }
 
   /**
    * Gets the underlying type, for example `string` in `string?`
@@ -206,7 +324,7 @@ class AnnotatedType extends TAnnotatedType {
   }
 
   /** Gets the type annotation set of this annotated type. */
-  private Annotations::TypeAnnotations getAnnotations() { result = annotations }
+  Annotations::TypeAnnotations getAnnotations() { result = annotations }
 
   /** Gets a type annotation of this annotated type. */
   private Annotations::TypeAnnotation getAnAnnotation() {
@@ -214,12 +332,12 @@ class AnnotatedType extends TAnnotatedType {
   }
 
   /** Holds if the type is a non-nullable reference, for example, `string` in a nullable-enabled context. */
-  predicate isNonNullableRefType() {
-    this.getAnAnnotation() instanceof Annotations::NonNullableRefType
-  }
+  predicate isNonNullableRefType() { this.getAnAnnotation() instanceof Annotations::NoNullability }
 
   /** Holds if the type is a nullable reference, for example `string?`. */
-  predicate isNullableRefType() { this.getAnAnnotation() instanceof Annotations::NullableRefType }
+  predicate isNullableRefType() {
+    this.getAnAnnotation() instanceof Annotations::AnnotatedNullability
+  }
 
   /** Holds if the type is a `ref`, for example the return type of `ref int F()`. */
   predicate isRef() { this.getAnAnnotation() instanceof Annotations::RefTypeAnnotation }
@@ -233,14 +351,71 @@ class AnnotatedType extends TAnnotatedType {
   /** Holds if this annotated type applies to element `e`. */
   predicate appliesTo(Element e) { Annotations::elementTypeAnnotations(e, type, annotations) }
 
-  /** Holds if this annotated type applies to type parameter constraints `constraints`. */
-  predicate appliesToTypeConstraint(TypeParameterConstraints constraints) {
-    annotations = Annotations::TAnnotationFlags(getTypeParameterFlags(constraints, type))
+  /** Holds if this annotated type is the `i`th type argument of constructed generic 'g'. */
+  predicate appliesToTypeArgument(ConstructedGeneric g, int i) {
+    Annotations::getNoFlagsNullability(this.getAnnotations()) = Annotations::getChildNullability(getElementNullability(g),
+        i) and
+    this.getType() = g.getTypeArgument(i)
   }
 
-  /** Holds if this annotated type applies to the `i`th type argument of constructed generic `g`. */
-  predicate appliesToTypeArgument(ConstructedGeneric g, int i) {
-    type = g.getTypeArgument(i) and
-    this.getAnnotations() = Annotations::TAnnotationFlags(getTypeArgumentFlags(g, i))
+  /** Holds if this annotated type applies to type parameter constraints `constraints`. */
+  predicate appliesToTypeConstraint(TypeParameterConstraints constraints) {
+    Annotations::getNoFlagsNullability(this.getAnnotations()) = getTypeParameterNullability(constraints,
+        type)
+  }
+}
+
+/** An array type with additional type information. */
+class AnnotatedArrayType extends AnnotatedType {
+  override ArrayType type;
+
+  /** Gets the annotated element type of this array, for example `int?` in `int?[]`. */
+  final AnnotatedType getElementType() {
+    result.getType() = type.getElementType() and
+    result.getAnnotations() = Annotations::getChild(this.getAnnotations(), 0)
+  }
+
+  private string getDimensionString(AnnotatedType elementType) {
+    exists(AnnotatedType et, string res |
+      et = getElementType() and
+      res = type.getArraySuffix() and
+      if et.getUnderlyingType() instanceof ArrayType and not et.isNullableRefType()
+      then result = res + et.(AnnotatedArrayType).getDimensionString(elementType)
+      else (
+        result = res and elementType = et
+      )
+    )
+  }
+
+  override string toString() {
+    exists(AnnotatedType elementType |
+      result = annotations.getTypePrefix() + elementType.toString() +
+          this.getDimensionString(elementType) + annotations.getTypeSuffix()
+    )
+  }
+}
+
+/** A constructed type with additional type information. */
+class AnnotatedConstructedType extends AnnotatedType {
+  override ConstructedType type;
+
+  /** Gets the `i`th type argument of this constructed type. */
+  AnnotatedType getTypeArgument(int i) {
+    result.getType() = type.getTypeArgument(i) and
+    result.getAnnotations() = Annotations::getChild(this.getAnnotations(), i)
+  }
+
+  override string toString() {
+    result = annotations.getTypePrefix() + type.getUnboundGeneric().getNameWithoutBrackets() + "<" +
+        this.getTypeArgumentsString() + ">" + annotations.getTypeSuffix()
+  }
+
+  language[monotonicAggregates]
+  private string getTypeArgumentsString() {
+    result = concat(int i |
+        exists(this.getTypeArgument(i))
+      |
+        this.getTypeArgument(i).toString(), ", " order by i
+      )
   }
 }

csharp/ql/src/semmle/code/csharp/Generics.qll

@@ -370,21 +370,21 @@ class ConstructedType extends ValueOrRefType, ConstructedGeneric {
 
   override UnboundGenericType getUnboundGeneric() { constructed_generic(this, getTypeRef(result)) }
 
-  language[monotonicAggregates]
-  private string annotatedTypeArgumentsToString() {
-    result = concat(int i |
-        exists(this.getAnnotatedTypeArgument(i))
-      |
-        this.getAnnotatedTypeArgument(i).toString(), ", " order by i
-      )
-  }
-
   override string toStringWithTypes() {
-    result = getUnboundGeneric().getNameWithoutBrackets() + "<" +
-        this.annotatedTypeArgumentsToString() + ">"
+    result = getUnboundGeneric().getNameWithoutBrackets() + "<" + this.getTypeArgumentsString() +
+        ">"
   }
 
   final override Type getChild(int n) { result = getTypeArgument(n) }
+
+  language[monotonicAggregates]
+  private string getTypeArgumentsString() {
+    result = concat(int i |
+        exists(this.getTypeArgument(i))
+      |
+        this.getTypeArgument(i).toString(), ", " order by i
+      )
+  }
 }
 
 /**

csharp/ql/src/semmle/code/csharp/Type.qll

@@ -821,9 +821,6 @@ class ArrayType extends DotNet::ArrayType, RefType, @array_type {
   /** Gets the element type of this array, for example `int` in `int[]`. */
   override Type getElementType() { array_element_type(this, _, _, getTypeRef(result)) }
 
-  /** Gets the annotated element type of this array, for example `int?` in `int?[]`. */
-  final AnnotatedType getAnnotatedElementType() { result.appliesTo(this) }
-
   /** Holds if this array type has the same shape (dimension and rank) as `that` array type. */
   predicate hasSameShapeAs(ArrayType that) {
     getDimension() = that.getDimension() and
@@ -835,12 +832,18 @@ class ArrayType extends DotNet::ArrayType, RefType, @array_type {
     if i = getRank() - 1 then result = "" else result = "," + getRankString(i + 1)
   }
 
-  private string getDimensionString(AnnotatedType elementType) {
-    exists(AnnotatedType et, string res |
-      et = getAnnotatedElementType() and
-      res = "[" + getRankString(0) + "]" and
-      if et.getUnderlyingType() instanceof ArrayType and not et.isNullableRefType()
-      then result = res + et.getUnderlyingType().(ArrayType).getDimensionString(elementType)
+  /**
+   * INTERNAL: Do not use.
+   * Gets a string representing the array suffix, for example `[,,,]`.
+   */
+  string getArraySuffix() { result = "[" + getRankString(0) + "]" }
+
+  private string getDimensionString(Type elementType) {
+    exists(Type et, string res |
+      et = this.getElementType() and
+      res = getArraySuffix() and
+      if et instanceof ArrayType
+      then result = res + et.(ArrayType).getDimensionString(elementType)
       else (
         result = res and elementType = et
       )
@@ -848,7 +851,7 @@ class ArrayType extends DotNet::ArrayType, RefType, @array_type {
   }
 
   override string toStringWithTypes() {
-    exists(AnnotatedType elementType |
+    exists(Type elementType |
       result = elementType.toString() + this.getDimensionString(elementType)
     )
   }
@@ -905,7 +908,7 @@ class UnknownType extends Type, @unknown_type { }
  */
 class TupleType extends ValueType, @tuple_type {
   /** Gets the underlying type of this tuple, which is of type `System.ValueTuple`. */
-  ConstructedStruct getUnderlyingType() { tuple_underlying_type(this, result) }
+  ConstructedStruct getUnderlyingType() { tuple_underlying_type(this, getTypeRef(result)) }
 
   /**
    * Gets the `n`th element of this tuple, indexed from 0.

csharp/ql/src/semmlecode.csharp.dbscheme

@@ -157,28 +157,28 @@ compilation_finished(
 
 externalDefects(
   unique int id: @externalDefect,
-  varchar(900) queryPath: string ref,
+  string queryPath: string ref,
   int location: @location ref,
-  varchar(900) message: string ref,
+  string message: string ref,
   float severity: float ref);
 
 externalMetrics(
   unique int id: @externalMetric,
-  varchar(900) queryPath: string ref,
+  string queryPath: string ref,
   int location: @location ref,
   float value: float ref);
 
 externalData(
   int id: @externalDataElement,
-  varchar(900) path: string ref,
+  string path: string ref,
   int column: int ref,
-  varchar(900) value: string ref);
+  string value: string ref);
 
 snapshotDate(
   unique date snapshotDate: date ref);
 
 sourceLocationPrefix(
-  varchar(900) prefix: string ref);
+  string prefix: string ref);
 
 /*
  * Duplicate code
@@ -186,12 +186,12 @@ sourceLocationPrefix(
 
 duplicateCode(
   unique int id: @duplication,
-  varchar(900) relativePath: string ref,
+  string relativePath: string ref,
   int equivClass: int ref);
 
 similarCode(
   unique int id: @similarity,
-  varchar(900) relativePath: string ref,
+  string relativePath: string ref,
   int equivClass: int ref);
 
 @duplication_or_similarity = @duplication | @similarity
@@ -244,7 +244,7 @@ locations_default(
 @sourceline = @file | @callable | @xmllocatable;
 
 numlines(
-  unique int element_id: @sourceline ref,
+  int element_id: @sourceline ref,
   int num_lines: int ref,
   int num_code: int ref,
   int num_comment: int ref);
@@ -252,9 +252,9 @@ numlines(
 assemblies(
   unique int id: @assembly,
   int file: @file ref,
-  varchar(900) fullname: string ref,
-  varchar(900) name: string ref,
-  varchar(900) version: string ref);
+  string fullname: string ref,
+  string name: string ref,
+  string version: string ref);
 
 /*
   fromSource(0) = unknown,
@@ -263,15 +263,15 @@ assemblies(
 */
 files(
   unique int id: @file,
-  varchar(900) name: string ref,
-  varchar(900) simple: string ref,
-  varchar(900) ext: string ref,
+  string name: string ref,
+  string simple: string ref,
+  string ext: string ref,
   int fromSource: int ref);
 
 folders(
   unique int id: @folder,
-  varchar(900) name: string ref,
-  varchar(900) simple: string ref);
+  string name: string ref,
+  string simple: string ref);
 
 @container = @folder | @file ;
 
@@ -291,7 +291,7 @@ file_extraction_mode(
 
 namespaces(
   unique int id: @namespace,
-  varchar(900) name: string ref);
+  string name: string ref);
 
 namespace_declarations(
   unique int id: @namespace_declaration,
@@ -330,7 +330,7 @@ using_directive_location(
 types(
   unique int id: @type,
   int kind: int ref,
-  varchar(900) name: string ref);
+  string name: string ref);
 
 case @type.kind of
    1 = @bool_type
@@ -378,10 +378,10 @@ case @type.kind of
 
 typerefs(
   unique int id: @typeref,
-  varchar(900) name: string ref);
+  string name: string ref);
 
 typeref_type(
-  unique int id: @typeref ref,
+  int id: @typeref ref,
   unique int typeId: @type ref);
 
 @type_or_ref = @type | @typeref;
@@ -424,7 +424,7 @@ type_location(
 
 tuple_underlying_type(
   unique int tuple: @tuple_type ref,
-  int struct: @struct_type ref);
+  int struct: @type_or_ref ref);
 
 #keyset[tuple, index]
 tuple_element(
@@ -452,7 +452,7 @@ type_mention_location(
   unique int id: @type_mention ref,
   int loc: @location ref);
 
-@has_type_annotation = @assignable | @type_parameter | @callable | @array_type | @expr | @delegate_type;
+@has_type_annotation = @assignable | @type_parameter | @callable | @expr | @delegate_type | @generic;
 
 /**
  * A direct annotation on an entity, for example `string? x;`.
@@ -472,8 +472,18 @@ type_mention_location(
  */
 type_annotation(int id: @has_type_annotation ref, int annotation: int ref);
 
-/** The annotation of type arguments of a constructed type or method. */ 
-type_argument_annotation(int constructedgeneric: @generic ref, int position: int ref, int annotation: int ref);
+nullability(unique int nullability: @nullability, int kind: int ref);
+
+case @nullability.kind of
+  0 = @oblivious
+| 1 = @not_annotated
+| 2 = @annotated
+;
+
+#keyset[parent, index]
+nullability_parent(int nullability: @nullability ref, int index: int ref, int parent: @nullability ref)
+
+type_nullability(int id: @has_type_annotation ref, int nullability: @nullability ref)
 
 /** GENERICS **/
 
@@ -517,10 +527,10 @@ specific_type_parameter_constraints(
   int id: @type_parameter_constraints ref,
   int base_id: @type_or_ref ref);
 
-specific_type_parameter_annotation(
+specific_type_parameter_nullability(
   int id: @type_parameter_constraints ref,
   int base_id: @type_or_ref ref,
-  int annotation: int ref);
+  int nullability: @nullability ref);
 
 /** MODIFIERS */
 
@@ -530,7 +540,7 @@ specific_type_parameter_annotation(
 
 modifiers(
   unique int id: @modifier,
-  varchar(900) name: string ref);
+  string name: string ref);
 
 has_modifiers(
   int id: @modifiable_direct ref,
@@ -548,7 +558,7 @@ compiler_generated(unique int id: @modifiable_direct ref);
 
 exprorstmt_name(
   unique int parent_id: @named_exprorstmt ref,
-  varchar(900) name: string ref);
+  string name: string ref);
 
 nested_types(
   unique int id: @type ref,
@@ -557,7 +567,7 @@ nested_types(
 
 properties(
   unique int id: @property,
-  varchar(900) name: string ref,
+  string name: string ref,
   int declaring_type_id: @type ref,
   int type_id: @type_or_ref ref,
   int unbound_id: @property ref);
@@ -568,7 +578,7 @@ property_location(
 
 indexers(
   unique int id: @indexer,
-  varchar(900) name: string ref,
+  string name: string ref,
   int declaring_type_id: @type ref,
   int type_id: @type_or_ref ref,
   int unbound_id: @indexer ref);
@@ -580,7 +590,7 @@ indexer_location(
 accessors(
   unique int id: @accessor,
   int kind: int ref,
-  varchar(900) name: string ref,
+  string name: string ref,
   int declaring_member_id: @member ref,
   int unbound_id: @accessor ref);
 
@@ -595,7 +605,7 @@ accessor_location(
 
 events(
   unique int id: @event,
-  varchar(900) name: string ref,
+  string name: string ref,
   int declaring_type_id: @type ref,
   int type_id: @type_or_ref ref,
   int unbound_id: @event ref);
@@ -607,7 +617,7 @@ event_location(
 event_accessors(
   unique int id: @event_accessor,
   int kind: int ref,
-  varchar(900) name: string ref,
+  string name: string ref,
   int declaring_event_id: @event ref,
   int unbound_id: @event_accessor ref);
 
@@ -622,8 +632,8 @@ event_accessor_location(
 
 operators(
   unique int id: @operator,
-  varchar(900) name: string ref,
-  varchar(900) symbol: string ref,
+  string name: string ref,
+  string symbol: string ref,
   int declaring_type_id: @type ref,
   int type_id: @type_or_ref ref,
   int unbound_id: @operator ref);
@@ -633,8 +643,8 @@ operator_location(
   int loc: @location ref);
 
 constant_value(
-  unique int id: @variable ref,
-  varchar(900) value: string ref);
+  int id: @variable ref,
+  string value: string ref);
 
 /** CALLABLES **/
 
@@ -644,7 +654,7 @@ constant_value(
 
 methods(
   unique int id: @method,
-  varchar(900) name: string ref,
+  string name: string ref,
   int declaring_type_id: @type ref,
   int type_id: @type_or_ref ref,
   int unbound_id: @method ref);
@@ -655,7 +665,7 @@ method_location(
 
 constructors(
   unique int id: @constructor,
-  varchar(900) name: string ref,
+  string name: string ref,
   int declaring_type_id: @type ref,
   int unbound_id: @constructor ref);
 
@@ -665,7 +675,7 @@ constructor_location(
 
 destructors(
   unique int id: @destructor,
-  varchar(900) name: string ref,
+  string name: string ref,
   int declaring_type_id: @type ref,
   int unbound_id: @destructor ref);
 
@@ -674,7 +684,7 @@ destructor_location(
   int loc: @location ref);
 
 overrides(
-  unique int id: @callable ref,
+  int id: @callable ref,
   int base_id: @callable ref);
 
 explicitly_implements(
@@ -683,7 +693,7 @@ explicitly_implements(
 
 local_functions(
     unique int id: @local_function,
-    varchar(900) name: string ref,
+    string name: string ref,
     int return_type: @type ref,
     int unbound_id: @local_function ref);
 
@@ -700,7 +710,7 @@ local_function_stmts(
 fields(
   unique int id: @field,
   int kind: int ref,
-  varchar(900) name: string ref,
+  string name: string ref,
   int declaring_type_id: @type ref,
   int type_id: @type_or_ref ref,
   int unbound_id: @field ref);
@@ -717,7 +727,7 @@ field_location(
 localvars(
   unique int id: @local_variable,
   int kind: int ref,
-  varchar(900) name: string ref,
+  string name: string ref,
   int implicitly_typed: int ref /* 0 = no, 1 = yes */,
   int type_id: @type_or_ref ref,
   int parent_id: @local_var_decl_expr ref);
@@ -738,7 +748,7 @@ localvar_location(
 #keyset[index, parent_id]
 params(
   unique int id: @parameter,
-  varchar(900) name: string ref,
+  string name: string ref,
   int type_id: @type_or_ref ref,
   int index: int ref,
   int mode: int ref, /* value = 0, ref = 1, out = 2, array = 3, this = 4 */
@@ -1075,7 +1085,7 @@ expr_compiler_generated(
 
 expr_value(
   unique int id: @expr ref,
-  varchar(900) value: string ref);
+  string value: string ref);
 
 expr_call(
   unique int caller_id: @expr ref,
@@ -1093,7 +1103,7 @@ expr_location(
 
 dynamic_member_name(
   unique int id: @late_bindable_expr ref,
-  varchar(900) name: string ref);
+  string name: string ref);
 
 @qualifiable_expr = @member_access_expr
                   | @method_invocation_expr
@@ -1109,7 +1119,7 @@ expr_argument(
 
 expr_argument_name(
   unique int id: @expr ref,
-  varchar(900) name: string ref);
+  string name: string ref);
 
 /** CONTROL/DATA FLOW **/
 
@@ -1119,18 +1129,18 @@ expr_argument_name(
 
 xmlEncoding  (
   unique int id: @file ref,
-  varchar(900) encoding: string ref);
+  string encoding: string ref);
 
 xmlDTDs(
   unique int id: @xmldtd,
-  varchar(900) root: string ref,
-  varchar(900) publicId: string ref,
-  varchar(900) systemId: string ref,
+  string root: string ref,
+  string publicId: string ref,
+  string systemId: string ref,
   int fileid: @file ref);
 
 xmlElements(
   unique int id: @xmlelement,
-  varchar(900) name: string ref,
+  string name: string ref,
   int parentid: @xmlparent ref,
   int idx: int ref,
   int fileid: @file ref);
@@ -1138,15 +1148,15 @@ xmlElements(
 xmlAttrs(
   unique int id: @xmlattribute,
   int elementid: @xmlelement ref,
-  varchar(900) name: string ref,
-  varchar(3600) value: string ref,
+  string name: string ref,
+  string value: string ref,
   int idx: int ref,
   int fileid: @file ref);
 
 xmlNs(
   int id: @xmlnamespace,
-  varchar(900) prefixName: string ref,
-  varchar(900) URI: string ref,
+  string prefixName: string ref,
+  string URI: string ref,
   int fileid: @file ref);
 
 xmlHasNs(
@@ -1156,13 +1166,13 @@ xmlHasNs(
 
 xmlComments(
   unique int id: @xmlcomment,
-  varchar(3600) text: string ref,
+  string text: string ref,
   int parentid: @xmlparent ref,
   int fileid: @file ref);
 
 xmlChars(
   unique int id: @xmlcharacters,
-  varchar(3600) text: string ref,
+  string text: string ref,
   int parentid: @xmlparent ref,
   int idx: int ref,
   int isCDATA: int ref,
@@ -1182,8 +1192,8 @@ xmllocations(
 commentline(
   unique int id: @commentline,
   int kind: int ref,
-  varchar(800) text: string ref,
-  varchar(800) rawtext: string ref);
+  string text: string ref,
+  string rawtext: string ref);
 
 case @commentline.kind of
   0 = @singlelinecomment
@@ -1236,22 +1246,22 @@ asp_code_inline(unique int code: @asp_code ref);
 asp_directive_attribute(
   int directive: @asp_directive ref,
   int index: int ref,
-  varchar(1000) name: string ref,
+  string name: string ref,
   int value: @asp_quoted_string ref);
 asp_directive_name(
   unique int directive: @asp_directive ref,
-  varchar(1000) name: string ref);
+  string name: string ref);
 asp_element_body(
   unique int element: @asp_element ref,
-  varchar(1000) body: string ref);
+  string body: string ref);
 asp_tag_attribute(
   int tag: @asp_open_tag ref,
   int index: int ref,
-  varchar(1000) name: string ref,
+  string name: string ref,
   int attribute: @asp_attribute ref);
 asp_tag_name(
   unique int tag: @asp_open_tag ref,
-  varchar(1000) name: string ref);
+  string name: string ref);
 asp_tag_isempty(int tag: @asp_open_tag ref);
 
 /* Common Intermediate Language - CIL */
@@ -1606,7 +1616,7 @@ cil_access(
 
 cil_value(
   unique int instruction: @cil_literal ref,
-  varchar(900) value: string ref);
+  string value: string ref);
 
 #keyset[instruction, index]
 cil_switch(
@@ -1639,7 +1649,7 @@ case @cil_type.kind of
 
 cil_type(
   unique int id: @cil_type,
-  varchar(900) name: string ref,
+  string name: string ref,
   int kind: int ref,
   int parent: @cil_type_container ref,
   int sourceDecl: @cil_type ref);
@@ -1655,7 +1665,7 @@ cil_array_type(
 
 cil_method(
   unique int id: @cil_method,
-  varchar(900) name: string ref,
+  string name: string ref,
   int parent: @cil_type ref,
   int return_type: @cil_type ref);
 
@@ -1676,7 +1686,7 @@ cil_implements(
 cil_field(
   unique int id: @cil_field,
   int parent: @cil_type ref,
-  varchar(900) name: string ref,
+  string name: string ref,
   int field_type: @cil_type ref);
 
 @cil_element = @cil_instruction | @cil_declaration | @cil_handler | @cil_attribute | @cil_namespace;
@@ -1713,13 +1723,13 @@ cil_raiser(unique int event: @cil_event ref, int method: @cil_method ref);
 cil_property(
   unique int id: @cil_property,
   int parent: @cil_type ref,
-  varchar(900) name: string ref,
+  string name: string ref,
   int property_type: @cil_type ref);
 
 #keyset[parent, name]
 cil_event(unique int id: @cil_event,
   int parent: @cil_type ref,
-  varchar(900) name: string ref,
+  string name: string ref,
   int event_type: @cil_type ref);
 
 #keyset[impl, index]
@@ -1817,14 +1827,14 @@ cil_attribute(
 #keyset[attribute_id, param]
 cil_attribute_named_argument(
   int attribute_id: @cil_attribute ref,
-  varchar(100) param: string ref,
-  varchar(900) value: string ref);
+  string param: string ref,
+  string value: string ref);
 
 #keyset[attribute_id, index]
 cil_attribute_positional_argument(
   int attribute_id: @cil_attribute ref,
   int index: int ref,
-  varchar(900) value: string ref);
+  string value: string ref);
 
 
 // Common .Net data model covering both C# and CIL

csharp/ql/test/library-tests/csharp7/LocalVariables.expected

@@ -33,8 +33,8 @@
 | CSharp7.cs:119:13:119:15 | m11 | int |
 | CSharp7.cs:122:16:122:18 | m12 | string |
 | CSharp7.cs:123:16:123:18 | m13 | string |
-| CSharp7.cs:135:19:135:20 | f4 | Func<int> |
-| CSharp7.cs:139:24:139:25 | f5 | Func<int, int> |
+| CSharp7.cs:135:19:135:20 | f4 | Func<Int32> |
+| CSharp7.cs:139:24:139:25 | f5 | Func<Int32, Int32> |
 | CSharp7.cs:151:16:151:16 | a | Action |
 | CSharp7.cs:176:16:176:18 | src | string |
 | CSharp7.cs:181:13:181:17 | sink1 | string |
@@ -42,7 +42,7 @@
 | CSharp7.cs:183:13:183:17 | sink3 | string |
 | CSharp7.cs:191:13:191:14 | v1 | int |
 | CSharp7.cs:192:17:192:18 | r1 | int |
-| CSharp7.cs:193:13:193:17 | array | int[] |
+| CSharp7.cs:193:13:193:17 | array | Int32[] |
 | CSharp7.cs:196:17:196:18 | r2 | int |
 | CSharp7.cs:197:17:197:18 | r3 | int |
 | CSharp7.cs:199:17:199:18 | r4 | int |
@@ -58,8 +58,8 @@
 | CSharp7.cs:261:22:261:23 | i3 | int |
 | CSharp7.cs:264:25:264:26 | s2 | string |
 | CSharp7.cs:270:22:270:23 | v2 | object |
-| CSharp7.cs:283:13:283:16 | dict | Dictionary<int, string> |
-| CSharp7.cs:284:13:284:16 | list | IEnumerable<(int, string)> |
+| CSharp7.cs:283:13:283:16 | dict | Dictionary<Int32, String> |
+| CSharp7.cs:284:13:284:16 | list | IEnumerable<(Int32,String)> |
 | CSharp7.cs:286:23:286:23 | a | int |
 | CSharp7.cs:286:33:286:33 | b | string |
 | CSharp7.cs:288:23:288:23 | a | int |

csharp/ql/test/library-tests/csharp7/TupleTypes.expected

@@ -1,49 +1,49 @@
-| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<int, (int, int)> | 2 | 0 | CSharp7.cs:77:10:77:14 | a |
-| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<int, (int, int)> | 2 | 0 | CSharp7.cs:77:36:77:36 | Item1 |
-| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<int, (int, int)> | 2 | 0 | CSharp7.cs:78:24:78:24 | b |
-| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<int, (int, int)> | 2 | 1 | CSharp7.cs:77:17:77:30 | Item2 |
-| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<int, (int, int)> | 2 | 1 | CSharp7.cs:77:39:77:39 | z |
-| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<int, (int, int)> | 2 | 1 | CSharp7.cs:78:27:78:32 | Item2 |
-| (Int32,(String,Int32)) | (int, (string, int)) | ValueTuple<int, (string, int)> | 2 | 0 | CSharp7.cs:98:19:98:19 | Item1 |
-| (Int32,(String,Int32)) | (int, (string, int)) | ValueTuple<int, (string, int)> | 2 | 1 | CSharp7.cs:98:22:98:42 | Item2 |
-| (Int32,Double) | (int, double) | ValueTuple<int, double> | 2 | 0 | CSharp7.cs:214:6:214:8 | Item1 |
-| (Int32,Double) | (int, double) | ValueTuple<int, double> | 2 | 0 | CSharp7.cs:224:10:224:14 | x |
-| (Int32,Double) | (int, double) | ValueTuple<int, double> | 2 | 0 | CSharp7.cs:225:10:225:10 | Item1 |
-| (Int32,Double) | (int, double) | ValueTuple<int, double> | 2 | 1 | CSharp7.cs:214:11:214:16 | Item2 |
-| (Int32,Double) | (int, double) | ValueTuple<int, double> | 2 | 1 | CSharp7.cs:224:17:224:17 | Item2 |
-| (Int32,Double) | (int, double) | ValueTuple<int, double> | 2 | 1 | CSharp7.cs:225:13:225:17 | y |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 0 | CSharp7.cs:64:6:64:8 | Item1 |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 0 | CSharp7.cs:71:10:71:14 | x |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 0 | CSharp7.cs:77:18:77:22 | b |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 0 | CSharp7.cs:78:28:78:28 | c |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 0 | CSharp7.cs:112:15:112:16 | m4 |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 0 | CSharp7.cs:114:19:114:24 | m8 |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 1 | CSharp7.cs:64:11:64:13 | Item2 |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 1 | CSharp7.cs:71:17:71:21 | y |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 1 | CSharp7.cs:77:25:77:29 | c |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 1 | CSharp7.cs:78:31:78:31 | a |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 1 | CSharp7.cs:112:19:112:20 | m5 |
-| (Int32,Int32) | (int, int) | ValueTuple<int, int> | 2 | 1 | CSharp7.cs:114:27:114:32 | m9 |
-| (Int32,Int32,Int32) | (int, int, int) | ValueTuple<int, int, int> | 3 | 0 | CSharp7.cs:75:10:75:10 | x |
-| (Int32,Int32,Int32) | (int, int, int) | ValueTuple<int, int, int> | 3 | 1 | CSharp7.cs:75:13:75:13 | y |
-| (Int32,Int32,Int32) | (int, int, int) | ValueTuple<int, int, int> | 3 | 2 | CSharp7.cs:75:16:75:22 | Item3 |
-| (Int32,String) | (int, string) | ValueTuple<int, string> | 2 | 0 | CSharp7.cs:284:41:284:48 | Key |
-| (Int32,String) | (int, string) | ValueTuple<int, string> | 2 | 0 | CSharp7.cs:286:19:286:23 | a |
-| (Int32,String) | (int, string) | ValueTuple<int, string> | 2 | 1 | CSharp7.cs:284:51:284:60 | Value |
-| (Int32,String) | (int, string) | ValueTuple<int, string> | 2 | 1 | CSharp7.cs:286:26:286:33 | b |
-| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<string, (int, int)> | 2 | 0 | CSharp7.cs:109:10:109:15 | m1 |
-| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<string, (int, int)> | 2 | 0 | CSharp7.cs:112:10:112:11 | m3 |
-| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<string, (int, int)> | 2 | 0 | CSharp7.cs:114:10:114:15 | m7 |
-| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<string, (int, int)> | 2 | 1 | CSharp7.cs:109:18:109:23 | m2 |
-| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<string, (int, int)> | 2 | 1 | CSharp7.cs:112:14:112:21 | Item2 |
-| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<string, (int, int)> | 2 | 1 | CSharp7.cs:114:18:114:33 | Item2 |
-| (String,Int32) | (string, int) | ValueTuple<string, int> | 2 | 0 | CSharp7.cs:79:14:79:14 | i |
-| (String,Int32) | (string, int) | ValueTuple<string, int> | 2 | 0 | CSharp7.cs:79:23:79:24 | Item1 |
-| (String,Int32) | (string, int) | ValueTuple<string, int> | 2 | 0 | CSharp7.cs:84:17:84:17 | a |
-| (String,Int32) | (string, int) | ValueTuple<string, int> | 2 | 1 | CSharp7.cs:79:17:79:17 | j |
-| (String,Int32) | (string, int) | ValueTuple<string, int> | 2 | 1 | CSharp7.cs:79:27:79:27 | x |
-| (String,Int32) | (string, int) | ValueTuple<string, int> | 2 | 1 | CSharp7.cs:84:23:84:23 | Item2 |
-| (String,String) | (string, string) | ValueTuple<string, string> | 2 | 0 | CSharp7.cs:89:19:89:27 | Item1 |
-| (String,String) | (string, string) | ValueTuple<string, string> | 2 | 0 | CSharp7.cs:90:10:90:15 | t2 |
-| (String,String) | (string, string) | ValueTuple<string, string> | 2 | 1 | CSharp7.cs:89:30:89:33 | Item2 |
-| (String,String) | (string, string) | ValueTuple<string, string> | 2 | 1 | CSharp7.cs:90:18:90:23 | t3 |
+| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<Int32, (Int32,Int32)> | 2 | 0 | CSharp7.cs:77:10:77:14 | a |
+| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<Int32, (Int32,Int32)> | 2 | 0 | CSharp7.cs:77:36:77:36 | Item1 |
+| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<Int32, (Int32,Int32)> | 2 | 0 | CSharp7.cs:78:24:78:24 | b |
+| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<Int32, (Int32,Int32)> | 2 | 1 | CSharp7.cs:77:17:77:30 | Item2 |
+| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<Int32, (Int32,Int32)> | 2 | 1 | CSharp7.cs:77:39:77:39 | z |
+| (Int32,(Int32,Int32)) | (int, (int, int)) | ValueTuple<Int32, (Int32,Int32)> | 2 | 1 | CSharp7.cs:78:27:78:32 | Item2 |
+| (Int32,(String,Int32)) | (int, (string, int)) | ValueTuple<Int32, (String,Int32)> | 2 | 0 | CSharp7.cs:98:19:98:19 | Item1 |
+| (Int32,(String,Int32)) | (int, (string, int)) | ValueTuple<Int32, (String,Int32)> | 2 | 1 | CSharp7.cs:98:22:98:42 | Item2 |
+| (Int32,Double) | (int, double) | ValueTuple<Int32, Double> | 2 | 0 | CSharp7.cs:214:6:214:8 | Item1 |
+| (Int32,Double) | (int, double) | ValueTuple<Int32, Double> | 2 | 0 | CSharp7.cs:224:10:224:14 | x |
+| (Int32,Double) | (int, double) | ValueTuple<Int32, Double> | 2 | 0 | CSharp7.cs:225:10:225:10 | Item1 |
+| (Int32,Double) | (int, double) | ValueTuple<Int32, Double> | 2 | 1 | CSharp7.cs:214:11:214:16 | Item2 |
+| (Int32,Double) | (int, double) | ValueTuple<Int32, Double> | 2 | 1 | CSharp7.cs:224:17:224:17 | Item2 |
+| (Int32,Double) | (int, double) | ValueTuple<Int32, Double> | 2 | 1 | CSharp7.cs:225:13:225:17 | y |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 0 | CSharp7.cs:64:6:64:8 | Item1 |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 0 | CSharp7.cs:71:10:71:14 | x |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 0 | CSharp7.cs:77:18:77:22 | b |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 0 | CSharp7.cs:78:28:78:28 | c |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 0 | CSharp7.cs:112:15:112:16 | m4 |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 0 | CSharp7.cs:114:19:114:24 | m8 |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 1 | CSharp7.cs:64:11:64:13 | Item2 |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 1 | CSharp7.cs:71:17:71:21 | y |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 1 | CSharp7.cs:77:25:77:29 | c |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 1 | CSharp7.cs:78:31:78:31 | a |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 1 | CSharp7.cs:112:19:112:20 | m5 |
+| (Int32,Int32) | (int, int) | ValueTuple<Int32, Int32> | 2 | 1 | CSharp7.cs:114:27:114:32 | m9 |
+| (Int32,Int32,Int32) | (int, int, int) | ValueTuple<Int32, Int32, Int32> | 3 | 0 | CSharp7.cs:75:10:75:10 | x |
+| (Int32,Int32,Int32) | (int, int, int) | ValueTuple<Int32, Int32, Int32> | 3 | 1 | CSharp7.cs:75:13:75:13 | y |
+| (Int32,Int32,Int32) | (int, int, int) | ValueTuple<Int32, Int32, Int32> | 3 | 2 | CSharp7.cs:75:16:75:22 | Item3 |
+| (Int32,String) | (int, string) | ValueTuple<Int32, String> | 2 | 0 | CSharp7.cs:284:41:284:48 | Key |
+| (Int32,String) | (int, string) | ValueTuple<Int32, String> | 2 | 0 | CSharp7.cs:286:19:286:23 | a |
+| (Int32,String) | (int, string) | ValueTuple<Int32, String> | 2 | 1 | CSharp7.cs:284:51:284:60 | Value |
+| (Int32,String) | (int, string) | ValueTuple<Int32, String> | 2 | 1 | CSharp7.cs:286:26:286:33 | b |
+| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<String, (Int32,Int32)> | 2 | 0 | CSharp7.cs:109:10:109:15 | m1 |
+| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<String, (Int32,Int32)> | 2 | 0 | CSharp7.cs:112:10:112:11 | m3 |
+| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<String, (Int32,Int32)> | 2 | 0 | CSharp7.cs:114:10:114:15 | m7 |
+| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<String, (Int32,Int32)> | 2 | 1 | CSharp7.cs:109:18:109:23 | m2 |
+| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<String, (Int32,Int32)> | 2 | 1 | CSharp7.cs:112:14:112:21 | Item2 |
+| (String,(Int32,Int32)) | (string, (int, int)) | ValueTuple<String, (Int32,Int32)> | 2 | 1 | CSharp7.cs:114:18:114:33 | Item2 |
+| (String,Int32) | (string, int) | ValueTuple<String, Int32> | 2 | 0 | CSharp7.cs:79:14:79:14 | i |
+| (String,Int32) | (string, int) | ValueTuple<String, Int32> | 2 | 0 | CSharp7.cs:79:23:79:24 | Item1 |
+| (String,Int32) | (string, int) | ValueTuple<String, Int32> | 2 | 0 | CSharp7.cs:84:17:84:17 | a |
+| (String,Int32) | (string, int) | ValueTuple<String, Int32> | 2 | 1 | CSharp7.cs:79:17:79:17 | j |
+| (String,Int32) | (string, int) | ValueTuple<String, Int32> | 2 | 1 | CSharp7.cs:79:27:79:27 | x |
+| (String,Int32) | (string, int) | ValueTuple<String, Int32> | 2 | 1 | CSharp7.cs:84:23:84:23 | Item2 |
+| (String,String) | (string, string) | ValueTuple<String, String> | 2 | 0 | CSharp7.cs:89:19:89:27 | Item1 |
+| (String,String) | (string, string) | ValueTuple<String, String> | 2 | 0 | CSharp7.cs:90:10:90:15 | t2 |
+| (String,String) | (string, string) | ValueTuple<String, String> | 2 | 1 | CSharp7.cs:89:30:89:33 | Item2 |
+| (String,String) | (string, string) | ValueTuple<String, String> | 2 | 1 | CSharp7.cs:90:18:90:23 | t3 |

csharp/ql/test/library-tests/csharp8/NullCoalescingAssignment.expected

@@ -1,5 +1,5 @@
 nullcoalescing
 | NullCoalescingAssignment.cs:8:9:8:18 | ... ?? ... |
-| NullableRefTypes.cs:88:17:88:25 | ... ?? ... |
+| NullableRefTypes.cs:94:17:94:25 | ... ?? ... |
 assignments
 | NullCoalescingAssignment.cs:8:9:8:18 | ... ??= ... | NullCoalescingAssignment.cs:8:9:8:18 | ... = ... |

csharp/ql/test/library-tests/csharp8/NullableRefTypes.cs

@@ -55,6 +55,12 @@ class MyClass
     {
     }
 
+    class Generic2<T1, T2>
+        where T1: MyClass
+        where T2: Generic<string?, T1?, IEnumerable<string?>, MyClass>
+    {
+    }
+
     // Nullable type arguments
     Generic<MyClass?, MyClass, IDisposable, MyClass> items2;
     

csharp/ql/test/library-tests/csharp8/NullableRefTypes.expected

@@ -1,150 +1,150 @@
 suppressNullableWarnings
-| NullableRefTypes.cs:79:20:79:21 | ...! | NullableRefTypes.cs:79:20:79:20 | access to local variable x |
-| NullableRefTypes.cs:80:13:80:14 | ...! | NullableRefTypes.cs:80:13:80:13 | access to local variable x |
-| NullableRefTypes.cs:80:13:80:15 | ...! | NullableRefTypes.cs:80:13:80:14 | ...! |
-| NullableRefTypes.cs:82:13:82:14 | ...! | NullableRefTypes.cs:82:13:82:13 | access to local variable x |
-| NullableRefTypes.cs:107:36:107:44 | ...! | NullableRefTypes.cs:107:36:107:43 | access to field Property |
+| NullableRefTypes.cs:85:20:85:21 | ...! | NullableRefTypes.cs:85:20:85:20 | access to local variable x |
+| NullableRefTypes.cs:86:13:86:14 | ...! | NullableRefTypes.cs:86:13:86:13 | access to local variable x |
+| NullableRefTypes.cs:86:13:86:15 | ...! | NullableRefTypes.cs:86:13:86:14 | ...! |
+| NullableRefTypes.cs:88:13:88:14 | ...! | NullableRefTypes.cs:88:13:88:13 | access to local variable x |
+| NullableRefTypes.cs:113:36:113:44 | ...! | NullableRefTypes.cs:113:36:113:43 | access to field Property |
 nullableDataFlow
-| NullableRefTypes.cs:78:17:78:28 | SSA def(x) | NullableRefTypes.cs:79:20:79:20 | access to local variable x |
-| NullableRefTypes.cs:78:21:78:28 | "source" | NullableRefTypes.cs:78:17:78:28 | SSA def(x) |
-| NullableRefTypes.cs:79:20:79:20 | access to local variable x | NullableRefTypes.cs:79:20:79:21 | ...! |
-| NullableRefTypes.cs:79:20:79:20 | access to local variable x | NullableRefTypes.cs:80:13:80:13 | access to local variable x |
-| NullableRefTypes.cs:80:13:80:13 | access to local variable x | NullableRefTypes.cs:80:13:80:14 | ...! |
-| NullableRefTypes.cs:80:13:80:14 | ...! | NullableRefTypes.cs:80:13:80:15 | ...! |
-| NullableRefTypes.cs:81:9:81:16 | SSA def(x) | NullableRefTypes.cs:82:13:82:13 | access to local variable x |
-| NullableRefTypes.cs:81:13:81:16 | null | NullableRefTypes.cs:81:9:81:16 | SSA def(x) |
-| NullableRefTypes.cs:82:13:82:13 | access to local variable x | NullableRefTypes.cs:82:13:82:14 | ...! |
+| NullableRefTypes.cs:84:17:84:28 | SSA def(x) | NullableRefTypes.cs:85:20:85:20 | access to local variable x |
+| NullableRefTypes.cs:84:21:84:28 | "source" | NullableRefTypes.cs:84:17:84:28 | SSA def(x) |
+| NullableRefTypes.cs:85:20:85:20 | access to local variable x | NullableRefTypes.cs:85:20:85:21 | ...! |
+| NullableRefTypes.cs:85:20:85:20 | access to local variable x | NullableRefTypes.cs:86:13:86:13 | access to local variable x |
+| NullableRefTypes.cs:86:13:86:13 | access to local variable x | NullableRefTypes.cs:86:13:86:14 | ...! |
+| NullableRefTypes.cs:86:13:86:14 | ...! | NullableRefTypes.cs:86:13:86:15 | ...! |
+| NullableRefTypes.cs:87:9:87:16 | SSA def(x) | NullableRefTypes.cs:88:13:88:13 | access to local variable x |
+| NullableRefTypes.cs:87:13:87:16 | null | NullableRefTypes.cs:87:9:87:16 | SSA def(x) |
+| NullableRefTypes.cs:88:13:88:13 | access to local variable x | NullableRefTypes.cs:88:13:88:14 | ...! |
 nullableControlFlow
-| NullableRefTypes.cs:76:10:76:40 | enter TestSuppressNullableWarningExpr | NullableRefTypes.cs:77:5:83:5 | {...} | successor |
-| NullableRefTypes.cs:77:5:83:5 | {...} | NullableRefTypes.cs:78:9:78:29 | ... ...; | successor |
-| NullableRefTypes.cs:78:9:78:29 | ... ...; | NullableRefTypes.cs:78:21:78:28 | "source" | successor |
-| NullableRefTypes.cs:78:17:78:28 | String x = ... | NullableRefTypes.cs:79:9:79:22 | ... ...; | successor |
-| NullableRefTypes.cs:78:21:78:28 | "source" | NullableRefTypes.cs:78:17:78:28 | String x = ... | successor |
-| NullableRefTypes.cs:79:9:79:22 | ... ...; | NullableRefTypes.cs:79:20:79:20 | access to local variable x | successor |
-| NullableRefTypes.cs:79:16:79:21 | String y = ... | NullableRefTypes.cs:80:9:80:16 | ...; | successor |
-| NullableRefTypes.cs:79:20:79:20 | access to local variable x | NullableRefTypes.cs:79:20:79:21 | ...! | successor |
-| NullableRefTypes.cs:79:20:79:21 | ...! | NullableRefTypes.cs:79:16:79:21 | String y = ... | successor |
-| NullableRefTypes.cs:80:9:80:15 | ... = ... | NullableRefTypes.cs:81:9:81:17 | ...; | successor |
-| NullableRefTypes.cs:80:9:80:16 | ...; | NullableRefTypes.cs:80:13:80:13 | access to local variable x | successor |
-| NullableRefTypes.cs:80:13:80:13 | access to local variable x | NullableRefTypes.cs:80:13:80:14 | ...! | successor |
-| NullableRefTypes.cs:80:13:80:14 | ...! | NullableRefTypes.cs:80:13:80:15 | ...! | successor |
-| NullableRefTypes.cs:80:13:80:15 | ...! | NullableRefTypes.cs:80:9:80:15 | ... = ... | successor |
-| NullableRefTypes.cs:81:9:81:16 | ... = ... | NullableRefTypes.cs:82:9:82:15 | ...; | successor |
-| NullableRefTypes.cs:81:9:81:17 | ...; | NullableRefTypes.cs:81:13:81:16 | null | successor |
-| NullableRefTypes.cs:81:13:81:16 | null | NullableRefTypes.cs:81:9:81:16 | ... = ... | successor |
-| NullableRefTypes.cs:82:9:82:14 | ... = ... | NullableRefTypes.cs:76:10:76:40 | exit TestSuppressNullableWarningExpr | successor |
-| NullableRefTypes.cs:82:9:82:15 | ...; | NullableRefTypes.cs:82:13:82:13 | access to local variable x | successor |
-| NullableRefTypes.cs:82:13:82:13 | access to local variable x | NullableRefTypes.cs:82:13:82:14 | ...! | successor |
-| NullableRefTypes.cs:82:13:82:14 | ...! | NullableRefTypes.cs:82:9:82:14 | ... = ... | successor |
+| NullableRefTypes.cs:82:10:82:40 | enter TestSuppressNullableWarningExpr | NullableRefTypes.cs:83:5:89:5 | {...} | successor |
+| NullableRefTypes.cs:83:5:89:5 | {...} | NullableRefTypes.cs:84:9:84:29 | ... ...; | successor |
+| NullableRefTypes.cs:84:9:84:29 | ... ...; | NullableRefTypes.cs:84:21:84:28 | "source" | successor |
+| NullableRefTypes.cs:84:17:84:28 | String x = ... | NullableRefTypes.cs:85:9:85:22 | ... ...; | successor |
+| NullableRefTypes.cs:84:21:84:28 | "source" | NullableRefTypes.cs:84:17:84:28 | String x = ... | successor |
+| NullableRefTypes.cs:85:9:85:22 | ... ...; | NullableRefTypes.cs:85:20:85:20 | access to local variable x | successor |
+| NullableRefTypes.cs:85:16:85:21 | String y = ... | NullableRefTypes.cs:86:9:86:16 | ...; | successor |
+| NullableRefTypes.cs:85:20:85:20 | access to local variable x | NullableRefTypes.cs:85:20:85:21 | ...! | successor |
+| NullableRefTypes.cs:85:20:85:21 | ...! | NullableRefTypes.cs:85:16:85:21 | String y = ... | successor |
+| NullableRefTypes.cs:86:9:86:15 | ... = ... | NullableRefTypes.cs:87:9:87:17 | ...; | successor |
+| NullableRefTypes.cs:86:9:86:16 | ...; | NullableRefTypes.cs:86:13:86:13 | access to local variable x | successor |
+| NullableRefTypes.cs:86:13:86:13 | access to local variable x | NullableRefTypes.cs:86:13:86:14 | ...! | successor |
+| NullableRefTypes.cs:86:13:86:14 | ...! | NullableRefTypes.cs:86:13:86:15 | ...! | successor |
+| NullableRefTypes.cs:86:13:86:15 | ...! | NullableRefTypes.cs:86:9:86:15 | ... = ... | successor |
+| NullableRefTypes.cs:87:9:87:16 | ... = ... | NullableRefTypes.cs:88:9:88:15 | ...; | successor |
+| NullableRefTypes.cs:87:9:87:17 | ...; | NullableRefTypes.cs:87:13:87:16 | null | successor |
+| NullableRefTypes.cs:87:13:87:16 | null | NullableRefTypes.cs:87:9:87:16 | ... = ... | successor |
+| NullableRefTypes.cs:88:9:88:14 | ... = ... | NullableRefTypes.cs:82:10:82:40 | exit TestSuppressNullableWarningExpr | successor |
+| NullableRefTypes.cs:88:9:88:15 | ...; | NullableRefTypes.cs:88:13:88:13 | access to local variable x | successor |
+| NullableRefTypes.cs:88:13:88:13 | access to local variable x | NullableRefTypes.cs:88:13:88:14 | ...! | successor |
+| NullableRefTypes.cs:88:13:88:14 | ...! | NullableRefTypes.cs:88:9:88:14 | ... = ... | successor |
 nonNullExpressions
-| NullableRefTypes.cs:78:21:78:28 | "source" |
-| NullableRefTypes.cs:79:20:79:20 | access to local variable x |
-| NullableRefTypes.cs:79:20:79:21 | ...! |
-| NullableRefTypes.cs:80:9:80:15 | ... = ... |
-| NullableRefTypes.cs:80:13:80:13 | access to local variable x |
-| NullableRefTypes.cs:80:13:80:14 | ...! |
-| NullableRefTypes.cs:80:13:80:15 | ...! |
-| NullableRefTypes.cs:82:9:82:14 | ... = ... |
-| NullableRefTypes.cs:82:13:82:14 | ...! |
+| NullableRefTypes.cs:84:21:84:28 | "source" |
+| NullableRefTypes.cs:85:20:85:20 | access to local variable x |
+| NullableRefTypes.cs:85:20:85:21 | ...! |
+| NullableRefTypes.cs:86:9:86:15 | ... = ... |
+| NullableRefTypes.cs:86:13:86:13 | access to local variable x |
+| NullableRefTypes.cs:86:13:86:14 | ...! |
+| NullableRefTypes.cs:86:13:86:15 | ...! |
+| NullableRefTypes.cs:88:9:88:14 | ... = ... |
+| NullableRefTypes.cs:88:13:88:14 | ...! |
 assignableTypes
-| NullableRefTypes.cs:9:14:9:14 | A | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:10:13:10:13 | B | NullableRefTypes.cs:6:7:6:13 | MyClass! |
-| NullableRefTypes.cs:13:14:13:14 | C | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:14:13:14:13 | D | NullableRefTypes.cs:6:7:6:13 | MyClass! |
-| NullableRefTypes.cs:17:14:17:17 | Item | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:18:13:18:16 | Item | NullableRefTypes.cs:6:7:6:13 | MyClass! |
-| NullableRefTypes.cs:19:13:19:16 | Item | NullableRefTypes.cs:6:7:6:13 | MyClass! |
-| NullableRefTypes.cs:19:27:19:27 | i | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:19:27:19:27 | i | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:22:16:22:17 | G1 | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! |
-| NullableRefTypes.cs:23:17:23:18 | G2 | NullableRefTypes.cs:6:7:6:13 | MyClass?[]? |
-| NullableRefTypes.cs:24:16:24:17 | G3 | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! |
-| NullableRefTypes.cs:25:18:25:18 | H | NullableRefTypes.cs:6:7:6:13 | MyClass?[][]! |
-| NullableRefTypes.cs:26:38:26:38 | x | NullableRefTypes.cs:6:7:6:13 | MyClass![]?[]! |
-| NullableRefTypes.cs:27:38:27:38 | x | NullableRefTypes.cs:6:7:6:13 | MyClass?[][]! |
-| NullableRefTypes.cs:32:20:32:20 | a | NullableRefTypes.cs:6:7:6:13 | MyClass! |
-| NullableRefTypes.cs:32:31:32:31 | b | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:37:17:37:17 | a | NullableRefTypes.cs:6:7:6:13 | MyClass! |
-| NullableRefTypes.cs:38:18:38:18 | b | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:39:21:39:21 | c | NullableRefTypes.cs:6:7:6:13 | ref MyClass! |
-| NullableRefTypes.cs:40:22:40:22 | d | NullableRefTypes.cs:6:7:6:13 | ref MyClass? |
-| NullableRefTypes.cs:47:35:47:35 | x | NullableRefTypes.cs:6:7:6:13 | MyClass! |
-| NullableRefTypes.cs:47:35:47:35 | x | NullableRefTypes.cs:6:7:6:13 | MyClass! |
-| NullableRefTypes.cs:47:35:47:35 | x | NullableRefTypes.cs:6:7:6:13 | MyClass! |
-| NullableRefTypes.cs:48:16:48:16 | P | NullableRefTypes.cs:47:23:47:25 | Del? |
-| NullableRefTypes.cs:48:16:48:16 | value | NullableRefTypes.cs:47:23:47:25 | Del? |
-| NullableRefTypes.cs:48:16:48:16 | value | NullableRefTypes.cs:47:23:47:25 | Del? |
-| NullableRefTypes.cs:51:19:51:19 | t | NullableRefTypes.cs:6:7:6:13 | MyClass |
-| NullableRefTypes.cs:51:19:51:19 | t | NullableRefTypes.cs:51:14:51:14 | T! |
-| NullableRefTypes.cs:59:54:59:59 | items2 | NullableRefTypes.cs:54:11:54:33 | Generic<MyClass?, MyClass!, IDisposable!, MyClass!>! |
-| NullableRefTypes.cs:61:25:61:25 | x | NullableRefTypes.cs:6:7:6:13 | MyClass |
-| NullableRefTypes.cs:61:25:61:25 | x | NullableRefTypes.cs:61:20:61:20 | T! |
-| NullableRefTypes.cs:67:18:67:18 | x | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:97:42:97:42 | r | NullableRefTypes.cs:6:7:6:13 | ref MyClass! |
-| NullableRefTypes.cs:98:42:98:42 | r | NullableRefTypes.cs:6:7:6:13 | ref MyClass? |
-| NullableRefTypes.cs:99:51:99:51 | r | NullableRefTypes.cs:6:7:6:13 | readonly MyClass? |
-| NullableRefTypes.cs:100:50:100:50 | r | NullableRefTypes.cs:6:7:6:13 | readonly MyClass! |
-| NullableRefTypes.cs:101:49:101:49 | r | NullableRefTypes.cs:6:7:6:13 | readonly MyClass! |
-| NullableRefTypes.cs:102:50:102:50 | r | NullableRefTypes.cs:6:7:6:13 | readonly MyClass? |
-| NullableRefTypes.cs:104:34:104:35 | p1 | NullableRefTypes.cs:6:7:6:13 | ref MyClass! |
-| NullableRefTypes.cs:104:51:104:52 | p2 | NullableRefTypes.cs:6:7:6:13 | out MyClass? |
-| NullableRefTypes.cs:106:14:106:21 | Property | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:107:17:107:27 | RefProperty | NullableRefTypes.cs:6:7:6:13 | ref MyClass! |
-| NullableRefTypes.cs:112:15:112:15 | a | NullableRefTypes.cs:159:8:159:15 | MyStruct? |
-| NullableRefTypes.cs:113:17:113:17 | b | NullableRefTypes.cs:159:8:159:15 | MyStruct![]? |
-| NullableRefTypes.cs:114:17:114:17 | c | NullableRefTypes.cs:159:8:159:15 | MyStruct?[]! |
-| NullableRefTypes.cs:115:18:115:18 | d | NullableRefTypes.cs:159:8:159:15 | MyStruct?[]? |
-| NullableRefTypes.cs:117:14:117:14 | e | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:118:16:118:16 | f | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! |
-| NullableRefTypes.cs:119:16:119:16 | g | NullableRefTypes.cs:6:7:6:13 | MyClass![]? |
-| NullableRefTypes.cs:120:17:120:17 | h | NullableRefTypes.cs:6:7:6:13 | MyClass?[]? |
-| NullableRefTypes.cs:122:23:122:23 | i | NullableRefTypes.cs:6:7:6:13 | MyClass![,,]?[,][]! |
-| NullableRefTypes.cs:123:22:123:22 | j | NullableRefTypes.cs:6:7:6:13 | MyClass![,,][,][]! |
-| NullableRefTypes.cs:124:27:124:27 | k | NullableRefTypes.cs:6:7:6:13 | MyClass![,,,][][,][,,]! |
-| NullableRefTypes.cs:125:29:125:29 | l | NullableRefTypes.cs:6:7:6:13 | MyClass?[,,,][][,]?[,,]! |
-| NullableRefTypes.cs:132:15:132:15 | a | NullableRefTypes.cs:159:8:159:15 | MyStruct? |
-| NullableRefTypes.cs:133:17:133:17 | b | NullableRefTypes.cs:159:8:159:15 | MyStruct![]? |
-| NullableRefTypes.cs:134:17:134:17 | c | NullableRefTypes.cs:159:8:159:15 | MyStruct?[] |
-| NullableRefTypes.cs:135:18:135:18 | d | NullableRefTypes.cs:159:8:159:15 | MyStruct?[]? |
-| NullableRefTypes.cs:137:14:137:14 | e | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:138:16:138:16 | f | NullableRefTypes.cs:6:7:6:13 | MyClass?[] |
-| NullableRefTypes.cs:139:16:139:16 | g | NullableRefTypes.cs:6:7:6:13 | MyClass[]? |
-| NullableRefTypes.cs:140:17:140:17 | h | NullableRefTypes.cs:6:7:6:13 | MyClass?[]? |
-| NullableRefTypes.cs:142:23:142:23 | i | NullableRefTypes.cs:6:7:6:13 | MyClass[,,]?[,][] |
-| NullableRefTypes.cs:143:22:143:22 | j | NullableRefTypes.cs:6:7:6:13 | MyClass[,,][,][] |
-| NullableRefTypes.cs:144:27:144:27 | k | NullableRefTypes.cs:6:7:6:13 | MyClass[,,,][][,][,,] |
-| NullableRefTypes.cs:145:29:145:29 | l | NullableRefTypes.cs:6:7:6:13 | MyClass?[,,,][][,]?[,,] |
-| NullableRefTypes.cs:150:13:150:14 | f1 | NullableRefTypes.cs:6:7:6:13 | MyClass |
-| NullableRefTypes.cs:151:13:151:13 | P | NullableRefTypes.cs:6:7:6:13 | MyClass |
-| NullableRefTypes.cs:152:24:152:24 | p | NullableRefTypes.cs:6:7:6:13 | MyClass |
-| NullableRefTypes.cs:154:17:154:17 | a | NullableRefTypes.cs:6:7:6:13 | MyClass |
+| NullableRefTypes.cs:9:14:9:14 | A | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:10:13:10:13 | B | NullableRefTypes.cs:6:7:6:13 | MyClass! | ! |
+| NullableRefTypes.cs:13:14:13:14 | C | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:14:13:14:13 | D | NullableRefTypes.cs:6:7:6:13 | MyClass! | ! |
+| NullableRefTypes.cs:17:14:17:17 | Item | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:18:13:18:16 | Item | NullableRefTypes.cs:6:7:6:13 | MyClass! | ! |
+| NullableRefTypes.cs:19:13:19:16 | Item | NullableRefTypes.cs:6:7:6:13 | MyClass! | ! |
+| NullableRefTypes.cs:19:27:19:27 | i | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:19:27:19:27 | i | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:22:16:22:17 | G1 | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! | <?>! |
+| NullableRefTypes.cs:23:17:23:18 | G2 | NullableRefTypes.cs:6:7:6:13 | MyClass?[]? | ? |
+| NullableRefTypes.cs:24:16:24:17 | G3 | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! | <?>! |
+| NullableRefTypes.cs:25:18:25:18 | H | NullableRefTypes.cs:6:7:6:13 | MyClass?[][]! | <<?>!>! |
+| NullableRefTypes.cs:26:38:26:38 | x | NullableRefTypes.cs:6:7:6:13 | MyClass![]?[]! | <<!>?>! |
+| NullableRefTypes.cs:27:38:27:38 | x | NullableRefTypes.cs:6:7:6:13 | MyClass?[][]! | <<?>!>! |
+| NullableRefTypes.cs:32:20:32:20 | a | NullableRefTypes.cs:6:7:6:13 | MyClass! | ! |
+| NullableRefTypes.cs:32:31:32:31 | b | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:37:17:37:17 | a | NullableRefTypes.cs:6:7:6:13 | MyClass! | ! |
+| NullableRefTypes.cs:38:18:38:18 | b | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:39:21:39:21 | c | NullableRefTypes.cs:6:7:6:13 | ref MyClass! | ! |
+| NullableRefTypes.cs:40:22:40:22 | d | NullableRefTypes.cs:6:7:6:13 | ref MyClass? | ? |
+| NullableRefTypes.cs:47:35:47:35 | x | NullableRefTypes.cs:6:7:6:13 | MyClass! | ! |
+| NullableRefTypes.cs:47:35:47:35 | x | NullableRefTypes.cs:6:7:6:13 | MyClass! | ! |
+| NullableRefTypes.cs:47:35:47:35 | x | NullableRefTypes.cs:6:7:6:13 | MyClass! | ! |
+| NullableRefTypes.cs:48:16:48:16 | P | NullableRefTypes.cs:47:23:47:25 | Del? | ? |
+| NullableRefTypes.cs:48:16:48:16 | value | NullableRefTypes.cs:47:23:47:25 | Del? | ? |
+| NullableRefTypes.cs:48:16:48:16 | value | NullableRefTypes.cs:47:23:47:25 | Del? | ? |
+| NullableRefTypes.cs:51:19:51:19 | t | NullableRefTypes.cs:6:7:6:13 | MyClass | _ |
+| NullableRefTypes.cs:51:19:51:19 | t | NullableRefTypes.cs:51:14:51:14 | T! | ! |
+| NullableRefTypes.cs:65:54:65:59 | items2 | NullableRefTypes.cs:54:11:54:33 | Generic<MyClass?, MyClass!, IDisposable!, MyClass!>! | <?,!,!,!>! |
+| NullableRefTypes.cs:67:25:67:25 | x | NullableRefTypes.cs:6:7:6:13 | MyClass | _ |
+| NullableRefTypes.cs:67:25:67:25 | x | NullableRefTypes.cs:67:20:67:20 | T! | ! |
+| NullableRefTypes.cs:73:18:73:18 | x | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:103:42:103:42 | r | NullableRefTypes.cs:6:7:6:13 | ref MyClass! | ! |
+| NullableRefTypes.cs:104:42:104:42 | r | NullableRefTypes.cs:6:7:6:13 | ref MyClass? | ? |
+| NullableRefTypes.cs:105:51:105:51 | r | NullableRefTypes.cs:6:7:6:13 | readonly MyClass? | ? |
+| NullableRefTypes.cs:106:50:106:50 | r | NullableRefTypes.cs:6:7:6:13 | readonly MyClass! | ! |
+| NullableRefTypes.cs:107:49:107:49 | r | NullableRefTypes.cs:6:7:6:13 | readonly MyClass! | ! |
+| NullableRefTypes.cs:108:50:108:50 | r | NullableRefTypes.cs:6:7:6:13 | readonly MyClass? | ? |
+| NullableRefTypes.cs:110:34:110:35 | p1 | NullableRefTypes.cs:6:7:6:13 | ref MyClass! | ! |
+| NullableRefTypes.cs:110:51:110:52 | p2 | NullableRefTypes.cs:6:7:6:13 | out MyClass? | ? |
+| NullableRefTypes.cs:112:14:112:21 | Property | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:113:17:113:27 | RefProperty | NullableRefTypes.cs:6:7:6:13 | ref MyClass! | ! |
+| NullableRefTypes.cs:118:15:118:15 | a | NullableRefTypes.cs:165:8:165:15 | MyStruct? | <_>? |
+| NullableRefTypes.cs:119:17:119:17 | b | NullableRefTypes.cs:165:8:165:15 | MyStruct![]? | <!>? |
+| NullableRefTypes.cs:120:17:120:17 | c | NullableRefTypes.cs:165:8:165:15 | MyStruct?[]! | <<_>?>! |
+| NullableRefTypes.cs:121:18:121:18 | d | NullableRefTypes.cs:165:8:165:15 | MyStruct?[]? | <<_>?>? |
+| NullableRefTypes.cs:123:14:123:14 | e | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:124:16:124:16 | f | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! | <?>! |
+| NullableRefTypes.cs:125:16:125:16 | g | NullableRefTypes.cs:6:7:6:13 | MyClass![]? | <!>? |
+| NullableRefTypes.cs:126:17:126:17 | h | NullableRefTypes.cs:6:7:6:13 | MyClass?[]? | ? |
+| NullableRefTypes.cs:128:23:128:23 | i | NullableRefTypes.cs:6:7:6:13 | MyClass![,,]?[,][]! | <<<!>?>!>! |
+| NullableRefTypes.cs:129:22:129:22 | j | NullableRefTypes.cs:6:7:6:13 | MyClass![,,][,][]! | ! |
+| NullableRefTypes.cs:130:27:130:27 | k | NullableRefTypes.cs:6:7:6:13 | MyClass![,,,][][,][,,]! | ! |
+| NullableRefTypes.cs:131:29:131:29 | l | NullableRefTypes.cs:6:7:6:13 | MyClass?[,,,][][,]?[,,]! | <<<<?>!>!>?>! |
+| NullableRefTypes.cs:138:15:138:15 | a | NullableRefTypes.cs:165:8:165:15 | MyStruct? | <_>? |
+| NullableRefTypes.cs:139:17:139:17 | b | NullableRefTypes.cs:165:8:165:15 | MyStruct[]? | <_>? |
+| NullableRefTypes.cs:140:17:140:17 | c | NullableRefTypes.cs:165:8:165:15 | MyStruct?[] | <<_>?>_ |
+| NullableRefTypes.cs:141:18:141:18 | d | NullableRefTypes.cs:165:8:165:15 | MyStruct?[]? | <<_>?>? |
+| NullableRefTypes.cs:143:14:143:14 | e | NullableRefTypes.cs:6:7:6:13 | MyClass? | ? |
+| NullableRefTypes.cs:144:16:144:16 | f | NullableRefTypes.cs:6:7:6:13 | MyClass?[] | <?>_ |
+| NullableRefTypes.cs:145:16:145:16 | g | NullableRefTypes.cs:6:7:6:13 | MyClass[]? | <_>? |
+| NullableRefTypes.cs:146:17:146:17 | h | NullableRefTypes.cs:6:7:6:13 | MyClass?[]? | ? |
+| NullableRefTypes.cs:148:23:148:23 | i | NullableRefTypes.cs:6:7:6:13 | MyClass[,,]?[,][] | <<<_>?>_>_ |
+| NullableRefTypes.cs:149:22:149:22 | j | NullableRefTypes.cs:6:7:6:13 | MyClass[,,][,][] | _ |
+| NullableRefTypes.cs:150:27:150:27 | k | NullableRefTypes.cs:6:7:6:13 | MyClass[,,,][][,][,,] | _ |
+| NullableRefTypes.cs:151:29:151:29 | l | NullableRefTypes.cs:6:7:6:13 | MyClass?[,,,][][,]?[,,] | <<<<?>_>_>?>_ |
+| NullableRefTypes.cs:156:13:156:14 | f1 | NullableRefTypes.cs:6:7:6:13 | MyClass | _ |
+| NullableRefTypes.cs:157:13:157:13 | P | NullableRefTypes.cs:6:7:6:13 | MyClass | _ |
+| NullableRefTypes.cs:158:24:158:24 | p | NullableRefTypes.cs:6:7:6:13 | MyClass | _ |
+| NullableRefTypes.cs:160:17:160:17 | a | NullableRefTypes.cs:6:7:6:13 | MyClass | _ |
 arrayElements
-| NullableRefTypes.cs:22:16:22:17 | G1 | NullableRefTypes.cs:6:7:6:13 | MyClass[] | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:23:17:23:18 | G2 | NullableRefTypes.cs:6:7:6:13 | MyClass[] | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:24:16:24:17 | G3 | NullableRefTypes.cs:6:7:6:13 | MyClass[] | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:25:18:25:18 | H | NullableRefTypes.cs:6:7:6:13 | MyClass[][] | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! |
-| NullableRefTypes.cs:26:38:26:38 | x | NullableRefTypes.cs:6:7:6:13 | MyClass[][] | NullableRefTypes.cs:6:7:6:13 | MyClass![]? |
-| NullableRefTypes.cs:27:38:27:38 | x | NullableRefTypes.cs:6:7:6:13 | MyClass[][] | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! |
-| NullableRefTypes.cs:113:17:113:17 | b | NullableRefTypes.cs:159:8:159:15 | MyStruct[] | NullableRefTypes.cs:159:8:159:15 | MyStruct! |
-| NullableRefTypes.cs:114:17:114:17 | c | NullableRefTypes.cs:159:8:159:15 | Nullable | NullableRefTypes.cs:159:8:159:15 | MyStruct? |
-| NullableRefTypes.cs:115:18:115:18 | d | NullableRefTypes.cs:159:8:159:15 | Nullable | NullableRefTypes.cs:159:8:159:15 | MyStruct? |
-| NullableRefTypes.cs:118:16:118:16 | f | NullableRefTypes.cs:6:7:6:13 | MyClass[] | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:119:16:119:16 | g | NullableRefTypes.cs:6:7:6:13 | MyClass[] | NullableRefTypes.cs:6:7:6:13 | MyClass! |
-| NullableRefTypes.cs:120:17:120:17 | h | NullableRefTypes.cs:6:7:6:13 | MyClass[] | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:122:23:122:23 | i | NullableRefTypes.cs:6:7:6:13 | MyClass[,,][][,] | NullableRefTypes.cs:6:7:6:13 | MyClass![,,]?[]! |
-| NullableRefTypes.cs:123:22:123:22 | j | NullableRefTypes.cs:6:7:6:13 | MyClass[][,][,,] | NullableRefTypes.cs:6:7:6:13 | MyClass![,][]! |
-| NullableRefTypes.cs:124:27:124:27 | k | NullableRefTypes.cs:6:7:6:13 | MyClass[,,][,][][,,,] | NullableRefTypes.cs:6:7:6:13 | MyClass![][,][,,]! |
-| NullableRefTypes.cs:125:29:125:29 | l | NullableRefTypes.cs:6:7:6:13 | MyClass[,][][,,,][,,] | NullableRefTypes.cs:6:7:6:13 | MyClass?[,,,][][,]? |
-| NullableRefTypes.cs:133:17:133:17 | b | NullableRefTypes.cs:159:8:159:15 | MyStruct[] | NullableRefTypes.cs:159:8:159:15 | MyStruct! |
-| NullableRefTypes.cs:134:17:134:17 | c | NullableRefTypes.cs:159:8:159:15 | Nullable | NullableRefTypes.cs:159:8:159:15 | MyStruct? |
-| NullableRefTypes.cs:135:18:135:18 | d | NullableRefTypes.cs:159:8:159:15 | Nullable | NullableRefTypes.cs:159:8:159:15 | MyStruct? |
-| NullableRefTypes.cs:138:16:138:16 | f | NullableRefTypes.cs:6:7:6:13 | MyClass[] | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:139:16:139:16 | g | NullableRefTypes.cs:6:7:6:13 | MyClass[] | NullableRefTypes.cs:6:7:6:13 | MyClass |
-| NullableRefTypes.cs:140:17:140:17 | h | NullableRefTypes.cs:6:7:6:13 | MyClass[] | NullableRefTypes.cs:6:7:6:13 | MyClass? |
-| NullableRefTypes.cs:142:23:142:23 | i | NullableRefTypes.cs:6:7:6:13 | MyClass[,,][][,] | NullableRefTypes.cs:6:7:6:13 | MyClass[,,]?[] |
-| NullableRefTypes.cs:143:22:143:22 | j | NullableRefTypes.cs:6:7:6:13 | MyClass[][,][,,] | NullableRefTypes.cs:6:7:6:13 | MyClass[,][] |
-| NullableRefTypes.cs:144:27:144:27 | k | NullableRefTypes.cs:6:7:6:13 | MyClass[,,][,][][,,,] | NullableRefTypes.cs:6:7:6:13 | MyClass[][,][,,] |
-| NullableRefTypes.cs:145:29:145:29 | l | NullableRefTypes.cs:6:7:6:13 | MyClass[,][][,,,][,,] | NullableRefTypes.cs:6:7:6:13 | MyClass?[,,,][][,]? |
+| NullableRefTypes.cs:22:16:22:17 | G1 | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! | NullableRefTypes.cs:6:7:6:13 | MyClass? |
+| NullableRefTypes.cs:23:17:23:18 | G2 | NullableRefTypes.cs:6:7:6:13 | MyClass?[]? | NullableRefTypes.cs:6:7:6:13 | MyClass? |
+| NullableRefTypes.cs:24:16:24:17 | G3 | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! | NullableRefTypes.cs:6:7:6:13 | MyClass? |
+| NullableRefTypes.cs:25:18:25:18 | H | NullableRefTypes.cs:6:7:6:13 | MyClass?[][]! | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! |
+| NullableRefTypes.cs:26:38:26:38 | x | NullableRefTypes.cs:6:7:6:13 | MyClass![]?[]! | NullableRefTypes.cs:6:7:6:13 | MyClass![]? |
+| NullableRefTypes.cs:27:38:27:38 | x | NullableRefTypes.cs:6:7:6:13 | MyClass?[][]! | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! |
+| NullableRefTypes.cs:119:17:119:17 | b | NullableRefTypes.cs:165:8:165:15 | MyStruct![]? | NullableRefTypes.cs:165:8:165:15 | MyStruct! |
+| NullableRefTypes.cs:120:17:120:17 | c | NullableRefTypes.cs:165:8:165:15 | MyStruct?[]! | NullableRefTypes.cs:165:8:165:15 | MyStruct? |
+| NullableRefTypes.cs:121:18:121:18 | d | NullableRefTypes.cs:165:8:165:15 | MyStruct?[]? | NullableRefTypes.cs:165:8:165:15 | MyStruct? |
+| NullableRefTypes.cs:124:16:124:16 | f | NullableRefTypes.cs:6:7:6:13 | MyClass?[]! | NullableRefTypes.cs:6:7:6:13 | MyClass? |
+| NullableRefTypes.cs:125:16:125:16 | g | NullableRefTypes.cs:6:7:6:13 | MyClass![]? | NullableRefTypes.cs:6:7:6:13 | MyClass! |
+| NullableRefTypes.cs:126:17:126:17 | h | NullableRefTypes.cs:6:7:6:13 | MyClass?[]? | NullableRefTypes.cs:6:7:6:13 | MyClass? |
+| NullableRefTypes.cs:128:23:128:23 | i | NullableRefTypes.cs:6:7:6:13 | MyClass![,,]?[,][]! | NullableRefTypes.cs:6:7:6:13 | MyClass![,,]?[]! |
+| NullableRefTypes.cs:129:22:129:22 | j | NullableRefTypes.cs:6:7:6:13 | MyClass![,,][,][]! | NullableRefTypes.cs:6:7:6:13 | MyClass![,][]! |
+| NullableRefTypes.cs:130:27:130:27 | k | NullableRefTypes.cs:6:7:6:13 | MyClass![,,,][][,][,,]! | NullableRefTypes.cs:6:7:6:13 | MyClass![][,][,,]! |
+| NullableRefTypes.cs:131:29:131:29 | l | NullableRefTypes.cs:6:7:6:13 | MyClass?[,,,][][,]?[,,]! | NullableRefTypes.cs:6:7:6:13 | MyClass?[,,,][][,]? |
+| NullableRefTypes.cs:139:17:139:17 | b | NullableRefTypes.cs:165:8:165:15 | MyStruct[]? | NullableRefTypes.cs:165:8:165:15 | MyStruct |
+| NullableRefTypes.cs:140:17:140:17 | c | NullableRefTypes.cs:165:8:165:15 | MyStruct?[] | NullableRefTypes.cs:165:8:165:15 | MyStruct? |
+| NullableRefTypes.cs:141:18:141:18 | d | NullableRefTypes.cs:165:8:165:15 | MyStruct?[]? | NullableRefTypes.cs:165:8:165:15 | MyStruct? |
+| NullableRefTypes.cs:144:16:144:16 | f | NullableRefTypes.cs:6:7:6:13 | MyClass?[] | NullableRefTypes.cs:6:7:6:13 | MyClass? |
+| NullableRefTypes.cs:145:16:145:16 | g | NullableRefTypes.cs:6:7:6:13 | MyClass[]? | NullableRefTypes.cs:6:7:6:13 | MyClass |
+| NullableRefTypes.cs:146:17:146:17 | h | NullableRefTypes.cs:6:7:6:13 | MyClass?[]? | NullableRefTypes.cs:6:7:6:13 | MyClass? |
+| NullableRefTypes.cs:148:23:148:23 | i | NullableRefTypes.cs:6:7:6:13 | MyClass[,,]?[,][] | NullableRefTypes.cs:6:7:6:13 | MyClass[,,]?[] |
+| NullableRefTypes.cs:149:22:149:22 | j | NullableRefTypes.cs:6:7:6:13 | MyClass[,,][,][] | NullableRefTypes.cs:6:7:6:13 | MyClass[,][] |
+| NullableRefTypes.cs:150:27:150:27 | k | NullableRefTypes.cs:6:7:6:13 | MyClass[,,,][][,][,,] | NullableRefTypes.cs:6:7:6:13 | MyClass[][,][,,] |
+| NullableRefTypes.cs:151:29:151:29 | l | NullableRefTypes.cs:6:7:6:13 | MyClass?[,,,][][,]?[,,] | NullableRefTypes.cs:6:7:6:13 | MyClass?[,,,][][,]? |
 returnTypes
 | NullableRefTypes.cs:6:7:6:13 | MyClass | Void |
 | NullableRefTypes.cs:13:19:13:22 | get_C | MyClass? |
@@ -168,40 +168,61 @@ returnTypes
 | NullableRefTypes.cs:47:23:47:25 | Invoke | MyClass? |
 | NullableRefTypes.cs:48:16:48:16 | add_P | Void |
 | NullableRefTypes.cs:48:16:48:16 | remove_P | Void |
+| NullableRefTypes.cs:51:12:51:15 | Q | object |
 | NullableRefTypes.cs:51:12:51:15 | Q | object! |
 | NullableRefTypes.cs:51:12:51:15 | Q | object! |
 | NullableRefTypes.cs:54:11:54:33 | Generic | Void |
-| NullableRefTypes.cs:61:10:61:21 | GenericFn | Void! |
-| NullableRefTypes.cs:61:10:61:21 | GenericFn | Void! |
-| NullableRefTypes.cs:65:14:65:18 | CallF | MyStruct! |
-| NullableRefTypes.cs:74:7:74:22 | NullableRefTypes | Void |
-| NullableRefTypes.cs:76:10:76:40 | TestSuppressNullableWarningExpr | Void! |
-| NullableRefTypes.cs:85:10:85:34 | FunctionInNullableContext | Void! |
-| NullableRefTypes.cs:94:7:94:14 | RefTypes | Void |
-| NullableRefTypes.cs:97:18:97:28 | ReturnsRef1 | ref MyClass? |
-| NullableRefTypes.cs:98:17:98:27 | ReturnsRef2 | ref MyClass! |
-| NullableRefTypes.cs:99:27:99:37 | ReturnsRef3 | readonly MyClass? |
-| NullableRefTypes.cs:100:27:100:37 | ReturnsRef4 | readonly MyClass? |
-| NullableRefTypes.cs:101:26:101:36 | ReturnsRef5 | readonly MyClass! |
-| NullableRefTypes.cs:102:26:102:36 | ReturnsRef6 | readonly MyClass! |
-| NullableRefTypes.cs:104:10:104:20 | Parameters1 | Void! |
-| NullableRefTypes.cs:107:32:107:44 | get_RefProperty | MyClass! |
-| NullableRefTypes.cs:110:7:110:23 | ToStringWithTypes | Void |
-| NullableRefTypes.cs:130:7:130:24 | ToStringWithTypes2 | Void |
-| NullableRefTypes.cs:148:7:148:25 | DisabledNullability | Void |
-| NullableRefTypes.cs:151:18:151:30 | get_P | MyClass |
-| NullableRefTypes.cs:152:13:152:14 | Fn | MyClass |
-| NullableRefTypes.cs:159:8:159:15 | MyStruct | Void |
-typeArguments
+| NullableRefTypes.cs:58:11:58:26 | Generic2 | Void |
+| NullableRefTypes.cs:67:10:67:21 | GenericFn | Void |
+| NullableRefTypes.cs:67:10:67:21 | GenericFn | Void! |
+| NullableRefTypes.cs:67:10:67:21 | GenericFn | Void! |
+| NullableRefTypes.cs:71:14:71:18 | CallF | MyStruct! |
+| NullableRefTypes.cs:80:7:80:22 | NullableRefTypes | Void |
+| NullableRefTypes.cs:82:10:82:40 | TestSuppressNullableWarningExpr | Void! |
+| NullableRefTypes.cs:91:10:91:34 | FunctionInNullableContext | Void! |
+| NullableRefTypes.cs:100:7:100:14 | RefTypes | Void |
+| NullableRefTypes.cs:103:18:103:28 | ReturnsRef1 | ref MyClass? |
+| NullableRefTypes.cs:104:17:104:27 | ReturnsRef2 | ref MyClass! |
+| NullableRefTypes.cs:105:27:105:37 | ReturnsRef3 | readonly MyClass? |
+| NullableRefTypes.cs:106:27:106:37 | ReturnsRef4 | readonly MyClass? |
+| NullableRefTypes.cs:107:26:107:36 | ReturnsRef5 | readonly MyClass! |
+| NullableRefTypes.cs:108:26:108:36 | ReturnsRef6 | readonly MyClass! |
+| NullableRefTypes.cs:110:10:110:20 | Parameters1 | Void! |
+| NullableRefTypes.cs:113:32:113:44 | get_RefProperty | MyClass! |
+| NullableRefTypes.cs:116:7:116:23 | ToStringWithTypes | Void |
+| NullableRefTypes.cs:136:7:136:24 | ToStringWithTypes2 | Void |
+| NullableRefTypes.cs:154:7:154:25 | DisabledNullability | Void |
+| NullableRefTypes.cs:157:18:157:30 | get_P | MyClass |
+| NullableRefTypes.cs:158:13:158:14 | Fn | MyClass |
+| NullableRefTypes.cs:165:8:165:15 | MyStruct | Void |
+methodTypeArguments
 | NullableRefTypes.cs:51:12:51:15 | Q | 0 | MyClass |
-| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass,MyClass,IDisposable,MyClass> | 0 | MyClass? |
-| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass,MyClass,IDisposable,MyClass> | 1 | MyClass! |
-| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass,MyClass,IDisposable,MyClass> | 2 | IDisposable! |
-| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass,MyClass,IDisposable,MyClass> | 3 | MyClass! |
-| NullableRefTypes.cs:61:10:61:21 | GenericFn | 0 | MyClass |
+| NullableRefTypes.cs:51:12:51:15 | Q | 0 | MyClass! |
+| NullableRefTypes.cs:67:10:67:21 | GenericFn | 0 | MyClass |
+| NullableRefTypes.cs:67:10:67:21 | GenericFn | 0 | MyClass! |
+constructedTypes
+| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass, MyClass, IDisposable, MyClass> | 0 | MyClass | _ |
+| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass, MyClass, IDisposable, MyClass> | 1 | MyClass | _ |
+| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass, MyClass, IDisposable, MyClass> | 2 | IDisposable | _ |
+| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass, MyClass, IDisposable, MyClass> | 3 | MyClass | _ |
+| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass?, MyClass!, IDisposable!, MyClass!>! | 0 | MyClass? | <?,!,!,!>! |
+| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass?, MyClass!, IDisposable!, MyClass!>! | 1 | MyClass! | <?,!,!,!>! |
+| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass?, MyClass!, IDisposable!, MyClass!>! | 2 | IDisposable! | <?,!,!,!>! |
+| NullableRefTypes.cs:54:11:54:33 | Generic<MyClass?, MyClass!, IDisposable!, MyClass!>! | 3 | MyClass! | <?,!,!,!>! |
+| NullableRefTypes.cs:54:11:54:33 | Generic<string, T1, IEnumerable<string>, MyClass> | 0 | string | _ |
+| NullableRefTypes.cs:54:11:54:33 | Generic<string, T1, IEnumerable<string>, MyClass> | 1 | T1 | _ |
+| NullableRefTypes.cs:54:11:54:33 | Generic<string, T1, IEnumerable<string>, MyClass> | 2 | IEnumerable<string> | _ |
+| NullableRefTypes.cs:54:11:54:33 | Generic<string, T1, IEnumerable<string>, MyClass> | 3 | MyClass | _ |
+| NullableRefTypes.cs:54:11:54:33 | Generic<string?, T1?, IEnumerable<string?>!, MyClass!>! | 0 | string? | <?,?,<?>!,!>! |
+| NullableRefTypes.cs:54:11:54:33 | Generic<string?, T1?, IEnumerable<string?>!, MyClass!>! | 1 | T1? | <?,?,<?>!,!>! |
+| NullableRefTypes.cs:54:11:54:33 | Generic<string?, T1?, IEnumerable<string?>!, MyClass!>! | 2 | IEnumerable<string?>! | <?,?,<?>!,!>! |
+| NullableRefTypes.cs:54:11:54:33 | Generic<string?, T1?, IEnumerable<string?>!, MyClass!>! | 3 | MyClass! | <?,?,<?>!,!>! |
 nullableTypeParameters
 | NullableRefTypes.cs:54:19:54:20 | T1 |
 annotatedTypeConstraints
 | NullableRefTypes.cs:51:14:51:14 | T | NullableRefTypes.cs:6:7:6:13 | MyClass? |
 | NullableRefTypes.cs:54:23:54:24 | T2 | NullableRefTypes.cs:6:7:6:13 | MyClass? |
 | NullableRefTypes.cs:54:31:54:32 | T4 | NullableRefTypes.cs:6:7:6:13 | MyClass! |
+| NullableRefTypes.cs:58:20:58:21 | T1 | NullableRefTypes.cs:6:7:6:13 | MyClass! |
+| NullableRefTypes.cs:58:24:58:25 | T2 | NullableRefTypes.cs:54:11:54:33 | Generic<string?, T1?, IEnumerable<string?>!, MyClass!>! |
+typeNotAnnotated

csharp/ql/test/library-tests/csharp8/NullableRefTypes.ql

@@ -21,17 +21,18 @@ query predicate nonNullExpressions(NonNullExpr e) {
   e.getEnclosingCallable().getName() = "TestSuppressNullableWarningExpr"
 }
 
-query predicate assignableTypes(Assignable a, AnnotatedType t) {
+query predicate assignableTypes(Assignable a, AnnotatedType t, string n) {
   a.getFile().getBaseName() = "NullableRefTypes.cs" and
   t.getLocation() instanceof SourceLocation and
   a.getLocation() instanceof SourceLocation and
-  t = a.getAnnotatedType()
+  t = a.getAnnotatedType() and
+  n = t.getAnnotations().getNullability().toString()
 }
 
-query predicate arrayElements(Variable v, ArrayType array, AnnotatedType elementType) {
+query predicate arrayElements(Variable v, AnnotatedArrayType array, AnnotatedType elementType) {
   v.getFile().getBaseName() = "NullableRefTypes.cs" and
-  array = v.getType() and
-  elementType = array.getAnnotatedElementType()
+  array = v.getAnnotatedType() and
+  elementType = array.getElementType()
 }
 
 query predicate returnTypes(Callable c, string t) {
@@ -39,20 +40,25 @@ query predicate returnTypes(Callable c, string t) {
   t = c.getAnnotatedReturnType().toString()
 }
 
-query predicate typeArguments(ConstructedGeneric generic, int arg, string argument) {
-  (
-    generic = any(Variable v | v.fromSource()).getType()
-    or
-    generic = any(MethodCall mc).getTarget()
-  ) and
+query predicate methodTypeArguments(ConstructedGeneric generic, int arg, string argument) {
+  generic = any(MethodCall mc).getTarget() and
   argument = generic.getAnnotatedTypeArgument(arg).toString()
 }
 
+query predicate constructedTypes(AnnotatedConstructedType at, int i, string arg, string nullability) {
+  arg = at.getTypeArgument(i).toString() and
+  at.getLocation().getFile().getBaseName() = "NullableRefTypes.cs" and
+  nullability = at.getAnnotations().getNullability().toString()
+}
+
 query predicate nullableTypeParameters(TypeParameter p) {
-  p.getConstraints().hasNullableRefTypeConstraint()
+  p.getConstraints().hasNullableRefTypeConstraint() and
+  p.getLocation().getFile().getBaseName() = "NullableRefTypes.cs"
 }
 
 query predicate annotatedTypeConstraints(TypeParameter p, AnnotatedType t) {
   t = p.getConstraints().getAnAnnotatedTypeConstraint() and
   t.getLocation() instanceof SourceLocation
 }
+
+query predicate typeNotAnnotated(Type type) { not exists(AnnotatedType at | at.getType() = type) }

csharp/ql/test/library-tests/dispatch/GetADynamicTarget.expected

@@ -72,11 +72,11 @@
 | ViableCallable.cs:12:9:12:28 | call to method M | C2<Int32>.M<T3>(string, T3) |
 | ViableCallable.cs:12:9:12:28 | call to method M | C3.M<T3>(string, T3) |
 | ViableCallable.cs:12:9:12:28 | call to method M | C4<>.M<T3>(T[], T3) |
-| ViableCallable.cs:12:9:12:28 | call to method M | C4<Int32>.M<T3>(int[], T3) |
+| ViableCallable.cs:12:9:12:28 | call to method M | C4<Int32>.M<T3>(Int32[], T3) |
 | ViableCallable.cs:12:9:12:28 | call to method M | C5.M<T3>(string, T3) |
 | ViableCallable.cs:12:9:12:28 | call to method M | C6<,>.M<T3>(T1, T3) |
 | ViableCallable.cs:12:9:12:28 | call to method M | C6<Boolean,Byte>.M<T3>(bool, T3) |
-| ViableCallable.cs:12:9:12:28 | call to method M | C6<Int32[],Boolean>.M<T3>(int[], T3) |
+| ViableCallable.cs:12:9:12:28 | call to method M | C6<Int32[],Boolean>.M<T3>(Int32[], T3) |
 | ViableCallable.cs:12:9:12:28 | call to method M | C6<String,Boolean>.M<T3>(string, T3) |
 | ViableCallable.cs:12:9:12:28 | call to method M | C6<String,Decimal>.M<T3>(string, T3) |
 | ViableCallable.cs:12:9:12:28 | call to method M | C6<String,Int32>.M<T3>(string, T3) |
@@ -90,11 +90,11 @@
 | ViableCallable.cs:14:9:14:15 | access to property Prop | C2<Int32>.set_Prop(string) |
 | ViableCallable.cs:14:9:14:15 | access to property Prop | C3.set_Prop(string) |
 | ViableCallable.cs:14:9:14:15 | access to property Prop | C4<>.set_Prop(T[]) |
-| ViableCallable.cs:14:9:14:15 | access to property Prop | C4<Int32>.set_Prop(int[]) |
+| ViableCallable.cs:14:9:14:15 | access to property Prop | C4<Int32>.set_Prop(Int32[]) |
 | ViableCallable.cs:14:9:14:15 | access to property Prop | C5.set_Prop(string) |
 | ViableCallable.cs:14:9:14:15 | access to property Prop | C6<,>.set_Prop(T1) |
 | ViableCallable.cs:14:9:14:15 | access to property Prop | C6<Boolean,Byte>.set_Prop(bool) |
-| ViableCallable.cs:14:9:14:15 | access to property Prop | C6<Int32[],Boolean>.set_Prop(int[]) |
+| ViableCallable.cs:14:9:14:15 | access to property Prop | C6<Int32[],Boolean>.set_Prop(Int32[]) |
 | ViableCallable.cs:14:9:14:15 | access to property Prop | C6<String,Boolean>.set_Prop(string) |
 | ViableCallable.cs:14:9:14:15 | access to property Prop | C6<String,Decimal>.set_Prop(string) |
 | ViableCallable.cs:14:9:14:15 | access to property Prop | C6<String,Int32>.set_Prop(string) |
@@ -126,11 +126,11 @@
 | ViableCallable.cs:16:9:16:23 | access to indexer | C2<Int32>.set_Item(int, string) |
 | ViableCallable.cs:16:9:16:23 | access to indexer | C3.set_Item(decimal, string) |
 | ViableCallable.cs:16:9:16:23 | access to indexer | C4<>.set_Item(bool, T[]) |
-| ViableCallable.cs:16:9:16:23 | access to indexer | C4<Int32>.set_Item(bool, int[]) |
+| ViableCallable.cs:16:9:16:23 | access to indexer | C4<Int32>.set_Item(bool, Int32[]) |
 | ViableCallable.cs:16:9:16:23 | access to indexer | C5.set_Item(bool, string) |
 | ViableCallable.cs:16:9:16:23 | access to indexer | C6<,>.set_Item(T2, T1) |
 | ViableCallable.cs:16:9:16:23 | access to indexer | C6<Boolean,Byte>.set_Item(byte, bool) |
-| ViableCallable.cs:16:9:16:23 | access to indexer | C6<Int32[],Boolean>.set_Item(bool, int[]) |
+| ViableCallable.cs:16:9:16:23 | access to indexer | C6<Int32[],Boolean>.set_Item(bool, Int32[]) |
 | ViableCallable.cs:16:9:16:23 | access to indexer | C6<String,Boolean>.set_Item(bool, string) |
 | ViableCallable.cs:16:9:16:23 | access to indexer | C6<String,Decimal>.set_Item(decimal, string) |
 | ViableCallable.cs:16:9:16:23 | access to indexer | C6<String,Int32>.set_Item(int, string) |
@@ -156,64 +156,64 @@
 | ViableCallable.cs:16:27:16:41 | access to indexer | C6<T1,Byte>.get_Item(byte) |
 | ViableCallable.cs:16:27:16:41 | access to indexer | C7<>.get_Item(byte) |
 | ViableCallable.cs:16:27:16:41 | access to indexer | C7<Boolean>.get_Item(byte) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C2<>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C2<Boolean>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C2<Decimal>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C2<Int32>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C3.add_Event(EventHandler<string>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C2<>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C2<Boolean>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C2<Decimal>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C2<Int32>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C3.add_Event(EventHandler<String>) |
 | ViableCallable.cs:18:9:18:16 | access to event Event | C4<>.add_Event(EventHandler<T[]>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C4<Int32>.add_Event(EventHandler<int[]>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C5.add_Event(EventHandler<string>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C4<Int32>.add_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C5.add_Event(EventHandler<String>) |
 | ViableCallable.cs:18:9:18:16 | access to event Event | C6<,>.add_Event(EventHandler<T1>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C6<Boolean,Byte>.add_Event(EventHandler<bool>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C6<Int32[],Boolean>.add_Event(EventHandler<int[]>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C6<String,Boolean>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C6<String,Decimal>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C6<String,Int32>.add_Event(EventHandler<string>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C6<Boolean,Byte>.add_Event(EventHandler<Boolean>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C6<Int32[],Boolean>.add_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C6<String,Boolean>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C6<String,Decimal>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C6<String,Int32>.add_Event(EventHandler<String>) |
 | ViableCallable.cs:18:9:18:16 | access to event Event | C6<T1,Boolean>.add_Event(EventHandler<T1>) |
 | ViableCallable.cs:18:9:18:16 | access to event Event | C6<T1,Byte>.add_Event(EventHandler<T1>) |
 | ViableCallable.cs:18:9:18:16 | access to event Event | C7<>.add_Event(EventHandler<T1>) |
-| ViableCallable.cs:18:9:18:16 | access to event Event | C7<Boolean>.add_Event(EventHandler<bool>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C2<>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C2<Boolean>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C2<Decimal>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C2<Int32>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C3.remove_Event(EventHandler<string>) |
+| ViableCallable.cs:18:9:18:16 | access to event Event | C7<Boolean>.add_Event(EventHandler<Boolean>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C2<>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C2<Boolean>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C2<Decimal>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C2<Int32>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C3.remove_Event(EventHandler<String>) |
 | ViableCallable.cs:19:9:19:16 | access to event Event | C4<>.remove_Event(EventHandler<T[]>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C4<Int32>.remove_Event(EventHandler<int[]>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C5.remove_Event(EventHandler<string>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C4<Int32>.remove_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C5.remove_Event(EventHandler<String>) |
 | ViableCallable.cs:19:9:19:16 | access to event Event | C6<,>.remove_Event(EventHandler<T1>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C6<Boolean,Byte>.remove_Event(EventHandler<bool>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C6<Int32[],Boolean>.remove_Event(EventHandler<int[]>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C6<String,Boolean>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C6<String,Decimal>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C6<String,Int32>.remove_Event(EventHandler<string>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C6<Boolean,Byte>.remove_Event(EventHandler<Boolean>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C6<Int32[],Boolean>.remove_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C6<String,Boolean>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C6<String,Decimal>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C6<String,Int32>.remove_Event(EventHandler<String>) |
 | ViableCallable.cs:19:9:19:16 | access to event Event | C6<T1,Boolean>.remove_Event(EventHandler<T1>) |
 | ViableCallable.cs:19:9:19:16 | access to event Event | C6<T1,Byte>.remove_Event(EventHandler<T1>) |
 | ViableCallable.cs:19:9:19:16 | access to event Event | C7<>.remove_Event(EventHandler<T1>) |
-| ViableCallable.cs:19:9:19:16 | access to event Event | C7<Boolean>.remove_Event(EventHandler<bool>) |
+| ViableCallable.cs:19:9:19:16 | access to event Event | C7<Boolean>.remove_Event(EventHandler<Boolean>) |
 | ViableCallable.cs:22:9:22:30 | call to method M | C4<>.M<T3>(T[], T3) |
-| ViableCallable.cs:22:9:22:30 | call to method M | C4<Int32>.M<T3>(int[], T3) |
-| ViableCallable.cs:22:9:22:30 | call to method M | C6<Int32[],Boolean>.M<T3>(int[], T3) |
+| ViableCallable.cs:22:9:22:30 | call to method M | C4<Int32>.M<T3>(Int32[], T3) |
+| ViableCallable.cs:22:9:22:30 | call to method M | C6<Int32[],Boolean>.M<T3>(Int32[], T3) |
 | ViableCallable.cs:24:9:24:15 | access to property Prop | C4<>.set_Prop(T[]) |
-| ViableCallable.cs:24:9:24:15 | access to property Prop | C4<Int32>.set_Prop(int[]) |
-| ViableCallable.cs:24:9:24:15 | access to property Prop | C6<Int32[],Boolean>.set_Prop(int[]) |
+| ViableCallable.cs:24:9:24:15 | access to property Prop | C4<Int32>.set_Prop(Int32[]) |
+| ViableCallable.cs:24:9:24:15 | access to property Prop | C6<Int32[],Boolean>.set_Prop(Int32[]) |
 | ViableCallable.cs:24:19:24:25 | access to property Prop | C4<>.get_Prop() |
 | ViableCallable.cs:24:19:24:25 | access to property Prop | C4<Int32>.get_Prop() |
 | ViableCallable.cs:24:19:24:25 | access to property Prop | C6<Int32[],Boolean>.get_Prop() |
 | ViableCallable.cs:26:9:26:23 | access to indexer | C4<>.set_Item(bool, T[]) |
-| ViableCallable.cs:26:9:26:23 | access to indexer | C4<Int32>.set_Item(bool, int[]) |
-| ViableCallable.cs:26:9:26:23 | access to indexer | C6<Int32[],Boolean>.set_Item(bool, int[]) |
+| ViableCallable.cs:26:9:26:23 | access to indexer | C4<Int32>.set_Item(bool, Int32[]) |
+| ViableCallable.cs:26:9:26:23 | access to indexer | C6<Int32[],Boolean>.set_Item(bool, Int32[]) |
 | ViableCallable.cs:26:27:26:41 | access to indexer | C4<>.get_Item(bool) |
 | ViableCallable.cs:26:27:26:41 | access to indexer | C4<Int32>.get_Item(bool) |
 | ViableCallable.cs:26:27:26:41 | access to indexer | C6<Int32[],Boolean>.get_Item(bool) |
 | ViableCallable.cs:28:9:28:16 | access to event Event | C4<>.add_Event(EventHandler<T[]>) |
-| ViableCallable.cs:28:9:28:16 | access to event Event | C4<Int32>.add_Event(EventHandler<int[]>) |
-| ViableCallable.cs:28:9:28:16 | access to event Event | C6<Int32[],Boolean>.add_Event(EventHandler<int[]>) |
+| ViableCallable.cs:28:9:28:16 | access to event Event | C4<Int32>.add_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:28:9:28:16 | access to event Event | C6<Int32[],Boolean>.add_Event(EventHandler<Int32[]>) |
 | ViableCallable.cs:29:9:29:16 | access to event Event | C4<>.remove_Event(EventHandler<T[]>) |
-| ViableCallable.cs:29:9:29:16 | access to event Event | C4<Int32>.remove_Event(EventHandler<int[]>) |
-| ViableCallable.cs:29:9:29:16 | access to event Event | C6<Int32[],Boolean>.remove_Event(EventHandler<int[]>) |
-| ViableCallable.cs:32:30:32:52 | call to method Mock | ViableCallable.Mock<C1<string, int>>() |
+| ViableCallable.cs:29:9:29:16 | access to event Event | C4<Int32>.remove_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:29:9:29:16 | access to event Event | C6<Int32[],Boolean>.remove_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:32:30:32:52 | call to method Mock | ViableCallable.Mock<C1<String, Int32>>() |
 | ViableCallable.cs:33:9:33:23 | call to method M | C2<Int32>.M<T3>(string, T3) |
 | ViableCallable.cs:33:9:33:23 | call to method M | C6<String,Int32>.M<T3>(string, T3) |
 | ViableCallable.cs:35:9:35:15 | access to property Prop | C2<Int32>.set_Prop(string) |
@@ -224,11 +224,11 @@
 | ViableCallable.cs:37:9:37:13 | access to indexer | C6<String,Int32>.set_Item(int, string) |
 | ViableCallable.cs:37:17:37:21 | access to indexer | C2<Int32>.get_Item(int) |
 | ViableCallable.cs:37:17:37:21 | access to indexer | C6<String,Int32>.get_Item(int) |
-| ViableCallable.cs:39:9:39:16 | access to event Event | C2<Int32>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:39:9:39:16 | access to event Event | C6<String,Int32>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:40:9:40:16 | access to event Event | C2<Int32>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:40:9:40:16 | access to event Event | C6<String,Int32>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:43:34:43:60 | call to method Mock | ViableCallable.Mock<C1<string, decimal>>() |
+| ViableCallable.cs:39:9:39:16 | access to event Event | C2<Int32>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:39:9:39:16 | access to event Event | C6<String,Int32>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:40:9:40:16 | access to event Event | C2<Int32>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:40:9:40:16 | access to event Event | C6<String,Int32>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:43:34:43:60 | call to method Mock | ViableCallable.Mock<C1<String, Decimal>>() |
 | ViableCallable.cs:44:9:44:24 | call to method M | C2<Decimal>.M<T3>(string, T3) |
 | ViableCallable.cs:44:9:44:24 | call to method M | C3.M<T3>(string, T3) |
 | ViableCallable.cs:44:9:44:24 | call to method M | C6<String,Decimal>.M<T3>(string, T3) |
@@ -244,28 +244,28 @@
 | ViableCallable.cs:48:18:48:23 | access to indexer | C2<Decimal>.get_Item(decimal) |
 | ViableCallable.cs:48:18:48:23 | access to indexer | C3.get_Item(decimal) |
 | ViableCallable.cs:48:18:48:23 | access to indexer | C6<String,Decimal>.get_Item(decimal) |
-| ViableCallable.cs:50:9:50:16 | access to event Event | C2<Decimal>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:50:9:50:16 | access to event Event | C3.add_Event(EventHandler<string>) |
-| ViableCallable.cs:50:9:50:16 | access to event Event | C6<String,Decimal>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:51:9:51:16 | access to event Event | C2<Decimal>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:51:9:51:16 | access to event Event | C3.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:51:9:51:16 | access to event Event | C6<String,Decimal>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:54:30:54:52 | call to method Mock | ViableCallable.Mock<C1<int[], bool>>() |
-| ViableCallable.cs:55:9:55:44 | call to method M | C4<Int32>.M<T3>(int[], T3) |
-| ViableCallable.cs:55:9:55:44 | call to method M | C6<Int32[],Boolean>.M<T3>(int[], T3) |
-| ViableCallable.cs:57:9:57:15 | access to property Prop | C4<Int32>.set_Prop(int[]) |
-| ViableCallable.cs:57:9:57:15 | access to property Prop | C6<Int32[],Boolean>.set_Prop(int[]) |
+| ViableCallable.cs:50:9:50:16 | access to event Event | C2<Decimal>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:50:9:50:16 | access to event Event | C3.add_Event(EventHandler<String>) |
+| ViableCallable.cs:50:9:50:16 | access to event Event | C6<String,Decimal>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:51:9:51:16 | access to event Event | C2<Decimal>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:51:9:51:16 | access to event Event | C3.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:51:9:51:16 | access to event Event | C6<String,Decimal>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:54:30:54:52 | call to method Mock | ViableCallable.Mock<C1<Int32[], Boolean>>() |
+| ViableCallable.cs:55:9:55:44 | call to method M | C4<Int32>.M<T3>(Int32[], T3) |
+| ViableCallable.cs:55:9:55:44 | call to method M | C6<Int32[],Boolean>.M<T3>(Int32[], T3) |
+| ViableCallable.cs:57:9:57:15 | access to property Prop | C4<Int32>.set_Prop(Int32[]) |
+| ViableCallable.cs:57:9:57:15 | access to property Prop | C6<Int32[],Boolean>.set_Prop(Int32[]) |
 | ViableCallable.cs:57:19:57:25 | access to property Prop | C4<Int32>.get_Prop() |
 | ViableCallable.cs:57:19:57:25 | access to property Prop | C6<Int32[],Boolean>.get_Prop() |
-| ViableCallable.cs:59:9:59:17 | access to indexer | C4<Int32>.set_Item(bool, int[]) |
-| ViableCallable.cs:59:9:59:17 | access to indexer | C6<Int32[],Boolean>.set_Item(bool, int[]) |
+| ViableCallable.cs:59:9:59:17 | access to indexer | C4<Int32>.set_Item(bool, Int32[]) |
+| ViableCallable.cs:59:9:59:17 | access to indexer | C6<Int32[],Boolean>.set_Item(bool, Int32[]) |
 | ViableCallable.cs:59:21:59:29 | access to indexer | C4<Int32>.get_Item(bool) |
 | ViableCallable.cs:59:21:59:29 | access to indexer | C6<Int32[],Boolean>.get_Item(bool) |
-| ViableCallable.cs:61:9:61:16 | access to event Event | C4<Int32>.add_Event(EventHandler<int[]>) |
-| ViableCallable.cs:61:9:61:16 | access to event Event | C6<Int32[],Boolean>.add_Event(EventHandler<int[]>) |
-| ViableCallable.cs:62:9:62:16 | access to event Event | C4<Int32>.remove_Event(EventHandler<int[]>) |
-| ViableCallable.cs:62:9:62:16 | access to event Event | C6<Int32[],Boolean>.remove_Event(EventHandler<int[]>) |
-| ViableCallable.cs:65:31:65:54 | call to method Mock | ViableCallable.Mock<C1<string, bool>>() |
+| ViableCallable.cs:61:9:61:16 | access to event Event | C4<Int32>.add_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:61:9:61:16 | access to event Event | C6<Int32[],Boolean>.add_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:62:9:62:16 | access to event Event | C4<Int32>.remove_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:62:9:62:16 | access to event Event | C6<Int32[],Boolean>.remove_Event(EventHandler<Int32[]>) |
+| ViableCallable.cs:65:31:65:54 | call to method Mock | ViableCallable.Mock<C1<String, Boolean>>() |
 | ViableCallable.cs:66:9:66:30 | call to method M | C2<Boolean>.M<T3>(string, T3) |
 | ViableCallable.cs:66:9:66:30 | call to method M | C5.M<T3>(string, T3) |
 | ViableCallable.cs:66:9:66:30 | call to method M | C6<String,Boolean>.M<T3>(string, T3) |
@@ -281,12 +281,12 @@
 | ViableCallable.cs:70:21:70:29 | access to indexer | C2<Boolean>.get_Item(bool) |
 | ViableCallable.cs:70:21:70:29 | access to indexer | C5.get_Item(bool) |
 | ViableCallable.cs:70:21:70:29 | access to indexer | C6<String,Boolean>.get_Item(bool) |
-| ViableCallable.cs:72:9:72:16 | access to event Event | C2<Boolean>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:72:9:72:16 | access to event Event | C5.add_Event(EventHandler<string>) |
-| ViableCallable.cs:72:9:72:16 | access to event Event | C6<String,Boolean>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:73:9:73:16 | access to event Event | C2<Boolean>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:73:9:73:16 | access to event Event | C5.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:73:9:73:16 | access to event Event | C6<String,Boolean>.remove_Event(EventHandler<string>) |
+| ViableCallable.cs:72:9:72:16 | access to event Event | C2<Boolean>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:72:9:72:16 | access to event Event | C5.add_Event(EventHandler<String>) |
+| ViableCallable.cs:72:9:72:16 | access to event Event | C6<String,Boolean>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:73:9:73:16 | access to event Event | C2<Boolean>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:73:9:73:16 | access to event Event | C5.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:73:9:73:16 | access to event Event | C6<String,Boolean>.remove_Event(EventHandler<String>) |
 | ViableCallable.cs:77:9:77:29 | call to method M | C6<T1,Boolean>.M<T3>(T1, T3) |
 | ViableCallable.cs:79:9:79:15 | access to property Prop | C6<T1,Boolean>.set_Prop(T1) |
 | ViableCallable.cs:79:19:79:25 | access to property Prop | C6<T1,Boolean>.get_Prop() |
@@ -295,9 +295,9 @@
 | ViableCallable.cs:83:9:83:16 | access to event Event | C6<T1,Boolean>.add_Event(EventHandler<T1>) |
 | ViableCallable.cs:84:9:84:16 | access to event Event | C6<T1,Boolean>.remove_Event(EventHandler<T1>) |
 | ViableCallable.cs:87:21:87:30 | call to method Mock | ViableCallable.Mock<C8>() |
-| ViableCallable.cs:88:9:88:44 | dynamic call to method M | C8.M(IEnumerable<C1<string[], bool>>) |
-| ViableCallable.cs:88:9:88:44 | dynamic call to method M | C9<>.M(IEnumerable<C1<string[], bool>>) |
-| ViableCallable.cs:88:13:88:43 | call to method Mock | ViableCallable.Mock<IEnumerable<C4<string>>>() |
+| ViableCallable.cs:88:9:88:44 | dynamic call to method M | C8.M(IEnumerable<C1<String[],Boolean>>) |
+| ViableCallable.cs:88:9:88:44 | dynamic call to method M | C9<>.M(IEnumerable<C1<String[],Boolean>>) |
+| ViableCallable.cs:88:13:88:43 | call to method Mock | ViableCallable.Mock<IEnumerable<C4<String>>>() |
 | ViableCallable.cs:90:9:90:15 | dynamic access to member Prop1 | C8.set_Prop1(string) |
 | ViableCallable.cs:90:9:90:15 | dynamic access to member Prop1 | C9<>.set_Prop1(string) |
 | ViableCallable.cs:90:19:90:25 | dynamic access to member Prop1 | C8.get_Prop1() |
@@ -306,13 +306,13 @@
 | ViableCallable.cs:92:9:92:12 | dynamic access to element | C9<>.set_Item(int, string) |
 | ViableCallable.cs:92:16:92:19 | dynamic access to element | C8.get_Item(int) |
 | ViableCallable.cs:92:16:92:19 | dynamic access to element | C9<>.get_Item(int) |
-| ViableCallable.cs:95:13:95:40 | call to method Mock | ViableCallable.Mock<IEnumerable<C4<int>>>() |
+| ViableCallable.cs:95:13:95:40 | call to method Mock | ViableCallable.Mock<IEnumerable<C4<Int32>>>() |
 | ViableCallable.cs:99:9:99:15 | dynamic call to method M | C5.M(int) |
 | ViableCallable.cs:102:9:102:16 | access to property Prop2 | C5.set_Prop2(string) |
-| ViableCallable.cs:105:9:105:17 | access to event Event2 | C5.add_Event2(EventHandler<string>) |
-| ViableCallable.cs:106:9:106:17 | access to event Event2 | C5.remove_Event2(EventHandler<string>) |
-| ViableCallable.cs:120:9:120:25 | dynamic call to method M2 | C8.M2<decimal>(decimal[]) |
-| ViableCallable.cs:124:9:124:24 | dynamic call to method M2 | C8.M2<string>(string[]) |
+| ViableCallable.cs:105:9:105:17 | access to event Event2 | C5.add_Event2(EventHandler<String>) |
+| ViableCallable.cs:106:9:106:17 | access to event Event2 | C5.remove_Event2(EventHandler<String>) |
+| ViableCallable.cs:120:9:120:25 | dynamic call to method M2 | C8.M2<decimal>(Decimal[]) |
+| ViableCallable.cs:124:9:124:24 | dynamic call to method M2 | C8.M2<string>(String[]) |
 | ViableCallable.cs:132:9:132:28 | dynamic call to method M | C6<Boolean,Byte>.M<T3>(bool, T3) |
 | ViableCallable.cs:132:9:132:28 | dynamic call to method M | C6<T1,Byte>.M<T3>(T1, T3) |
 | ViableCallable.cs:134:9:134:14 | dynamic access to member Prop | C6<Boolean,Byte>.set_Prop(bool) |
@@ -326,23 +326,23 @@
 | ViableCallable.cs:138:9:138:52 | ... += ... | C6<T1,Byte>.add_Event(EventHandler<T1>) |
 | ViableCallable.cs:139:9:139:52 | ... -= ... | C6<T1,Byte>.remove_Event(EventHandler<T1>) |
 | ViableCallable.cs:143:13:143:22 | call to method Mock | ViableCallable.Mock<C8>() |
-| ViableCallable.cs:144:9:144:14 | dynamic call to method M3 | C8.M3(params double[]) |
+| ViableCallable.cs:144:9:144:14 | dynamic call to method M3 | C8.M3(params Double[]) |
 | ViableCallable.cs:144:9:144:14 | dynamic call to method M3 | C9<>.M3(params T[]) |
-| ViableCallable.cs:145:9:145:15 | dynamic call to method M3 | C8.M3(params double[]) |
+| ViableCallable.cs:145:9:145:15 | dynamic call to method M3 | C8.M3(params Double[]) |
 | ViableCallable.cs:145:9:145:15 | dynamic call to method M3 | C9<>.M3(params T[]) |
-| ViableCallable.cs:146:9:146:20 | dynamic call to method M3 | C8.M3(params double[]) |
+| ViableCallable.cs:146:9:146:20 | dynamic call to method M3 | C8.M3(params Double[]) |
 | ViableCallable.cs:146:9:146:20 | dynamic call to method M3 | C9<>.M3(params T[]) |
-| ViableCallable.cs:149:9:149:16 | dynamic call to method M3 | C8.M3(params double[]) |
+| ViableCallable.cs:149:9:149:16 | dynamic call to method M3 | C8.M3(params Double[]) |
 | ViableCallable.cs:149:9:149:16 | dynamic call to method M3 | C9<>.M3(params T[]) |
-| ViableCallable.cs:149:9:149:16 | dynamic call to method M3 | C10.M3(params double[]) |
+| ViableCallable.cs:149:9:149:16 | dynamic call to method M3 | C10.M3(params Double[]) |
 | ViableCallable.cs:149:9:149:16 | dynamic call to method M3 | Test.MainClass.ImplAlpha.M3() |
 | ViableCallable.cs:149:9:149:16 | dynamic call to method M3 | Test.MainClass.SecondLevelImpl.M3() |
-| ViableCallable.cs:150:9:150:17 | dynamic call to method M3 | C8.M3(params double[]) |
+| ViableCallable.cs:150:9:150:17 | dynamic call to method M3 | C8.M3(params Double[]) |
 | ViableCallable.cs:150:9:150:17 | dynamic call to method M3 | C9<>.M3(params T[]) |
-| ViableCallable.cs:150:9:150:17 | dynamic call to method M3 | C10.M3(params double[]) |
-| ViableCallable.cs:151:9:151:22 | dynamic call to method M3 | C8.M3(params double[]) |
+| ViableCallable.cs:150:9:150:17 | dynamic call to method M3 | C10.M3(params Double[]) |
+| ViableCallable.cs:151:9:151:22 | dynamic call to method M3 | C8.M3(params Double[]) |
 | ViableCallable.cs:151:9:151:22 | dynamic call to method M3 | C9<>.M3(params T[]) |
-| ViableCallable.cs:151:9:151:22 | dynamic call to method M3 | C10.M3(params double[]) |
+| ViableCallable.cs:151:9:151:22 | dynamic call to method M3 | C10.M3(params Double[]) |
 | ViableCallable.cs:153:9:153:17 | dynamic access to member Prop1 | C8.set_Prop1(string) |
 | ViableCallable.cs:153:9:153:17 | dynamic access to member Prop1 | C9<>.set_Prop1(string) |
 | ViableCallable.cs:153:9:153:17 | dynamic access to member Prop1 | C10.set_Prop1(bool) |
@@ -377,39 +377,39 @@
 | ViableCallable.cs:155:18:155:23 | dynamic access to element | C8.get_Item(int) |
 | ViableCallable.cs:155:18:155:23 | dynamic access to element | C9<>.get_Item(int) |
 | ViableCallable.cs:155:18:155:23 | dynamic access to element | C10.get_Item(int) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C2<>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C2<Boolean>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C2<Decimal>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C2<Int32>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C3.add_Event(EventHandler<string>) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C5.add_Event(EventHandler<string>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C2<>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C2<Boolean>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C2<Decimal>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C2<Int32>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C3.add_Event(EventHandler<String>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C5.add_Event(EventHandler<String>) |
 | ViableCallable.cs:157:9:157:54 | ... += ... | C6<,>.add_Event(EventHandler<T1>) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C6<String,Boolean>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C6<String,Decimal>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C6<String,Int32>.add_Event(EventHandler<string>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C6<String,Boolean>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C6<String,Decimal>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C6<String,Int32>.add_Event(EventHandler<String>) |
 | ViableCallable.cs:157:9:157:54 | ... += ... | C6<T1,Boolean>.add_Event(EventHandler<T1>) |
 | ViableCallable.cs:157:9:157:54 | ... += ... | C6<T1,Byte>.add_Event(EventHandler<T1>) |
 | ViableCallable.cs:157:9:157:54 | ... += ... | C7<>.add_Event(EventHandler<T1>) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C8.add_Event(EventHandler<string>) |
-| ViableCallable.cs:157:9:157:54 | ... += ... | C9<>.add_Event(EventHandler<string>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C2<>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C2<Boolean>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C2<Decimal>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C2<Int32>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C3.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C5.remove_Event(EventHandler<string>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C8.add_Event(EventHandler<String>) |
+| ViableCallable.cs:157:9:157:54 | ... += ... | C9<>.add_Event(EventHandler<String>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C2<>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C2<Boolean>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C2<Decimal>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C2<Int32>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C3.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C5.remove_Event(EventHandler<String>) |
 | ViableCallable.cs:158:9:158:54 | ... -= ... | C6<,>.remove_Event(EventHandler<T1>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C6<String,Boolean>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C6<String,Decimal>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C6<String,Int32>.remove_Event(EventHandler<string>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C6<String,Boolean>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C6<String,Decimal>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C6<String,Int32>.remove_Event(EventHandler<String>) |
 | ViableCallable.cs:158:9:158:54 | ... -= ... | C6<T1,Boolean>.remove_Event(EventHandler<T1>) |
 | ViableCallable.cs:158:9:158:54 | ... -= ... | C6<T1,Byte>.remove_Event(EventHandler<T1>) |
 | ViableCallable.cs:158:9:158:54 | ... -= ... | C7<>.remove_Event(EventHandler<T1>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C8.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:158:9:158:54 | ... -= ... | C9<>.remove_Event(EventHandler<string>) |
-| ViableCallable.cs:161:9:161:40 | dynamic call to method M4 | C8.M4(byte, IEnumerable<string>) |
-| ViableCallable.cs:161:19:161:39 | call to method Mock | ViableCallable.Mock<IList<string>>() |
-| ViableCallable.cs:162:9:162:38 | dynamic call to method M4 | C8.M4(byte, IEnumerable<string>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C8.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:158:9:158:54 | ... -= ... | C9<>.remove_Event(EventHandler<String>) |
+| ViableCallable.cs:161:9:161:40 | dynamic call to method M4 | C8.M4(byte, IEnumerable<String>) |
+| ViableCallable.cs:161:19:161:39 | call to method Mock | ViableCallable.Mock<IList<String>>() |
+| ViableCallable.cs:162:9:162:38 | dynamic call to method M4 | C8.M4(byte, IEnumerable<String>) |
 | ViableCallable.cs:165:9:165:17 | dynamic access to member Prop1 | C10.set_Prop1(bool) |
 | ViableCallable.cs:175:9:175:15 | dynamic access to element | C2<>.set_Item(T, string) |
 | ViableCallable.cs:175:9:175:15 | dynamic access to element | C6<,>.set_Item(T2, T1) |
@@ -420,19 +420,19 @@
 | ViableCallable.cs:191:9:191:149 | call to method InvokeMember | C10.set_Prop3(string) |
 | ViableCallable.cs:194:9:194:146 | call to method InvokeMember | C10.get_Item(int) |
 | ViableCallable.cs:195:9:195:152 | call to method InvokeMember | C10.set_Item(int, bool) |
-| ViableCallable.cs:199:9:199:147 | call to method InvokeMember | C10.add_Event(EventHandler<bool>) |
-| ViableCallable.cs:200:9:200:150 | call to method InvokeMember | C10.remove_Event(EventHandler<bool>) |
+| ViableCallable.cs:199:9:199:147 | call to method InvokeMember | C10.add_Event(EventHandler<Boolean>) |
+| ViableCallable.cs:200:9:200:150 | call to method InvokeMember | C10.remove_Event(EventHandler<Boolean>) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C2<>.M<T3>(string, T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C2<Boolean>.M<T3>(string, T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C2<Decimal>.M<T3>(string, T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C2<Int32>.M<T3>(string, T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C3.M<T3>(string, T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C4<>.M<T3>(T[], T3) |
-| ViableCallable.cs:235:9:235:15 | call to method M | C4<Int32>.M<T3>(int[], T3) |
+| ViableCallable.cs:235:9:235:15 | call to method M | C4<Int32>.M<T3>(Int32[], T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C5.M<T3>(string, T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C6<,>.M<T3>(T1, T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C6<Boolean,Byte>.M<T3>(bool, T3) |
-| ViableCallable.cs:235:9:235:15 | call to method M | C6<Int32[],Boolean>.M<T3>(int[], T3) |
+| ViableCallable.cs:235:9:235:15 | call to method M | C6<Int32[],Boolean>.M<T3>(Int32[], T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C6<String,Boolean>.M<T3>(string, T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C6<String,Decimal>.M<T3>(string, T3) |
 | ViableCallable.cs:235:9:235:15 | call to method M | C6<String,Int32>.M<T3>(string, T3) |

csharp/ql/test/library-tests/frameworks/format/StringFormatItemParameter.expected

@@ -4,57 +4,57 @@
 | Console | Write(string, object, object, object) | arg0 |
 | Console | Write(string, object, object, object) | arg1 |
 | Console | Write(string, object, object, object) | arg2 |
-| Console | Write(string, params object[]) | arg |
+| Console | Write(string, params Object[]) | arg |
 | Console | WriteLine(string, object) | arg0 |
 | Console | WriteLine(string, object, object) | arg0 |
 | Console | WriteLine(string, object, object) | arg1 |
 | Console | WriteLine(string, object, object, object) | arg0 |
 | Console | WriteLine(string, object, object, object) | arg1 |
 | Console | WriteLine(string, object, object, object) | arg2 |
-| Console | WriteLine(string, params object[]) | arg |
-| Debug | Assert(bool, string, string, params object[]) | args |
-| Debug | Print(string, params object[]) | args |
-| Debug | WriteLine(string, params object[]) | args |
+| Console | WriteLine(string, params Object[]) | arg |
+| Debug | Assert(bool, string, string, params Object[]) | args |
+| Debug | Print(string, params Object[]) | args |
+| Debug | WriteLine(string, params Object[]) | args |
 | StringBuilder | AppendFormat(IFormatProvider, string, object) | arg0 |
 | StringBuilder | AppendFormat(IFormatProvider, string, object, object) | arg0 |
 | StringBuilder | AppendFormat(IFormatProvider, string, object, object) | arg1 |
 | StringBuilder | AppendFormat(IFormatProvider, string, object, object, object) | arg0 |
 | StringBuilder | AppendFormat(IFormatProvider, string, object, object, object) | arg1 |
 | StringBuilder | AppendFormat(IFormatProvider, string, object, object, object) | arg2 |
-| StringBuilder | AppendFormat(IFormatProvider, string, params object[]) | args |
+| StringBuilder | AppendFormat(IFormatProvider, string, params Object[]) | args |
 | StringBuilder | AppendFormat(string, object) | arg0 |
 | StringBuilder | AppendFormat(string, object, object) | arg0 |
 | StringBuilder | AppendFormat(string, object, object) | arg1 |
 | StringBuilder | AppendFormat(string, object, object, object) | arg0 |
 | StringBuilder | AppendFormat(string, object, object, object) | arg1 |
 | StringBuilder | AppendFormat(string, object, object, object) | arg2 |
-| StringBuilder | AppendFormat(string, params object[]) | args |
-| Strings | MyStringFormat(string, params object[]) | args |
+| StringBuilder | AppendFormat(string, params Object[]) | args |
+| Strings | MyStringFormat(string, params Object[]) | args |
 | TextWriter | Write(string, object) | arg0 |
 | TextWriter | Write(string, object, object) | arg0 |
 | TextWriter | Write(string, object, object) | arg1 |
 | TextWriter | Write(string, object, object, object) | arg0 |
 | TextWriter | Write(string, object, object, object) | arg1 |
 | TextWriter | Write(string, object, object, object) | arg2 |
-| TextWriter | Write(string, params object[]) | arg |
+| TextWriter | Write(string, params Object[]) | arg |
 | TextWriter | WriteLine(string, object) | arg0 |
 | TextWriter | WriteLine(string, object, object) | arg0 |
 | TextWriter | WriteLine(string, object, object) | arg1 |
 | TextWriter | WriteLine(string, object, object, object) | arg0 |
 | TextWriter | WriteLine(string, object, object, object) | arg1 |
 | TextWriter | WriteLine(string, object, object, object) | arg2 |
-| TextWriter | WriteLine(string, params object[]) | arg |
+| TextWriter | WriteLine(string, params Object[]) | arg |
 | string | Format(IFormatProvider, string, object) | arg0 |
 | string | Format(IFormatProvider, string, object, object) | arg0 |
 | string | Format(IFormatProvider, string, object, object) | arg1 |
 | string | Format(IFormatProvider, string, object, object, object) | arg0 |
 | string | Format(IFormatProvider, string, object, object, object) | arg1 |
 | string | Format(IFormatProvider, string, object, object, object) | arg2 |
-| string | Format(IFormatProvider, string, params object[]) | args |
+| string | Format(IFormatProvider, string, params Object[]) | args |
 | string | Format(string, object) | arg0 |
 | string | Format(string, object, object) | arg0 |
 | string | Format(string, object, object) | arg1 |
 | string | Format(string, object, object, object) | arg0 |
 | string | Format(string, object, object, object) | arg1 |
 | string | Format(string, object, object, object) | arg2 |
-| string | Format(string, params object[]) | args |
+| string | Format(string, params Object[]) | args |

csharp/ql/test/library-tests/methods/Parameters9.expected

@@ -3,5 +3,5 @@
 | methods.cs:145:65:145:65 | e | methods.cs:145:69:145:77 | ... + ... | Method2(int, int, int, int, string) |
 | methods.cs:168:51:168:55 | right | methods.cs:168:59:168:59 | 0 | Plus(int, int) |
 | methods.cs:173:133:173:133 | i | methods.cs:173:137:173:137 | 1 | SkipTwo<T>(IEnumerable<T>, int) |
-| methods.cs:173:133:173:133 | i | methods.cs:173:137:173:137 | 1 | SkipTwo<int>(IEnumerable<int>, int) |
-| methods.cs:178:137:178:137 | i | methods.cs:178:141:178:141 | 1 | SkipTwoInt(IEnumerable<int>, int) |
+| methods.cs:173:133:173:133 | i | methods.cs:173:137:173:137 | 1 | SkipTwo<int>(IEnumerable<Int32>, int) |
+| methods.cs:178:137:178:137 | i | methods.cs:178:141:178:141 | 1 | SkipTwoInt(IEnumerable<Int32>, int) |

csharp/ql/test/library-tests/overrides/Overrides22.expected

@@ -2,15 +2,15 @@
 | CallTargets.C3.m() | CallTargets.C2.m() | overrides |
 | overrides.A1.Event | overrides.I5.Event | implements |
 | overrides.A1.Item[int] | overrides.I5.Item[int] | implements |
-| overrides.A1.M<T>(dynamic[], T) | overrides.I2<Object[]>.M<S>(object[], S) | implements |
+| overrides.A1.M<T>(dynamic[], T) | overrides.I2<Object[]>.M<S>(Object[], S) | implements |
 | overrides.A1.Property | overrides.I5.Property | implements |
 | overrides.A4.Event | overrides.I5.Event | implements |
 | overrides.A4.Item[int] | overrides.I5.Item[int] | implements |
-| overrides.A4.M<T>(dynamic[], T) | overrides.I2<Object[]>.M<S>(object[], S) | implements |
+| overrides.A4.M<T>(dynamic[], T) | overrides.I2<Object[]>.M<S>(Object[], S) | implements |
 | overrides.A4.Property | overrides.I5.Property | implements |
 | overrides.A6.Event | overrides.I5.Event | implements |
 | overrides.A6.Item[int] | overrides.I5.Item[int] | implements |
-| overrides.A6.M<T>(object[], T) | overrides.I2<Object[]>.M<S>(object[], S) | implements |
+| overrides.A6.M<T>(Object[], T) | overrides.I2<Object[]>.M<S>(Object[], S) | implements |
 | overrides.A6.Property | overrides.I5.Property | implements |
 | overrides.A8.Event | overrides.A1.Event | overrides |
 | overrides.A8.Item[int] | overrides.A1.Item[int] | overrides |

csharp/ql/test/library-tests/tostringwithtypes/toStringWithTypes.expected

@@ -1,7 +1,7 @@
 | Delegate<> | Delegate<T>(int, T) |
-| Delegate<String> | Delegate<string> |
 | Item | Item[T, bool] |
-| M | M(IEnumerable<int>) |
+| M | M(IEnumerable<Int32>) |
+| M | M(Int32[,,,][][,][,,]) |
 | M | M(__arglist) |
 | M | M(bool) |
 | M | M(byte) |
@@ -13,7 +13,6 @@
 | M | M(float) |
 | M | M(int) |
 | M | M(int*) |
-| M | M(int[,,,][][,][,,]) |
 | M | M(long) |
 | M | M(object) |
 | M | M(out T) |
@@ -27,6 +26,6 @@
 | M | M<S>(ref S) |
 | M | M<char?>(ref char?) |
 | ToStringWithTypes<> | ToStringWithTypes<T> |
-| add_Event | add_Event(Delegate<string>) |
+| add_Event | add_Event(Delegate<String>) |
 | get_Item | get_Item(T, bool) |
-| remove_Event | remove_Event(Delegate<string>) |
+| remove_Event | remove_Event(Delegate<String>) |

csharp/upgrades/f93793ee5f6b7bec615eaa1af0a1a4dea19472bb/upgrade.properties

@@ -0,0 +1,2 @@
+description: Implement structured nullability 
+compatibility: backwards