Merge pull request #1408 from calumgrant/cs/suppress-null-expr

C#: C#8 Nullable expressions and type annotations

Author: aibaars

change-notes/1.22/analysis-csharp.md

@@ -8,6 +8,18 @@
 
 ## Changes to code extraction
 
+* The following C# 8 features are now extracted:
+  - Suppress-nullable-warning expressions, for example `x!`
+  - Nullable reference types, for example `string?`
+
 ## Changes to QL libraries
 
+* The new class `AnnotatedType` models types with type annotations, including nullability information, return kinds (`ref` and `readonly ref`), and parameter kinds (`in`, `out`, and `ref`)
+  - The new predicate `Assignable.getAnnotatedType()` gets the annotated type of an assignable (such as a variable or a property)
+  - The new predicates `Callable.getAnnotatedReturnType()` and `DelegateType.getAnnotatedReturnType()` get the annotated type of the return value
+  - The new predicate `ArrayType.getAnnotatedElementType()` gets the annotated type of the array element
+  - The new predicate `ConstructedGeneric.getAnnotatedTypeArgument()` gets the annotated type of a type argument
+  - The new predicate `TypeParameterConstraints.getAnAnnotatedTypeConstraint()` gets a type constraint with type annotations
+* The new class `SuppressNullableWarningExpr` models suppress-nullable-warning expressions such as `x!`
+
 ## Changes to autobuilder

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

