Merge remote-tracking branch 'upstream/main' into spellCheckingSnippet

Author: CyrusNajmabadi

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

@@ -1943,11 +1943,7 @@ private static void GetInvocationArgumentsForEscape(
                         parameters[argsToParamsOpt.IsDefault ? argIndex : argsToParamsOpt[argIndex]] :
                         null;
 
-                    if (mixableArguments is not null
-                        && isMixableParameter(parameter)
-                        // assume any expression variable is a valid mixing destination,
-                        // since we will infer a legal val-escape for it (if it doesn't already have a narrower one).
-                        && isMixableArgument(argument))
+                    if (mixableArguments is not null && isMixableParameter(parameter))
                     {
                         mixableArguments.Add(new MixableDestination(parameter, argument));
                     }
@@ -1972,9 +1968,6 @@ parameter is not null &&
                 parameter.Type.IsRefLikeType &&
                 parameter.RefKind.IsWritableReference();
 
-            static bool isMixableArgument(BoundExpression argument) =>
-                argument is not (BoundDeconstructValuePlaceholder or BoundLocal { DeclarationKind: not BoundLocalDeclarationKind.None });
-
             static EscapeArgument getReceiver(Symbol symbol, BoundExpression receiver)
             {
                 if (symbol is FunctionPointerMethodSymbol)
@@ -2202,30 +2195,6 @@ private bool UseUpdatedEscapeRulesForInvocation(Symbol symbol)
             return method?.UseUpdatedEscapeRules == true;
         }
 
-        private static bool ShouldInferDeclarationExpressionValEscape(BoundExpression argument, [NotNullWhen(true)] out SourceLocalSymbol? localSymbol)
-        {
-            var symbol = argument switch
-            {
-                BoundDeconstructValuePlaceholder p => p.ExpressionSymbol,
-                BoundLocal { DeclarationKind: not BoundLocalDeclarationKind.None } l => l.ExpressionSymbol,
-                _ => null
-            };
-            if (symbol is SourceLocalSymbol { ValEscapeScope: CallingMethodScope } local)
-            {
-                localSymbol = local;
-                return true;
-            }
-            else
-            {
-                // No need to infer a val escape for a global variable.
-                // These are only used in top-level statements in scripting mode,
-                // and since they are class fields, their scope is always CallingMethod.
-                Debug.Assert(symbol is null or SourceLocalSymbol or GlobalExpressionVariable);
-                localSymbol = null;
-                return false;
-            }
-        }
-
         /// <summary>
         /// Validates whether the invocation is valid per no-mixing rules.
         /// Returns <see langword="false"/> when it is not valid and produces diagnostics (possibly more than one recursively) that helps to figure the reason.
@@ -2270,7 +2239,7 @@ private bool CheckInvocationArgMixing(
             var escapeArguments = ArrayBuilder<EscapeArgument>.GetInstance();
             GetInvocationArgumentsForEscape(
                 symbol,
-                receiverOpt,
+                receiver: null, // receiver handled explicitly below
                 parameters,
                 argsOpt,
                 argRefKindsOpt: default,
@@ -2283,51 +2252,43 @@ private bool CheckInvocationArgMixing(
             {
                 foreach (var (_, argument, refKind) in escapeArguments)
                 {
-                    if (ShouldInferDeclarationExpressionValEscape(argument, out _))
-                    {
-                        // assume any expression variable is a valid mixing destination,
-                        // since we will infer a legal val-escape for it (if it doesn't already have a narrower one).
-                        continue;
-                    }
-
                     if (refKind.IsWritableReference() && argument.Type?.IsRefLikeType == true)
                     {
                         escapeTo = Math.Min(escapeTo, GetValEscape(argument, scopeOfTheContainingExpression));
                     }
                 }
 
-                var hasMixingError = false;
+                if (escapeTo == scopeOfTheContainingExpression)
+                {
+                    // cannot fail. common case.
+                    return true;
+                }
 
-                // track the widest scope that arguments could safely escape to.
-                // use this scope as the inferred STE of declaration expressions.
-                var inferredDestinationValEscape = CallingMethodScope;
                 foreach (var (parameter, argument, _) in escapeArguments)
                 {
-                    // in the old rules, we assume that refs cannot escape into ref struct variables.
-                    // e.g. in `dest = M(ref arg)`, we assume `ref arg` will not escape into `dest`, but `arg` might.
-                    inferredDestinationValEscape = Math.Max(inferredDestinationValEscape, GetValEscape(argument, scopeOfTheContainingExpression));
-                    if (!hasMixingError && !CheckValEscape(argument.Syntax, argument, scopeOfTheContainingExpression, escapeTo, false, diagnostics))
+                    var valid = CheckValEscape(argument.Syntax, argument, scopeOfTheContainingExpression, escapeTo, false, diagnostics);
+
+                    if (!valid)
                     {
                         string parameterName = GetInvocationParameterName(parameter);
                         Error(diagnostics, ErrorCode.ERR_CallArgMixing, syntax, symbol, parameterName);
-                        hasMixingError = true;
-                    }
-                }
-
-                foreach (var (_, argument, _) in escapeArguments)
-                {
-                    if (ShouldInferDeclarationExpressionValEscape(argument, out var localSymbol))
-                    {
-                        localSymbol.SetValEscape(inferredDestinationValEscape);
+                        return false;
                     }
                 }
-
-                return !hasMixingError;
             }
             finally
             {
                 escapeArguments.Free();
             }
+
+            // check val escape of receiver if ref-like
+            if (receiverOpt?.Type?.IsRefLikeType == true)
+            {
+                // Should we also report ErrorCode.ERR_CallArgMixing if CheckValEscape() fails?
+                return CheckValEscape(receiverOpt.Syntax, receiverOpt, scopeOfTheContainingExpression, escapeTo, false, diagnostics);
+            }
+
+            return true;
         }
 
         private bool CheckInvocationArgMixingWithUpdatedRules(
@@ -2391,32 +2352,9 @@ private bool CheckInvocationArgMixingWithUpdatedRules(
                 }
             }
 
-            inferDeclarationExpressionValEscape();
-
             mixableArguments.Free();
             escapeValues.Free();
             return valid;
-
-            void inferDeclarationExpressionValEscape()
-            {
-                // find the widest scope that arguments could safely escape to.
-                // use this scope as the inferred STE of declaration expressions.
-                var inferredDestinationValEscape = CallingMethodScope;
-                foreach (var (_, fromArg, _, isRefEscape) in escapeValues)
-                {
-                    inferredDestinationValEscape = Math.Max(inferredDestinationValEscape, isRefEscape
-                        ? GetRefEscape(fromArg, scopeOfTheContainingExpression)
-                        : GetValEscape(fromArg, scopeOfTheContainingExpression));
-                }
-
-                foreach (var (_, fromArg, _, _) in escapeValues)
-                {
-                    if (ShouldInferDeclarationExpressionValEscape(fromArg, out var localSymbol))
-                    {
-                        localSymbol.SetValEscape(inferredDestinationValEscape);
-                    }
-                }
-            }
         }
 
         private static bool IsReceiverRefReadOnly(Symbol methodOrPropertySymbol) => methodOrPropertySymbol switch

src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs

@@ -318,11 +318,6 @@ internal virtual void SetRefEscape(uint value)
 
         internal virtual void SetValEscape(uint value)
         {
-            // either we should be setting the val escape for the first time,
-            // or not contradicting what was set before.
-            Debug.Assert(
-                _valEscapeScope == Binder.CallingMethodScope
-                || _valEscapeScope == value);
             _valEscapeScope = value;
         }