Annotate more public syntax APIs (#44266)

Author: jcouv

src/Compilers/CSharp/Portable/Binder/Binder_Attributes.cs

@@ -666,7 +666,7 @@ private ImmutableArray<TypedConstant> GetRewrittenAttributeConstructorArguments(
                     }
                     else if (reorderedArgument.Kind == TypedConstantKind.Array &&
                         parameter.Type.TypeKind == TypeKind.Array &&
-                        !((TypeSymbol)reorderedArgument.TypeInternal).Equals(parameter.Type, TypeCompareKind.AllIgnoreOptions))
+                        !((TypeSymbol)reorderedArgument.TypeInternal!).Equals(parameter.Type, TypeCompareKind.AllIgnoreOptions))
                     {
                         // NOTE: As in dev11, we don't allow array covariance conversions (presumably, we don't have a way to
                         // represent the conversion in metadata).
@@ -922,6 +922,7 @@ private static bool TryGetNormalParamValue(ParameterSymbol parameter, ImmutableA
             }
 
             HashSet<DiagnosticInfo>? useSiteDiagnostics = null; // ignoring, since already bound argument and parameter
+            Debug.Assert(argument.TypeInternal is object);
             Conversion conversion = conversions.ClassifyBuiltInConversion((TypeSymbol)argument.TypeInternal, parameter.Type, ref useSiteDiagnostics);
 
             // NOTE: Won't always succeed, even though we've performed overload resolution.

src/Compilers/CSharp/Portable/Symbols/Attributes/AttributeData.cs

@@ -370,8 +370,8 @@ private DeclarativeSecurityAction DecodeSecurityAttributeAction(Symbol targetSym
             else
             {
                 TypedConstant firstArg = ctorArgs.First();
-                TypeSymbol firstArgType = (TypeSymbol)firstArg.TypeInternal;
-                if ((object)firstArgType != null && firstArgType.Equals(compilation.GetWellKnownType(WellKnownType.System_Security_Permissions_SecurityAction)))
+                var firstArgType = (TypeSymbol?)firstArg.TypeInternal;
+                if (firstArgType is object && firstArgType.Equals(compilation.GetWellKnownType(WellKnownType.System_Security_Permissions_SecurityAction)))
                 {
                     return DecodeSecurityAction(firstArg, targetSymbol, nodeOpt, diagnostics, out hasErrors);
                 }
@@ -387,6 +387,7 @@ private DeclarativeSecurityAction DecodeSecurityAction(TypedConstant typedValue,
         {
             Debug.Assert((object)targetSymbol != null);
             Debug.Assert(targetSymbol.Kind == SymbolKind.Assembly || targetSymbol.Kind == SymbolKind.NamedType || targetSymbol.Kind == SymbolKind.Method);
+            Debug.Assert(typedValue.ValueInternal is object);
 
             int securityAction = (int)typedValue.ValueInternal;
             bool isPermissionRequestAction;
@@ -527,15 +528,15 @@ private static Location GetSecurityAttributeActionSyntaxLocation(AttributeSyntax
                     PermissionSetAttributeTypeHasRequiredProperty(attrType, filePropName))
                 {
                     // resolve file prop path
-                    var fileName = (string)namedArg.Value.ValueInternal;
+                    var fileName = (string?)namedArg.Value.ValueInternal;
                     var resolver = compilation.Options.XmlReferenceResolver;
 
-                    resolvedFilePath = (resolver != null) ? resolver.ResolveReference(fileName, baseFilePath: null) : null;
+                    resolvedFilePath = (resolver != null && fileName != null) ? resolver.ResolveReference(fileName, baseFilePath: null) : null;
 
                     if (resolvedFilePath == null)
                     {
                         // CS7053: Unable to resolve file path '{0}' specified for the named argument '{1}' for PermissionSet attribute
-                        Location argSyntaxLocation = nodeOpt != null ? nodeOpt.GetNamedArgumentSyntax(filePropName).Location : NoLocation.Singleton;
+                        Location argSyntaxLocation = nodeOpt?.GetNamedArgumentSyntax(filePropName)?.Location ?? NoLocation.Singleton;
                         diagnostics.Add(ErrorCode.ERR_PermissionSetAttributeInvalidFile, argSyntaxLocation, fileName ?? "<null>", filePropName);
                     }
                     else if (!PermissionSetAttributeTypeHasRequiredProperty(attrType, hexPropName))
@@ -629,7 +630,7 @@ internal string DecodeGuidAttribute(AttributeSyntax? nodeOpt, DiagnosticBag diag
         {
             Debug.Assert(!this.HasErrors);
 
-            var guidString = (string)this.CommonConstructorArguments[0].ValueInternal;
+            var guidString = (string?)this.CommonConstructorArguments[0].ValueInternal;
 
             // Native compiler allows only a specific GUID format: "D" format (32 digits separated by hyphens)
             Guid guid;
@@ -641,7 +642,7 @@ internal string DecodeGuidAttribute(AttributeSyntax? nodeOpt, DiagnosticBag diag
                 guidString = String.Empty;
             }
 
-            return guidString;
+            return guidString!;
         }
 
         private protected sealed override bool IsStringProperty(string memberName)

src/Compilers/CSharp/Portable/Symbols/TypedConstantExtensions.cs

@@ -2,18 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
+#nullable enable
+
 using System.Diagnostics;
 using System.Linq;
 using System.Text;
-using Microsoft.CodeAnalysis.Collections;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.PooledObjects;
-using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -35,8 +29,9 @@ public static string ToCSharpString(this TypedConstant constant)
                 return "{" + string.Join(", ", constant.Values.Select(v => v.ToCSharpString())) + "}";
             }
 
-            if (constant.Kind == TypedConstantKind.Type || constant.TypeInternal.SpecialType == SpecialType.System_Object)
+            if (constant.Kind == TypedConstantKind.Type || constant.TypeInternal!.SpecialType == SpecialType.System_Object)
             {
+                Debug.Assert(constant.Value is object);
                 return "typeof(" + constant.Value.ToString() + ")";
             }
 
@@ -46,6 +41,7 @@ public static string ToCSharpString(this TypedConstant constant)
                 return DisplayEnumConstant(constant);
             }
 
+            Debug.Assert(constant.ValueInternal is object);
             return SymbolDisplay.FormatPrimitive(constant.ValueInternal, quoteStrings: true, useHexadecimalNumbers: false);
         }
 
@@ -55,7 +51,8 @@ private static string DisplayEnumConstant(TypedConstant constant)
             Debug.Assert(constant.Kind == TypedConstantKind.Enum);
 
             // Create a ConstantValue of enum underlying type
-            SpecialType splType = ((INamedTypeSymbol)constant.Type).EnumUnderlyingType.SpecialType;
+            SpecialType splType = ((INamedTypeSymbol)constant.Type!).EnumUnderlyingType!.SpecialType;
+            Debug.Assert(constant.ValueInternal is object);
             ConstantValue valueConstant = ConstantValue.Create(constant.ValueInternal, splType);
 
             string typeName = constant.Type.ToDisplayString(SymbolDisplayFormat.QualifiedNameOnlyFormat);
@@ -71,25 +68,27 @@ private static string DisplayEnumConstant(TypedConstant constant)
 
         private static string DisplayUnsignedEnumConstant(TypedConstant constant, SpecialType specialType, ulong constantToDecode, string typeName)
         {
+            Debug.Assert(constant.Kind == TypedConstantKind.Enum);
+
             // Specified valueConstant might have an exact matching enum field
             // or it might be a bitwise Or of multiple enum fields.
             // For the later case, we keep track of the current value of
             // bitwise Or of possible enum fields.
             ulong curValue = 0;
 
             // Initialize the value string to empty
-            PooledStringBuilder pooledBuilder = null;
-            StringBuilder valueStringBuilder = null;
+            PooledStringBuilder? pooledBuilder = null;
+            StringBuilder? valueStringBuilder = null;
 
             // Iterate through all the constant members in the enum type
-            var members = constant.Type.GetMembers();
+            var members = constant.Type!.GetMembers();
             foreach (var member in members)
             {
                 var field = member as IFieldSymbol;
 
-                if ((object)field != null && field.HasConstantValue)
+                if (field is object && field.HasConstantValue)
                 {
-                    ConstantValue memberConstant = ConstantValue.Create(field.ConstantValue, specialType);
+                    ConstantValue memberConstant = ConstantValue.Create(field.ConstantValue!, specialType); // use MemberNotNull when available https://github.com/dotnet/roslyn/issues/41964
                     ulong memberValue = memberConstant.UInt64Value;
 
                     // Do we have an exact matching enum field
@@ -140,29 +139,34 @@ private static string DisplayUnsignedEnumConstant(TypedConstant constant, Specia
             }
 
             // Unable to decode the enum constant, just display the integral value
-            return constant.ValueInternal.ToString();
+            Debug.Assert(constant.ValueInternal is object);
+            var result = constant.ValueInternal.ToString();
+            Debug.Assert(result is object);
+            return result;
         }
 
         private static string DisplaySignedEnumConstant(TypedConstant constant, SpecialType specialType, long constantToDecode, string typeName)
         {
+            Debug.Assert(constant.Kind == TypedConstantKind.Enum);
+
             // Specified valueConstant might have an exact matching enum field
             // or it might be a bitwise Or of multiple enum fields.
             // For the later case, we keep track of the current value of
             // bitwise Or of possible enum fields.
             long curValue = 0;
 
             // Initialize the value string to empty
-            PooledStringBuilder pooledBuilder = null;
-            StringBuilder valueStringBuilder = null;
+            PooledStringBuilder? pooledBuilder = null;
+            StringBuilder? valueStringBuilder = null;
 
             // Iterate through all the constant members in the enum type
-            var members = constant.Type.GetMembers();
+            var members = constant.Type!.GetMembers();
             foreach (var member in members)
             {
                 var field = member as IFieldSymbol;
-                if ((object)field != null && field.HasConstantValue)
+                if (field is object && field.HasConstantValue)
                 {
-                    ConstantValue memberConstant = ConstantValue.Create(field.ConstantValue, specialType);
+                    ConstantValue memberConstant = ConstantValue.Create(field.ConstantValue!, specialType); // use MemberNotNull when available https://github.com/dotnet/roslyn/issues/41964 
                     long memberValue = memberConstant.Int64Value;
 
                     // Do we have an exact matching enum field
@@ -213,7 +217,10 @@ private static string DisplaySignedEnumConstant(TypedConstant constant, SpecialT
             }
 
             // Unable to decode the enum constant, just display the integral value
-            return constant.ValueInternal.ToString();
+            Debug.Assert(constant.ValueInternal is object);
+            var result = constant.ValueInternal.ToString();
+            Debug.Assert(result is object);
+            return result;
         }
     }
 }

src/Compilers/CSharp/Portable/Syntax/AliasedQualifiedNameSyntax.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#nullable enable
+
 namespace Microsoft.CodeAnalysis.CSharp.Syntax
 {
     public sealed partial class AliasQualifiedNameSyntax : NameSyntax

src/Compilers/CSharp/Portable/Syntax/AnonymousFunctionExpressionSyntax.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#nullable enable
+
 namespace Microsoft.CodeAnalysis.CSharp.Syntax
 {
     public partial class AnonymousFunctionExpressionSyntax
@@ -10,7 +12,7 @@ public partial class AnonymousFunctionExpressionSyntax
         /// Either the <see cref="Block"/> if it is not <c>null</c> or the
         /// <see cref="ExpressionBody"/> otherwise.
         /// </summary>
-        public CSharpSyntaxNode Body => Block ?? (CSharpSyntaxNode)ExpressionBody;
+        public CSharpSyntaxNode Body => Block ?? (CSharpSyntaxNode)ExpressionBody!;
 
         public AnonymousFunctionExpressionSyntax WithBody(CSharpSyntaxNode body)
             => body is BlockSyntax block

src/Compilers/CSharp/Portable/Syntax/ArgumentSyntax.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#nullable enable
+
 using System.ComponentModel;
 
 namespace Microsoft.CodeAnalysis.CSharp.Syntax

src/Compilers/CSharp/Portable/Syntax/ArrayRankSpecifierSyntax.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#nullable enable
+
 namespace Microsoft.CodeAnalysis.CSharp.Syntax
 {
     public partial class ArrayRankSpecifierSyntax

src/Compilers/CSharp/Portable/Syntax/AttributeSyntax.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#nullable enable
+
 using System;
 using System.Diagnostics;
 
@@ -20,7 +22,7 @@ internal string GetErrorDisplayName()
             return Name.ErrorDisplayName();
         }
 
-        internal AttributeArgumentSyntax GetNamedArgumentSyntax(string namedArgName)
+        internal AttributeArgumentSyntax? GetNamedArgumentSyntax(string namedArgName)
         {
             Debug.Assert(!String.IsNullOrEmpty(namedArgName));
 

src/Compilers/CSharp/Portable/Syntax/AttributeTargetSpecifierSyntax.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#nullable enable
+
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Text;

src/Compilers/CSharp/Portable/Syntax/BlockSyntax.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#nullable enable
+
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Microsoft.CodeAnalysis.CSharp.Syntax