@@ -57,7 +57,7 @@ protected override void ExtractInitializers()
             }
 
             var initInfo = new ExpressionInfo(Context,
-                initializerType,
+                new AnnotatedType(initializerType, Kinds.TypeAnnotation.NotAnnotated),
                 Context.Create(initializer.ThisOrBaseKeyword.GetLocation()),
                 Kinds.ExprKind.CONSTRUCTOR_INIT,
                 this,

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

@@ -26,6 +26,8 @@ public override IId Id
 
         public override void Populate()
         {
+            ExtractNullability(symbol.NullableAnnotation);
+
             var type = Type.Create(Context, symbol.Type);
             Context.Emit(Tuples.events(this, symbol.GetName(), ContainingType, type.TypeRef, Create(Context, symbol.OriginalDefinition)));
 

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

@@ -18,7 +18,7 @@ public interface IExpressionParentEntity : IEntity
 
     class Expression : FreshEntity, IExpressionParentEntity
     {
-        public readonly Type Type;
+        public readonly AnnotatedType Type;
         public readonly Extraction.Entities.Location Location;
         public readonly ExprKind Kind;
 
@@ -27,9 +27,12 @@ internal Expression(IExpressionInfo info)
         {
             Location = info.Location;
             Kind = info.Kind;
-            Type = info.Type ?? NullType.Create(cx);
+            Type = info.Type;
 
-            cx.Emit(Tuples.expressions(this, Kind, Type.TypeRef));
+            if (Type.Type is null)
+                Type = NullType.Create(cx);
+
+            cx.Emit(Tuples.expressions(this, Kind, Type.Type.TypeRef));
             if (info.Parent.IsTopLevelParent)
                 cx.Emit(Tuples.expr_parent_top_level(this, info.Child, info.Parent));
             else
@@ -42,7 +45,7 @@ internal Expression(IExpressionInfo info)
             if (info.ExprValue is string value)
                 cx.Emit(Tuples.expr_value(this, value));
 
-            Type.ExtractGenerics();
+            Type.Type.ExtractGenerics();
         }
 
         public override Microsoft.CodeAnalysis.Location ReportingLocation => Location.symbol;
@@ -301,7 +304,7 @@ interface IExpressionInfo
         /// <summary>
         /// The type of the expression.
         /// </summary>
-        Type Type { get; }
+        AnnotatedType Type { get; }
 
         /// <summary>
         /// The location of the expression.
@@ -343,15 +346,15 @@ interface IExpressionInfo
     class ExpressionInfo : IExpressionInfo
     {
         public Context Context { get; }
-        public Type Type { get; }
+        public AnnotatedType Type { get; }
         public Extraction.Entities.Location Location { get; }
         public ExprKind Kind { get; }
         public IExpressionParentEntity Parent { get; }
         public int Child { get; }
         public bool IsCompilerGenerated { get; }
         public string ExprValue { get; }
 
-        public ExpressionInfo(Context cx, Type type, Extraction.Entities.Location location, ExprKind kind, IExpressionParentEntity parent, int child, bool isCompilerGenerated, string value)
+        public ExpressionInfo(Context cx, AnnotatedType type, Extraction.Entities.Location location, ExprKind kind, IExpressionParentEntity parent, int child, bool isCompilerGenerated, string value)
         {
             Context = cx;
             Type = type;
@@ -384,42 +387,37 @@ public ExpressionNodeInfo(Context cx, ExpressionSyntax node, IExpressionParentEn
             Conversion = cx.Model(node).GetConversion(node);
         }
 
-        public ExpressionNodeInfo(Context cx, ExpressionSyntax node, IExpressionParentEntity parent, int child, ITypeSymbol type) :
-            this(cx, node, parent, child)
-        {
-            Type = Type.Create(cx, type);
-        }
-
         public Context Context { get; }
         public ExpressionSyntax Node { get; private set; }
         public IExpressionParentEntity Parent { get; set; }
         public int Child { get; set; }
         public TypeInfo TypeInfo { get; }
         public Microsoft.CodeAnalysis.CSharp.Conversion Conversion { get; }
 
-        public ITypeSymbol ResolvedType => Context.DisambiguateType(TypeInfo.Type);
-        public ITypeSymbol ConvertedType => Context.DisambiguateType(TypeInfo.ConvertedType);
+        public AnnotatedTypeSymbol ResolvedType => new AnnotatedTypeSymbol(TypeInfo.Type.DisambiguateType(), TypeInfo.Nullability.Annotation);
+        public AnnotatedTypeSymbol ConvertedType => new AnnotatedTypeSymbol(TypeInfo.ConvertedType.DisambiguateType(), TypeInfo.ConvertedNullability.Annotation);
 
-        public ITypeSymbol ExpressionType
+        public AnnotatedTypeSymbol ExpressionType
         {
             get
             {
                 var type = ResolvedType;
 
-                if (type == null)
-                    type = Context.DisambiguateType(TypeInfo.Type ?? TypeInfo.ConvertedType);
+                if (type.Symbol == null)
+                    type.Symbol = (TypeInfo.Type ?? TypeInfo.ConvertedType).DisambiguateType();
 
                 // Roslyn workaround: It can't work out the type of "new object[0]"
                 // Clearly a bug.
-                if (type != null && type.TypeKind == Microsoft.CodeAnalysis.TypeKind.Error)
+                if (type.Symbol?.TypeKind == Microsoft.CodeAnalysis.TypeKind.Error)
                 {
                     var arrayCreation = Node as ArrayCreationExpressionSyntax;
                     if (arrayCreation != null)
                     {
                         var elementType = Context.GetType(arrayCreation.Type.ElementType);
 
-                        if (elementType != null)
-                            return Context.Compilation.CreateArrayTypeSymbol(elementType, arrayCreation.Type.RankSpecifiers.Count);
+                        if (elementType.Symbol != null)
+                            // There seems to be no way to create an array with a nullable element at present.
+                            return new AnnotatedTypeSymbol(Context.Compilation.CreateArrayTypeSymbol(elementType.Symbol, arrayCreation.Type.RankSpecifiers.Count), NullableAnnotation.NotAnnotated);
                     }
 
                     Context.ModelError(Node, "Failed to determine type");
@@ -456,14 +454,14 @@ public string ExprValue
             }
         }
 
-        Type cachedType;
+        AnnotatedType cachedType;
 
-        public Type Type
+        public AnnotatedType Type
         {
             get
             {
-                if (cachedType == null)
-                    cachedType = Type.Create(Context, ExpressionType);
+                if (cachedType.Type == null)
+                    cachedType = Entities.Type.Create(Context, ExpressionType);
                 return cachedType;
             }
             set
@@ -506,7 +504,7 @@ public ExpressionNodeInfo SetKind(ExprKind kind)
             return this;
         }
 
-        public ExpressionNodeInfo SetType(Type type)
+        public ExpressionNodeInfo SetType(AnnotatedType type)
         {
             Type = type;
             return this;

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Access.cs

@@ -46,7 +46,7 @@ static ExprKind AccessKind(Context cx, ISymbol symbol)
 
             if (implicitThis && !symbol.IsStatic)
             {
-                This.CreateImplicit(cx, Type.Create(cx, symbol.ContainingType), Location, this, -1);
+                This.CreateImplicit(cx, Entities.Type.Create(cx, symbol.ContainingType), Location, this, -1);
             }
         }
 

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ArrayCreation.cs

@@ -1,3 +1,4 @@
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Semmle.Extraction.Kinds;
 using System.Linq;
@@ -41,7 +42,7 @@ protected override void Populate()
 
                         var info = new ExpressionInfo(
                             cx,
-                            Type.Create(cx, cx.Compilation.GetSpecialType(Microsoft.CodeAnalysis.SpecialType.System_Int32)),
+                            new AnnotatedType(Entities.Type.Create(cx, cx.Compilation.GetSpecialType(Microsoft.CodeAnalysis.SpecialType.System_Int32)), Kinds.TypeAnnotation.NotAnnotated),
                             Location,
                             ExprKind.INT_LITERAL,
                             this,

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Assignment.cs

@@ -86,7 +86,7 @@ static ExprKind GetKind(Context cx, AssignmentExpressionSyntax syntax)
             var kind = GetAssignmentOperation(cx, syntax);
             var leftType = cx.GetType(syntax.Left);
 
-            if (leftType != null && leftType.SpecialType != SpecialType.None)
+            if (leftType.Symbol != null && leftType.Symbol.SpecialType != SpecialType.None)
             {
                 // In Mono, the builtin types did not specify their operator invocation
                 // even though EVERY operator has an invocation in C#. (This is a flaw in the dbscheme and should be fixed).

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Discard.cs

@@ -1,8 +1,8 @@
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Semmle.Extraction.Kinds;
-using Semmle.Extraction.Entities;
-using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Semmle.Extraction.Entities;
+using Semmle.Extraction.Kinds;
 
 namespace Semmle.Extraction.CSharp.Entities.Expressions
 {
@@ -13,7 +13,7 @@ public Discard(ExpressionNodeInfo info) : base(info.SetKind(ExprKind.DISCARD))
         }
 
         Discard(Context cx, CSharpSyntaxNode syntax, IExpressionParentEntity parent, int child) :
-            base(new ExpressionInfo(cx, Type.Create(cx, cx.Model(syntax).GetTypeInfo(syntax).Type), cx.Create(syntax.GetLocation()), ExprKind.DISCARD, parent, child, false, null))
+            base(new ExpressionInfo(cx, Entities.Type.Create(cx, cx.GetType(syntax)), cx.Create(syntax.GetLocation()), ExprKind.DISCARD, parent, child, false, null))
         {
         }
 

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ElementAccess.cs

@@ -55,17 +55,17 @@ static ExprKind GetKind(Context cx, ExpressionSyntax qualifier)
             var qualifierType = cx.GetType(qualifier);
 
             // This is a compilation error, so make a guess and continue.
-            if (qualifierType == null) return ExprKind.ARRAY_ACCESS;
+            if (qualifierType.Symbol == null) return ExprKind.ARRAY_ACCESS;
 
-            if (qualifierType.TypeKind == Microsoft.CodeAnalysis.TypeKind.Pointer)
+            if (qualifierType.Symbol.TypeKind == Microsoft.CodeAnalysis.TypeKind.Pointer)
             {
                 // Convert expressions of the form a[b] into *(a+b)
                 return ExprKind.POINTER_INDIRECTION;
             }
 
             return IsDynamic(cx, qualifier) ?
                 ExprKind.DYNAMIC_ELEMENT_ACCESS :
-                qualifierType.TypeKind == Microsoft.CodeAnalysis.TypeKind.Array ?
+                qualifierType.Symbol.TypeKind == Microsoft.CodeAnalysis.TypeKind.Array ?
                     ExprKind.ARRAY_ACCESS :
                     ExprKind.INDEXER_ACCESS;
         }

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ImplicitCast.cs

@@ -15,13 +15,13 @@ public Expression Expr
         }
 
         public ImplicitCast(ExpressionNodeInfo info)
-            : base(new ExpressionInfo(info.Context, Type.Create(info.Context, info.ConvertedType), info.Location, ExprKind.CAST, info.Parent, info.Child, true, info.ExprValue))
+            : base(new ExpressionInfo(info.Context, Entities.Type.Create(info.Context, info.ConvertedType), info.Location, ExprKind.CAST, info.Parent, info.Child, true, info.ExprValue))
         {
             Expr = Factory.Create(new ExpressionNodeInfo(cx, info.Node, this, 0));
         }
 
         public ImplicitCast(ExpressionNodeInfo info, IMethodSymbol method)
-            : base(new ExpressionInfo(info.Context, Type.Create(info.Context, info.ConvertedType), info.Location, ExprKind.OPERATOR_INVOCATION, info.Parent, info.Child, true, info.ExprValue) )
+            : base(new ExpressionInfo(info.Context, Entities.Type.Create(info.Context, info.ConvertedType), info.Location, ExprKind.OPERATOR_INVOCATION, info.Parent, info.Child, true, info.ExprValue) )
         {
             Expr = Factory.Create(info.SetParent(this, 0));
 
@@ -49,7 +49,7 @@ public static Expression Create(ExpressionNodeInfo info)
 
             if (conversion.MethodSymbol != null)
             {
-                bool convertedToDelegate = Type.IsDelegate(convertedType);
+                bool convertedToDelegate = Entities.Type.IsDelegate(convertedType.Symbol);
 
                 if (convertedToDelegate)
                 {
@@ -67,17 +67,17 @@ public static Expression Create(ExpressionNodeInfo info)
                     return Factory.Create(info);
                 }
 
-                if (resolvedType != null)
+                if (resolvedType.Symbol != null)
                     return new ImplicitCast(info, conversion.MethodSymbol);
             }
 
             bool implicitUpcast = conversion.IsImplicit &&
-                convertedType != null &&
+                convertedType.Symbol != null &&
                 !conversion.IsBoxing &&
                 (
-                    resolvedType == null ||
+                    resolvedType.Symbol == null ||
                     conversion.IsReference ||
-                    convertedType.SpecialType == SpecialType.System_Object)
+                    convertedType.Symbol.SpecialType == SpecialType.System_Object)
                 ;
 
             if (!conversion.IsIdentity && !implicitUpcast)