Merge pull request #58338 from dotnet/features/param-nullchecking

Merge param-nullchecking to main

Author: RikkiGibson

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

@@ -32,6 +32,7 @@ public QueryUnboundLambdaState(Binder binder, RangeVariableMap rangeVariableMap,
 
             public override string ParameterName(int index) { return _parameters[index].Name; }
             public override bool ParameterIsDiscard(int index) { return false; }
+            public override bool ParameterIsNullChecked(int index) { return false; }
             public override SyntaxList<AttributeListSyntax> ParameterAttributes(int index) => default;
             public override bool HasNames { get { return true; } }
             public override bool HasSignature { get { return true; } }

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

@@ -40,6 +40,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
 
             ImmutableArray<string> names = default;
             ImmutableArray<RefKind> refKinds = default;
+            ImmutableArray<bool> nullCheckedOpt = default;
             ImmutableArray<TypeWithAnnotations> types = default;
             RefKind returnRefKind = RefKind.None;
             TypeWithAnnotations returnType = default;
@@ -63,6 +64,10 @@ private UnboundLambda AnalyzeAnonymousFunction(
                     hasSignature = true;
                     var simple = (SimpleLambdaExpressionSyntax)syntax;
                     namesBuilder.Add(simple.Parameter.Identifier.ValueText);
+                    if (isNullChecked(simple.Parameter))
+                    {
+                        nullCheckedOpt = ImmutableArray.Create(true);
+                    }
                     break;
                 case SyntaxKind.ParenthesizedLambdaExpression:
                     // (T x, U y) => ...
@@ -98,6 +103,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
 
                 var typesBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance();
                 var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance();
+                var nullCheckedBuilder = ArrayBuilder<bool>.GetInstance();
                 var attributesBuilder = ArrayBuilder<SyntaxList<AttributeListSyntax>>.GetInstance();
 
                 // In the batch compiler case we probably should have given a syntax error if the
@@ -176,6 +182,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
                     namesBuilder.Add(p.Identifier.ValueText);
                     typesBuilder.Add(type);
                     refKindsBuilder.Add(refKind);
+                    nullCheckedBuilder.Add(isNullChecked(p));
                     attributesBuilder.Add(syntax.Kind() == SyntaxKind.ParenthesizedLambdaExpression ? p.AttributeLists : default);
                 }
 
@@ -191,13 +198,19 @@ private UnboundLambda AnalyzeAnonymousFunction(
                     refKinds = refKindsBuilder.ToImmutable();
                 }
 
+                if (nullCheckedBuilder.Contains(true))
+                {
+                    nullCheckedOpt = nullCheckedBuilder.ToImmutable();
+                }
+
                 if (attributesBuilder.Any(a => a.Count > 0))
                 {
                     parameterAttributes = attributesBuilder.ToImmutable();
                 }
 
                 typesBuilder.Free();
                 refKindsBuilder.Free();
+                nullCheckedBuilder.Free();
                 attributesBuilder.Free();
             }
 
