C#: Address review comments part 1.

calumgrant · calumgrant · commit 620ecc8128f3 · 2019-06-26T20:24:56.000+01:00
diff --git a/change-notes/1.22/analysis-csharp.md b/change-notes/1.22/analysis-csharp.md
@@ -16,7 +16,7 @@
 
 * 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 predicate `Callable.getAnnotatedReturnType()` and `DelegateType.getAnnotatedReturnType()` get the annotated type of the return value
+  - 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
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Constructor.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Constructor.cs
@@ -57,7 +57,7 @@ protected override void ExtractInitializers()
             }
 
             var initInfo = new ExpressionInfo(Context,
-                new AnnotatedType(initializerType, NullableAnnotation.NotAnnotated),
+                new AnnotatedType(initializerType, Kinds.TypeAnnotation.NotAnnotated),
                 Context.Create(initializer.ThisOrBaseKeyword.GetLocation()),
                 Kinds.ExprKind.CONSTRUCTOR_INIT,
                 this,
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ArrayCreation.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ArrayCreation.cs
@@ -42,7 +42,7 @@ protected override void Populate()
 
                         var info = new ExpressionInfo(
                             cx,
-                            new AnnotatedType(Entities.Type.Create(cx, cx.Compilation.GetSpecialType(Microsoft.CodeAnalysis.SpecialType.System_Int32)), NullableAnnotation.NotAnnotated),
+                            new AnnotatedType(Entities.Type.Create(cx, cx.Compilation.GetSpecialType(Microsoft.CodeAnalysis.SpecialType.System_Int32)), Kinds.TypeAnnotation.NotAnnotated),
                             Location,
                             ExprKind.INT_LITERAL,
                             this,
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Cast.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Cast.cs
@@ -20,7 +20,7 @@ protected override void Populate()
             {
                 // Type conversion
                 OperatorCall(Syntax);
-                TypeMention.Create(cx, Syntax.Type, this, Type.Type);
+                TypeMention.Create(cx, Syntax.Type, this, Type);
             }
         }
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ObjectCreation.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ObjectCreation.cs
@@ -73,7 +73,7 @@ protected override void Populate()
                 }
             }
 
-            TypeMention.Create(cx, Syntax.Type, this, Type.Type);
+            TypeMention.Create(cx, Syntax.Type, this, Type);
         }
 
         static SyntaxToken? GetDynamicName(CSharpSyntaxNode name)
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Query.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Query.cs
@@ -71,7 +71,7 @@ protected Expression DeclareRangeVariable(Context cx, IExpressionParentEntity pa
                 TypeSyntax declTypeSyntax = null;
                 if (getElement)
                 {
-                    if(node is FromClauseSyntax from && from.Type != null)
+                    if (node is FromClauseSyntax from && from.Type != null)
                     {
                         declTypeSyntax = from.Type;
                         declType = Type.Create(cx, cx.GetType(from.Type));
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/This.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/This.cs
@@ -8,7 +8,7 @@ class This : Expression
         This(IExpressionInfo info) : base(info) { }
 
         public static This CreateImplicit(Context cx, Type @class, Location loc, IExpressionParentEntity parent, int child) =>
-            new This(new ExpressionInfo(cx, new AnnotatedType(@class, Microsoft.CodeAnalysis.NullableAnnotation.NotAnnotated), loc, Kinds.ExprKind.THIS_ACCESS, parent, child, true, null));
+            new This(new ExpressionInfo(cx, new AnnotatedType(@class, Kinds.TypeAnnotation.NotAnnotated), loc, Kinds.ExprKind.THIS_ACCESS, parent, child, true, null));
 
         public static This CreateExplicit(ExpressionNodeInfo info) => new This(info.SetKind(ExprKind.THIS_ACCESS));
     }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/TypeAccess.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/TypeAccess.cs
@@ -17,17 +17,17 @@ protected override void Populate()
                     if (Type.Type.ContainingType == null)
                     {
                         // namespace qualifier
-                        TypeMention.Create(cx, maes.Name, this, Type.Type, Syntax.GetLocation());
+                        TypeMention.Create(cx, maes.Name, this, Type, Syntax.GetLocation());
                     }
                     else
                     {
                         // type qualifier
-                        TypeMention.Create(cx, maes.Name, this, Type.Type);
+                        TypeMention.Create(cx, maes.Name, this, Type);
                         Create(cx, maes.Expression, this, -1);
                     }
                     return;
                 default:
-                    TypeMention.Create(cx, (TypeSyntax)Syntax, this, Type.Type);
+                    TypeMention.Create(cx, (TypeSyntax)Syntax, this, Type);
                     return;
             }
         }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/VariableDeclaration.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/VariableDeclaration.cs
@@ -18,7 +18,7 @@ public static VariableDeclaration Create(Context cx, ISymbol symbol, AnnotatedTy
             {
                 LocalVariable.Create(cx, symbol, ret, isVar, declLocation);
                 if (optionalSyntax != null)
-                    TypeMention.Create(cx, optionalSyntax, parent, type.Type);
+                    TypeMention.Create(cx, optionalSyntax, parent, type);
             });
             return ret;
         }
@@ -135,7 +135,7 @@ public static VariableDeclaration Create(Context cx, CatchDeclarationSyntax d, b
                 var declSymbol = cx.Model(d).GetDeclaredSymbol(d);
                 var location = cx.Create(id.GetLocation());
                 LocalVariable.Create(cx, declSymbol, ret, isVar, location);
-                TypeMention.Create(cx, d.Type, ret, type.Type);
+                TypeMention.Create(cx, d.Type, ret, type);
             });
             return ret;
         }
@@ -161,7 +161,7 @@ public static VariableDeclaration CreateDeclarator(Context cx, VariableDeclarato
 
                 var decl = d.Parent as VariableDeclarationSyntax;
                 if (decl != null)
-                    TypeMention.Create(cx, decl.Type, ret, type.Type);
+                    TypeMention.Create(cx, decl.Type, ret, type);
             });
             return ret;
         }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Field.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Field.cs
@@ -82,7 +82,7 @@ public override void Populate()
                 foreach (var syntax in symbol.DeclaringSyntaxReferences.
                     Select(d => d.GetSyntax()).OfType<VariableDeclaratorSyntax>().
                     Select(d => d.Parent).OfType<VariableDeclarationSyntax>())
-                    TypeMention.Create(Context, syntax.Type, this, Type.Type);
+                    TypeMention.Create(Context, syntax.Type, this, Type);
         }
 
         readonly Lazy<AnnotatedType> type;
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Method.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Method.cs
@@ -122,13 +122,11 @@ protected static void BuildMethodId(Method m, ITrapBuilder tb)
                 else
                 {
                     tb.Append("<");
-                    tb.BuildList(",", m.symbol.TypeArguments, (ta, tb0) => AddSignatureTypeToId(m.Context, tb0, m.symbol, ta));
-
                     // Encode the nullability of the type arguments in the label.
                     // Type arguments with different nullability can result in 
                     // a constructed method with different nullability of its parameters and return type,
                     // so we need to create a distinct database entity for it.
-                    tb.BuildList("", m.symbol.TypeArgumentsNullableAnnotations, (a, tb1) => tb.Append((int)a));
+                    tb.BuildList(",", m.symbol.GetAnnotatedTypeArguments(), (ta, tb0) => { AddSignatureTypeToId(m.Context, tb0, m.symbol, ta.Symbol); tb.Append((int)ta.Nullability); });
                     tb.Append(">");
                 }
             }
@@ -345,8 +343,9 @@ protected void ExtractGenerics()
                     foreach (var tp in symbol.GetAnnotatedTypeArguments())
                     {
                         Context.Emit(Tuples.type_arguments(Type.Create(Context, tp.Symbol), child, this));
-                        if(tp.Nullability.NeedsExtraction())
-                            Context.Emit(Tuples.type_argument_annotation(this, child, (Kinds.TypeAnnotation)symbol.TypeArgumentsNullableAnnotations[child]));
+                        var ta = tp.Nullability.GetTypeAnnotation();
+                        if (ta != Kinds.TypeAnnotation.None)
+                            Context.Emit(Tuples.type_argument_annotation(this, child, ta));
                         child++;
                     }
                 }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Statements/ForEach.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Statements/ForEach.cs
@@ -29,7 +29,7 @@ protected override void Populate()
             if (typeSymbol.Name != "_")
                 Expressions.VariableDeclaration.Create(cx, typeSymbol, type, Stmt.Type, location, location, Stmt.Type.IsVar, this, 0);
             else