@@ -208,7 +221,10 @@ private UnboundLambda AnalyzeAnonymousFunction(
 
             namesBuilder.Free();
 
-            return UnboundLambda.Create(syntax, this, diagnostics.AccumulatesDependencies, returnRefKind, returnType, parameterAttributes, refKinds, types, names, discardsOpt, isAsync, isStatic);
+            return UnboundLambda.Create(syntax, this, diagnostics.AccumulatesDependencies, returnRefKind, returnType, parameterAttributes, refKinds, types, names, discardsOpt, nullCheckedOpt, isAsync, isStatic);
+
+            static bool isNullChecked(ParameterSyntax parameter)
+                => parameter.ExclamationExclamationToken.IsKind(SyntaxKind.ExclamationExclamationToken);
 
             static ImmutableArray<bool> computeDiscards(SeparatedSyntaxList<ParameterSyntax> parameters, int underscoresCount)
             {

src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs

@@ -383,6 +383,7 @@ public static UnboundLambda Create(
             ImmutableArray<TypeWithAnnotations> types,
             ImmutableArray<string> names,
             ImmutableArray<bool> discardsOpt,
+            ImmutableArray<bool> nullCheckedOpt,
             bool isAsync,
             bool isStatic)
         {
@@ -391,7 +392,7 @@ public static UnboundLambda Create(
             bool hasErrors = !types.IsDefault && types.Any(t => t.Type?.Kind == SymbolKind.ErrorType);
 
             var functionType = FunctionTypeSymbol.CreateIfFeatureEnabled(syntax, binder, static (binder, expr) => ((UnboundLambda)expr).Data.InferDelegateType());
-            var data = new PlainUnboundLambdaState(binder, returnRefKind, returnType, parameterAttributes, names, discardsOpt, types, refKinds, isAsync, isStatic, includeCache: true);
+            var data = new PlainUnboundLambdaState(binder, returnRefKind, returnType, parameterAttributes, names, discardsOpt, nullCheckedOpt, types, refKinds, isAsync, isStatic, includeCache: true);
             var lambda = new UnboundLambda(syntax, data, functionType, withDependencies, hasErrors: hasErrors);
             data.SetUnboundLambda(lambda);
             functionType?.SetExpression(lambda.WithNoCache());
@@ -458,6 +459,7 @@ public TypeWithAnnotations InferReturnType(ConversionsBase conversions, NamedTyp
         public Location ParameterLocation(int index) { return Data.ParameterLocation(index); }
         public string ParameterName(int index) { return Data.ParameterName(index); }
         public bool ParameterIsDiscard(int index) { return Data.ParameterIsDiscard(index); }
+        public bool ParameterIsNullChecked(int index) { return Data.ParameterIsNullChecked(index); }
     }
 
     internal abstract class UnboundLambdaState
@@ -517,6 +519,7 @@ internal UnboundLambdaState WithCaching(bool includeCache)
         public abstract MessageID MessageID { get; }
         public abstract string ParameterName(int index);
         public abstract bool ParameterIsDiscard(int index);
+        public abstract bool ParameterIsNullChecked(int index);
         public abstract SyntaxList<AttributeListSyntax> ParameterAttributes(int index);
         public abstract bool HasSignature { get; }
         public abstract bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType);
@@ -1321,6 +1324,7 @@ internal sealed class PlainUnboundLambdaState : UnboundLambdaState
         private readonly ImmutableArray<SyntaxList<AttributeListSyntax>> _parameterAttributes;
         private readonly ImmutableArray<string> _parameterNames;
         private readonly ImmutableArray<bool> _parameterIsDiscardOpt;
+        private readonly ImmutableArray<bool> _parameterIsNullCheckedOpt;
         private readonly ImmutableArray<TypeWithAnnotations> _parameterTypesWithAnnotations;
         private readonly ImmutableArray<RefKind> _parameterRefKinds;
         private readonly bool _isAsync;
@@ -1333,6 +1337,7 @@ internal PlainUnboundLambdaState(
             ImmutableArray<SyntaxList<AttributeListSyntax>> parameterAttributes,
             ImmutableArray<string> parameterNames,
             ImmutableArray<bool> parameterIsDiscardOpt,
+            ImmutableArray<bool> parameterIsNullCheckedOpt,
             ImmutableArray<TypeWithAnnotations> parameterTypesWithAnnotations,
             ImmutableArray<RefKind> parameterRefKinds,
             bool isAsync,
@@ -1345,6 +1350,7 @@ internal PlainUnboundLambdaState(
             _parameterAttributes = parameterAttributes;
             _parameterNames = parameterNames;
             _parameterIsDiscardOpt = parameterIsDiscardOpt;
+            _parameterIsNullCheckedOpt = parameterIsNullCheckedOpt;
             _parameterTypesWithAnnotations = parameterTypesWithAnnotations;
             _parameterRefKinds = parameterRefKinds;
             _isAsync = isAsync;
@@ -1414,6 +1420,11 @@ public override bool ParameterIsDiscard(int index)
             return _parameterIsDiscardOpt.IsDefault ? false : _parameterIsDiscardOpt[index];
         }
 
+        public override bool ParameterIsNullChecked(int index)
+        {
+            return _parameterIsNullCheckedOpt.IsDefault ? false : _parameterIsNullCheckedOpt[index];
+        }
+
         public override RefKind RefKind(int index)
         {
             Debug.Assert(0 <= index && index < _parameterTypesWithAnnotations.Length);
@@ -1429,7 +1440,7 @@ public override TypeWithAnnotations ParameterTypeWithAnnotations(int index)
 
         protected override UnboundLambdaState WithCachingCore(bool includeCache)
         {
-            return new PlainUnboundLambdaState(Binder, _returnRefKind, _returnType, _parameterAttributes, _parameterNames, _parameterIsDiscardOpt, _parameterTypesWithAnnotations, _parameterRefKinds, _isAsync, _isStatic, includeCache);
+            return new PlainUnboundLambdaState(Binder, _returnRefKind, _returnType, _parameterAttributes, _parameterNames, _parameterIsDiscardOpt, _parameterIsNullCheckedOpt, _parameterTypesWithAnnotations, _parameterRefKinds, _isAsync, _isStatic, includeCache);
         }
 
         protected override BoundExpression? GetLambdaExpressionBody(BoundBlock body)

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -363,6 +363,9 @@
   <data name="IDS_FeatureTypeVariance" xml:space="preserve">
     <value>type variance</value>
   </data>
+  <data name="IDS_ParameterNullChecking" xml:space="preserve">
+    <value>parameter null-checking</value>
+  </data>
   <data name="IDS_Parameter" xml:space="preserve">
     <value>parameter</value>
   </data>
@@ -6166,6 +6169,30 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_DuplicateNullSuppression" xml:space="preserve">
     <value>Duplicate null suppression operator ('!')</value>
   </data>
+  <data name="ERR_IncorrectNullCheckSyntax" xml:space="preserve">
+    <value>Incorrect parameter null checking syntax. Should be '!!'.</value>
+  </data>
+  <data name="ERR_MustNullCheckInImplementation" xml:space="preserve">
+    <value>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</value>
+  </data>
+  <data name="ERR_NonNullableValueTypeIsNullChecked" xml:space="preserve">
+    <value>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</value>
+  </data>
+  <data name="WRN_NullCheckedHasDefaultNull" xml:space="preserve">
+    <value>Parameter '{0}' is null-checked but is null by default.</value>
+  </data>
+  <data name="WRN_NullCheckedHasDefaultNull_Title" xml:space="preserve">
+    <value>Parameter is null-checked but is null by default.</value>
+  </data>
+  <data name="ERR_NullCheckingOnByRefParameter" xml:space="preserve">
+    <value>By-reference parameter '{0}' cannot be null-checked.</value>
+  </data>
+  <data name="WRN_NullCheckingOnNullableType" xml:space="preserve">
+    <value>Nullable type '{0}' is null-checked and will throw if null.</value>
+  </data>
+  <data name="WRN_NullCheckingOnNullableType_Title" xml:space="preserve">
+    <value>Nullable type is null-checked and will throw if null.</value>
+  </data>
   <data name="ERR_ReAbstractionInNoPIAType" xml:space="preserve">
     <value>Type '{0}' cannot be embedded because it has a re-abstraction of a member from base interface. Consider setting the 'Embed Interop Types' property to false.</value>
   </data>

src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs

@@ -1211,7 +1211,7 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
 
                     hasErrors = hasErrors || (hasBody && loweredBodyOpt.HasErrors) || diagsForCurrentMethod.HasAnyErrors();
                     SetGlobalErrorIfTrue(hasErrors);
-
+                    CSharpSyntaxNode syntax = methodSymbol.GetNonNullSyntaxNode();
                     // don't emit if the resulting method would contain initializers with errors
                     if (!hasErrors && (hasBody || includeNonEmptyInitializersInBody))
                     {
@@ -1290,12 +1290,29 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
                             {
                                 boundStatements = boundStatements.Concat(ImmutableArray.Create(loweredBodyOpt));
                             }
-                        }
 
+                            var factory = new SyntheticBoundNodeFactory(methodSymbol, syntax, compilationState, diagsForCurrentMethod);
+
+                            // Iterators handled in IteratorRewriter.cs
+                            if (!methodSymbol.IsIterator)
+                            {
+                                var boundStatementsWithNullCheck = LocalRewriter.TryConstructNullCheckedStatementList(methodSymbol.Parameters, boundStatements, factory);
+
+                                if (!boundStatementsWithNullCheck.IsDefault)
+                                {
+                                    boundStatements = boundStatementsWithNullCheck;
+                                    hasErrors = boundStatementsWithNullCheck.HasErrors() || diagsForCurrentMethod.HasAnyErrors();
+                                    SetGlobalErrorIfTrue(hasErrors);
+                                    if (hasErrors)
+                                    {
+                                        _diagnostics.AddRange(diagsForCurrentMethod);
+                                        return;
+                                    }
+                                }
+                            }
+                        }
                         if (_emitMethodBodies && (!(methodSymbol is SynthesizedStaticConstructor cctor) || cctor.ShouldEmit(processedInitializers.BoundInitializers)))
                         {
-                            CSharpSyntaxNode syntax = methodSymbol.GetNonNullSyntaxNode();
-
                             var boundBody = BoundStatementList.Synthesized(syntax, boundStatements);
 
                             var emittedBody = GenerateMethodBody(

src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs

@@ -1289,18 +1289,19 @@ internal Cci.IMethodReference Translate(
             }
         }
 
+#nullable enable
         private Cci.IMethodReference Translate(
             MethodSymbol methodSymbol,
             SyntaxNode syntaxNodeOpt,
             DiagnosticBag diagnostics,
             bool needDeclaration)
         {
-            object reference;
+            object? reference;
             Cci.IMethodReference methodRef;
             NamedTypeSymbol container = methodSymbol.ContainingType;
 
             // Method of anonymous type being translated
-            if (container.IsAnonymousType)
+            if (container?.IsAnonymousType == true)
             {
                 Debug.Assert(!needDeclaration);
                 methodSymbol = AnonymousTypeManager.TranslateAnonymousTypeMethodSymbol(methodSymbol);
@@ -1363,6 +1364,7 @@ private Cci.IMethodReference Translate(
 
             return methodSymbol.GetCciAdapter();
         }
+#nullable disable
 
         internal Cci.IMethodReference TranslateOverriddenMethodReference(
             MethodSymbol methodSymbol,
@@ -1777,6 +1779,39 @@ internal void EnsureNativeIntegerAttributeExists()
             EnsureEmbeddableAttributeExists(EmbeddableAttributes.NativeIntegerAttribute);
         }
 
+#nullable enable
+        /// <summary>
+        /// Creates the ThrowIfNull and Throw helpers if needed.
+        /// </summary>
+        /// <remarks>
+        /// The ThrowIfNull and Throw helpers are modeled off of the helpers on ArgumentNullException.
+        /// https://github.com/dotnet/runtime/blob/22663769611ba89cd92d14cfcb76e287f8af2335/src/libraries/System.Private.CoreLib/src/System/ArgumentNullException.cs#L56-L69
+        /// </remarks>
+        internal MethodSymbol EnsureThrowIfNullFunctionExists(SyntaxNode syntaxNode, SyntheticBoundNodeFactory factory, DiagnosticBag? diagnostics)
+        {
+            var privateImplClass = GetPrivateImplClass(syntaxNode, diagnostics);
+            var throwIfNullAdapter = privateImplClass.GetMethod(PrivateImplementationDetails.SynthesizedThrowIfNullFunctionName);
+            if (throwIfNullAdapter is null)
+            {
+                TypeSymbol returnType = factory.SpecialType(SpecialType.System_Void);
+                TypeSymbol argumentType = factory.SpecialType(SpecialType.System_Object);
+                TypeSymbol paramNameType = factory.SpecialType(SpecialType.System_String);
+                var sourceModule = SourceModule;
+
+                // use add-then-get pattern to ensure the symbol exists, and then ensure we use the single "canonical" instance added by whichever thread won the race.
+                privateImplClass.TryAddSynthesizedMethod(new SynthesizedThrowMethod(sourceModule, privateImplClass, returnType, paramNameType).GetCciAdapter());
+                var actuallyAddedThrowMethod = (SynthesizedThrowMethod)privateImplClass.GetMethod(PrivateImplementationDetails.SynthesizedThrowFunctionName)!.GetInternalSymbol()!;
+                privateImplClass.TryAddSynthesizedMethod(new SynthesizedThrowIfNullMethod(sourceModule, privateImplClass, actuallyAddedThrowMethod, returnType, argumentType, paramNameType).GetCciAdapter());
+                throwIfNullAdapter = privateImplClass.GetMethod(PrivateImplementationDetails.SynthesizedThrowIfNullFunctionName)!;
+            }
+
+            var internalSymbol = (SynthesizedThrowIfNullMethod)throwIfNullAdapter.GetInternalSymbol()!;
+            // the ThrowMethod referenced by the ThrowIfNullMethod must be the same instance as the ThrowMethod contained in the PrivateImplementationDetails
+            Debug.Assert((object?)privateImplClass.GetMethod(PrivateImplementationDetails.SynthesizedThrowFunctionName)!.GetInternalSymbol() == internalSymbol.ThrowMethod);
+            return internalSymbol;
+        }
+#nullable disable
+
         public override IEnumerable<Cci.INamespaceTypeDefinition> GetAdditionalTopLevelTypeDefinitions(EmitContext context)
         {
             return GetAdditionalTopLevelTypes()

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -2007,6 +2007,13 @@ internal enum ErrorCode
         // at runtime.
         ERR_CannotUseRefInUnmanagedCallersOnly = 8977,
 
+        ERR_IncorrectNullCheckSyntax = 8990,
+        ERR_MustNullCheckInImplementation = 8991,
+        ERR_NonNullableValueTypeIsNullChecked = 8992,
+        WRN_NullCheckedHasDefaultNull = 8993,
+        ERR_NullCheckingOnByRefParameter = 8994,
+        WRN_NullCheckingOnNullableType = 8995,
+
         #endregion
 
         #region diagnostics introduced for C# 11.0

src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs

@@ -455,6 +455,8 @@ internal static int GetWarningLevel(ErrorCode code)
                 case ErrorCode.WRN_UndecoratedCancellationTokenParameter:
                 case ErrorCode.WRN_NullabilityMismatchInTypeParameterNotNullConstraint:
                 case ErrorCode.WRN_DisallowNullAttributeForbidsMaybeNullAssignment:
+                case ErrorCode.WRN_NullCheckedHasDefaultNull:
+                case ErrorCode.WRN_NullCheckingOnNullableType:
                 case ErrorCode.WRN_ParameterConditionallyDisallowsNull:
                 case ErrorCode.WRN_NullReferenceInitializer:
                 case ErrorCode.WRN_ShouldNotReturn:

src/Compilers/CSharp/Portable/Errors/MessageID.cs

@@ -240,6 +240,7 @@ internal enum MessageID
 
         IDS_FeatureNewLinesInInterpolations = MessageBase + 12813,
         IDS_FeatureListPattern = MessageBase + 12814,
+        IDS_ParameterNullChecking = MessageBase + 12815,
     }
 
     // Message IDs may refer to strings that need to be localized.
@@ -353,6 +354,7 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 case MessageID.IDS_FeatureGenericAttributes: // semantic check
                 case MessageID.IDS_FeatureNewLinesInInterpolations: // semantic check
                 case MessageID.IDS_FeatureListPattern: // semantic check
+                case MessageID.IDS_ParameterNullChecking: // syntax check
                     return LanguageVersion.Preview;
 
                 // C# 10.0 features.