-                TypeMention.Create(cx, Stmt.Type, this, type.Type);
+                TypeMention.Create(cx, Stmt.Type, this, type);
 
             Statement.Create(cx, Stmt.Statement, this, 2);
         }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Symbol.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Symbol.cs
@@ -29,8 +29,9 @@ protected void ExtractAttributes()
 
         protected void ExtractNullability(NullableAnnotation annotation)
         {
-            if (annotation.NeedsExtraction())
-                Context.Emit(Tuples.type_annotation(this, (Kinds.TypeAnnotation)annotation));
+            var ta = annotation.GetTypeAnnotation();
+            if (ta != Kinds.TypeAnnotation.None)
+                Context.Emit(Tuples.type_annotation(this, ta));
         }
 
         protected void ExtractRefKind(RefKind kind)
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/TypeMention.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/TypeMention.cs
@@ -30,7 +30,7 @@ void Populate()
                     var ats = (ArrayTypeSyntax)Syntax;
                     var at = (ArrayType)Type;
                     Emit(Loc ?? Syntax.GetLocation(), Parent, Type);
-                    Create(cx, ats.ElementType, this, at.ElementType.Type);
+                    Create(cx, ats.ElementType, this, at.ElementType);
                     return;
                 case SyntaxKind.NullableType:
                     var nts = (NullableTypeSyntax)Syntax;
@@ -48,7 +48,7 @@ void Populate()
                     var tts = (TupleTypeSyntax)Syntax;
                     var tt = (TupleType)Type;
                     Emit(Loc ?? Syntax.GetLocation(), Parent, Type);
-                    tts.Elements.Zip(tt.TupleElements, (s, t) => Create(cx, s.Type, this, t.Type.Type)).Enumerate();
+                    tts.Elements.Zip(tt.TupleElements, (s, t) => Create(cx, s.Type, this, t.Type)).Enumerate();
                     return;
                 case SyntaxKind.PointerType:
                     var pts = (PointerTypeSyntax)Syntax;
@@ -94,6 +94,9 @@ public static TypeMention Create(Context cx, TypeSyntax syntax, IEntity parent,
             return ret;
         }
 
+        public static TypeMention Create(Context cx, TypeSyntax syntax, IEntity parent, AnnotatedType type, Microsoft.CodeAnalysis.Location loc = null) =>
+            Create(cx, syntax, parent, type.Type, loc);
+
         public override TrapStackBehaviour TrapStackBehaviour => TrapStackBehaviour.OptionalLabel;
     }
 }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs
@@ -56,7 +56,9 @@ public override void Populate()
 
                     for (int i = 0; i < symbol.TypeArguments.Length; ++i)
                     {
-                        Context.Emit(Tuples.type_argument_annotation(this, i, (Kinds.TypeAnnotation)symbol.TypeArgumentsNullableAnnotations[i]));
+                        var ta = symbol.TypeArgumentsNullableAnnotations[i].GetTypeAnnotation();
+                        if (ta != Kinds.TypeAnnotation.None)
+                            Context.Emit(Tuples.type_argument_annotation(this, i, ta));
                         Context.Emit(Tuples.type_arguments(TypeArguments[i].TypeRef, i, this));
                     }
                 }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NullType.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NullType.cs
@@ -23,7 +23,7 @@ public override bool Equals(object obj)
             return obj != null && obj.GetType() == typeof(NullType);
         }
 
-        public static AnnotatedType Create(Context cx) => new AnnotatedType(NullTypeFactory.Instance.CreateEntity(cx, null), NullableAnnotation.NotApplicable);
+        public static AnnotatedType Create(Context cx) => new AnnotatedType(NullTypeFactory.Instance.CreateEntity(cx, null), Kinds.TypeAnnotation.None);
 
         class NullTypeFactory : ICachedEntityFactory<ITypeSymbol, NullType>
         {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/Type.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/Type.cs
@@ -13,14 +13,14 @@ namespace Semmle.Extraction.CSharp.Entities
     /// </summary>
     public struct AnnotatedType
     {
-        public AnnotatedType(Type t, NullableAnnotation a)
+        public AnnotatedType(Type t, Kinds.TypeAnnotation a)
         {
             Type = t;
             Annotation = a;
         }
 
         public Type Type;
-        public NullableAnnotation Annotation;
+        public Kinds.TypeAnnotation Annotation;
     }
 
     public abstract class Type : CachedSymbol<ITypeSymbol>
@@ -291,7 +291,7 @@ public static Type Create(Context cx, ITypeSymbol type)
         }
 
         public static AnnotatedType Create(Context cx, AnnotatedTypeSymbol type) =>
-            new AnnotatedType(Create(cx, type.Symbol), type.Nullability);
+            new AnnotatedType(Create(cx, type.Symbol), type.Nullability.GetTypeAnnotation());
 
         public virtual int Dimension => 0;
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TypeParameter.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/TypeParameter.cs
@@ -50,8 +50,8 @@ public override void Populate()
                     baseType = abase.Symbol;
                 var t = Create(Context, abase.Symbol);
                 Context.Emit(Tuples.specific_type_parameter_constraints(constraints, t.TypeRef));
-                if (abase.Nullability.NeedsExtraction())
-                    Context.Emit(Tuples.specific_type_parameter_annotation(constraints, t.TypeRef, abase.Nullability));
+                if (abase.Nullability.GetTypeAnnotation() != Kinds.TypeAnnotation.None)
+                    Context.Emit(Tuples.specific_type_parameter_annotation(constraints, t.TypeRef, abase.Nullability.GetTypeAnnotation()));
             }
 
             Context.Emit(Tuples.types(this, Semmle.Extraction.Kinds.TypeKind.TYPE_PARAMETER, symbol.Name));
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Kinds/TypeAnnotation.cs b/csharp/extractor/Semmle.Extraction.CSharp/Kinds/TypeAnnotation.cs
@@ -1,13 +1,15 @@
-﻿namespace Semmle.Extraction.Kinds
+﻿using System;
+
+namespace Semmle.Extraction.Kinds
 {
-    enum TypeAnnotation
+    [Flags]
+    public enum TypeAnnotation
     {
-        NotApplicable,
-        Disabled,
-        NotAnnotated,
-        Annotated,
-        ReadonlyRef,
-        Ref,
-        Out
+        None = 0,
+        NotAnnotated = 4,
+        Annotated = 8,
+        ReadonlyRef = 16,
+        Ref = 32,
+        Out = 64
     }
 }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs b/csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs
@@ -227,13 +227,11 @@ static void BuildNamedTypeId(this INamedTypeSymbol named, Context cx, ITrapBuild
             {
                 subTermAction(cx, tb, named.ConstructedFrom);
                 tb.Append("<");
-                tb.BuildList(",", named.TypeArguments, (ta, tb0) => subTermAction(cx, tb0, ta));
-
                 // Encode the nullability of the type arguments in the label.
                 // Type arguments with different nullability can result in 
                 // a constructed type with different nullability of its members and methods,
                 // so we need to create a distinct database entity for it.
-                tb.BuildList("", named.TypeArgumentsNullableAnnotations, (a, tb1) => tb.Append((int)a));
+                tb.BuildList(",", named.GetAnnotatedTypeArguments(), (ta, tb0) => { subTermAction(cx, tb0, ta.Symbol); tb.Append((int)ta.Nullability); });
                 tb.Append(">");
             }
         }
@@ -492,7 +490,7 @@ public static AnnotatedTypeSymbol GetType(this Context cx, Microsoft.CodeAnalysi
         public static AnnotatedTypeSymbol GetAnnotatedType(this IPropertySymbol symbol) => new AnnotatedTypeSymbol(symbol.Type, symbol.NullableAnnotation);
 
         /// <summary>
-        /// Gets the annotated type of an ILocalSymbol.
+        /// 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);
@@ -504,11 +502,20 @@ public static AnnotatedTypeSymbol GetType(this Context cx, Microsoft.CodeAnalysi
         public static AnnotatedTypeSymbol GetAnnotatedReturnType(this IMethodSymbol symbol) => new AnnotatedTypeSymbol(symbol.ReturnType, symbol.ReturnNullableAnnotation);
 
         /// <summary>
-        /// Holds if the annotation should be extracted.
-        /// The "Disabled" and "NotApplicable" annotations can be inferred so
-        /// do not need to be stored in the database.
+        /// Gets the type annotation for a NullableAnnotation.
         /// </summary>
-        public static bool NeedsExtraction(this NullableAnnotation info) => info == NullableAnnotation.Annotated || info == NullableAnnotation.NotAnnotated;
+        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.
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Tuples.cs b/csharp/extractor/Semmle.Extraction.CSharp/Tuples.cs
@@ -192,7 +192,7 @@ public static Tuple metadata_handle(IEntity entity, Location assembly, int handl
 
         internal static Tuple specific_type_parameter_constraints(TypeParameterConstraints constraints, Type baseType) => new Tuple("specific_type_parameter_constraints", constraints, baseType);
 
-        internal static Tuple specific_type_parameter_annotation(TypeParameterConstraints constraints, Type baseType, Microsoft.CodeAnalysis.NullableAnnotation annotation) => new Tuple("specific_type_parameter_annotation", constraints, baseType, (int)annotation);
+        internal static Tuple specific_type_parameter_annotation(TypeParameterConstraints constraints, Type baseType, TypeAnnotation annotation) => new Tuple("specific_type_parameter_annotation", constraints, baseType, (int)annotation);
 
         internal static Tuple successors(IEntity from, IEntity to) => new Tuple("successors", from, to);
 
diff --git a/csharp/ql/src/semmle/code/csharp/AnnotatedType.qll b/csharp/ql/src/semmle/code/csharp/AnnotatedType.qll
@@ -147,21 +147,17 @@ private int getBitMask(int bit) {
 }
 
 private int getElementTypeFlags(@has_type_annotation element) {
-  result = sum(int b | type_annotation(element, b) | getBitMask(b))
+  result = sum(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) | getBitMask(b))
+  result = sum(int b | type_argument_annotation(generic, argument, b) | b)
 }
 
 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)
-    |
-      getBitMask(b)
-    )
+  result = sum(int b | specific_type_parameter_annotation(constraints, getTypeRef(type), b) | b)
 }
 
 private newtype TAnnotatedType =
diff --git a/csharp/upgrades/90fdbc8f87761f223ef7723e4b421c5b26ecc15e/type_annotation.ql b/csharp/upgrades/90fdbc8f87761f223ef7723e4b421c5b26ecc15e/type_annotation.ql
@@ -3,16 +3,16 @@ class Element extends @element {
 
   int getAnnotation() {
     exists(int mode | params(this, _, _, _, mode, _, _) |
-      mode = 1 and result = 5 // ref
+      mode = 1 and result = 32 // ref
       or
-      mode = 2 and result = 6 // out
+      mode = 2 and result = 64 // out
       or
-      mode = 5 and result = 4 // in
+      mode = 5 and result = 16 // in
     )
     or
-    ref_returns(this) and result = 5
+    ref_returns(this) and result = 32
     or
-    ref_readonly_returns(this) and result = 4
+    ref_readonly_returns(this) and result = 16
   }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ protected override void ExtractInitializers()`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`var initInfo = new ExpressionInfo(Context,`
`60`		`- new AnnotatedType(initializerType, NullableAnnotation.NotAnnotated),`
	`60`	`+ new AnnotatedType(initializerType, Kinds.TypeAnnotation.NotAnnotated),`
`61`	`61`	`Context.Create(initializer.ThisOrBaseKeyword.GetLocation()),`
`62`	`62`	`Kinds.ExprKind.CONSTRUCTOR_INIT,`
`63`	`63`	`this,`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ protected override void Populate()`
`20`	`20`	`{`
`21`	`21`	`// Type conversion`
`22`	`22`	`OperatorCall(Syntax);`
`23`		`- TypeMention.Create(cx, Syntax.Type, this, Type.Type);`
	`23`	`+ TypeMention.Create(cx, Syntax.Type, this, Type);`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ protected override void Populate()`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
`76`		`- TypeMention.Create(cx, Syntax.Type, this, Type.Type);`
	`76`	`+ TypeMention.Create(cx, Syntax.Type, this, Type);`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`static SyntaxToken? GetDynamicName(CSharpSyntaxNode name)`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ protected Expression DeclareRangeVariable(Context cx, IExpressionParentEntity pa`
`71`	`71`	`TypeSyntax declTypeSyntax = null;`
`72`	`72`	`if (getElement)`
`73`	`73`	`{`
`74`		`- if(node is FromClauseSyntax from && from.Type != null)`
	`74`	`+ if (node is FromClauseSyntax from && from.Type != null)`
`75`	`75`	`{`
`76`	`76`	`declTypeSyntax = from.Type;`
`77`	`77`	`declType = Type.Create(cx, cx.GetType(from.Type));`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ class This : Expression`
`8`	`8`	`This(IExpressionInfo info) : base(info) { }`
`9`	`9`
`10`	`10`	`public static This CreateImplicit(Context cx, Type @class, Location loc, IExpressionParentEntity parent, int child) =>`
`11`		`- new This(new ExpressionInfo(cx, new AnnotatedType(@class, Microsoft.CodeAnalysis.NullableAnnotation.NotAnnotated), loc, Kinds.ExprKind.THIS_ACCESS, parent, child, true, null));`
	`11`	`+ new This(new ExpressionInfo(cx, new AnnotatedType(@class, Kinds.TypeAnnotation.NotAnnotated), loc, Kinds.ExprKind.THIS_ACCESS, parent, child, true, null));`
`12`	`12`
`13`	`13`	`public static This CreateExplicit(ExpressionNodeInfo info) => new This(info.SetKind(ExprKind.THIS_ACCESS));`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,17 +17,17 @@ protected override void Populate()`
`17`	`17`	`if (Type.Type.ContainingType == null)`
`18`	`18`	`{`
`19`	`19`	`// namespace qualifier`
`20`		`- TypeMention.Create(cx, maes.Name, this, Type.Type, Syntax.GetLocation());`
	`20`	`+ TypeMention.Create(cx, maes.Name, this, Type, Syntax.GetLocation());`
`21`	`21`	`}`
`22`	`22`	`else`
`23`	`23`	`{`
`24`	`24`	`// type qualifier`
`25`		`- TypeMention.Create(cx, maes.Name, this, Type.Type);`
	`25`	`+ TypeMention.Create(cx, maes.Name, this, Type);`
`26`	`26`	`Create(cx, maes.Expression, this, -1);`
`27`	`27`	`}`
`28`	`28`	`return;`
`29`	`29`	`default:`
`30`		`- TypeMention.Create(cx, (TypeSyntax)Syntax, this, Type.Type);`
	`30`	`+ TypeMention.Create(cx, (TypeSyntax)Syntax, this, Type);`
`31`	`31`	`return;`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public static VariableDeclaration Create(Context cx, ISymbol symbol, AnnotatedTy`
`18`	`18`	`{`
`19`	`19`	`LocalVariable.Create(cx, symbol, ret, isVar, declLocation);`
`20`	`20`	`if (optionalSyntax != null)`
`21`		`- TypeMention.Create(cx, optionalSyntax, parent, type.Type);`
	`21`	`+ TypeMention.Create(cx, optionalSyntax, parent, type);`
`22`	`22`	`});`
`23`	`23`	`return ret;`
`24`	`24`	`}`
`@@ -135,7 +135,7 @@ public static VariableDeclaration Create(Context cx, CatchDeclarationSyntax d, b`
`135`	`135`	`var declSymbol = cx.Model(d).GetDeclaredSymbol(d);`
`136`	`136`	`var location = cx.Create(id.GetLocation());`
`137`	`137`	`LocalVariable.Create(cx, declSymbol, ret, isVar, location);`
`138`		`- TypeMention.Create(cx, d.Type, ret, type.Type);`
	`138`	`+ TypeMention.Create(cx, d.Type, ret, type);`
`139`	`139`	`});`
`140`	`140`	`return ret;`
`141`	`141`	`}`
`@@ -161,7 +161,7 @@ public static VariableDeclaration CreateDeclarator(Context cx, VariableDeclarato`
`161`	`161`
`162`	`162`	`var decl = d.Parent as VariableDeclarationSyntax;`
`163`	`163`	`if (decl != null)`
`164`		`- TypeMention.Create(cx, decl.Type, ret, type.Type);`
	`164`	`+ TypeMention.Create(cx, decl.Type, ret, type);`
`165`	`165`	`});`
`166`	`166`	`return ret;`
`167`	`167`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ public override void Populate()`
`82`	`82`	`foreach (var syntax in symbol.DeclaringSyntaxReferences.`
`83`	`83`	`Select(d => d.GetSyntax()).OfType<VariableDeclaratorSyntax>().`
`84`	`84`	`Select(d => d.Parent).OfType<VariableDeclarationSyntax>())`
`85`		`- TypeMention.Create(Context, syntax.Type, this, Type.Type);`
	`85`	`+ TypeMention.Create(Context, syntax.Type, this, Type);`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`readonly Lazy<AnnotatedType> type;`