diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
index b5e2811d66d113619b5d9db10605caeb04ee9b55..b66cb01e0c6e94e47e0ade80c29b5325a2d2b008 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -3377,16 +3377,19 @@ private static bool IsNegativeConstantForArraySize(BoundExpression expression)
                     var refKinds = analyzedArguments.RefKinds.ToImmutableOrNull();
                     var argsToParamsOpt = memberResolutionResult.Result.ArgsToParamsOpt;
 
-                    hasErrors |= !CheckInvocationArgMixing(
-                        nonNullSyntax,
-                        resultMember,
-                        receiver,
-                        resultMember.Parameters, 
-                        arguments, 
-                        refKinds, 
-                        argsToParamsOpt, 
-                        this.LocalScopeDepth, 
-                        diagnostics);
+                    if (!hasErrors)
+                    {
+                        hasErrors = !CheckInvocationArgMixing(
+                            nonNullSyntax,
+                            resultMember,
+                            receiver,
+                            resultMember.Parameters,
+                            arguments,
+                            refKinds,
+                            argsToParamsOpt,
+                            this.LocalScopeDepth,
+                            diagnostics);
+                    }
 
                     return new BoundCall(
                         nonNullSyntax,
@@ -4491,16 +4494,20 @@ private bool IsConstructorAccessible(MethodSymbol constructor, ref HashSet<Diagn
                 var arguments = analyzedArguments.Arguments.ToImmutable();
                 var refKinds = analyzedArguments.RefKinds.ToImmutableOrNull();
                 var argToParams = memberResolutionResult.Result.ArgsToParamsOpt;
-                hasError |= !CheckInvocationArgMixing(
-                    node,
-                    method,
-                    null,
-                    method.Parameters,
-                    arguments,
-                    refKinds,
-                    argToParams,
-                    this.LocalScopeDepth,
-                    diagnostics);
+
+                if (!hasError)
+                {
+                    hasError = !CheckInvocationArgMixing(
+                        node,
+                        method,
+                        null,
+                        method.Parameters,
+                        arguments,
+                        refKinds,
+                        argToParams,
+                        this.LocalScopeDepth,
+                        diagnostics);
+                }
 
                 result = new BoundObjectCreationExpression(
                     node,
@@ -6816,16 +6823,20 @@ private BoundExpression BindIndexedPropertyAccess(SyntaxNode syntax, BoundExpres
                 }
 
                 var arguments = analyzedArguments.Arguments.ToImmutable();
-                gotError |= !CheckInvocationArgMixing(
-                    syntax,
-                    property,
-                    receiver,
-                    property.Parameters,
-                    arguments,
-                    argumentRefKinds,
-                    argsToParams,
-                    this.LocalScopeDepth,
-                    diagnostics);
+
+                if (!gotError)
+                {
+                    gotError = !CheckInvocationArgMixing(
+                        syntax,
+                        property,
+                        receiver,
+                        property.Parameters,
+                        arguments,
+                        argumentRefKinds,
+                        argsToParams,
+                        this.LocalScopeDepth,
+                        diagnostics);
+                }
 
                 propertyAccess = new BoundIndexerAccess(
                     syntax,
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs
index ce729d50da236241fa5153685d352cc9a0207a7d..aa87998335397562b411caaf85fb08f3ff2c1954 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs
@@ -1066,16 +1066,19 @@ private static void CheckRestrictedTypeReceiver(BoundExpression expression, Comp
 
             Debug.Assert(args.IsDefaultOrEmpty || (object)receiver != (object)args[0]);
 
-            gotError |= !CheckInvocationArgMixing(
-                node,
-                method,
-                receiver,
-                method.Parameters,
-                args,
-                argRefKinds,
-                argsToParams,
-                this.LocalScopeDepth,
-                diagnostics);
+            if (!gotError)
+            {
+                gotError = !CheckInvocationArgMixing(
+                    node,
+                    method,
+                    receiver,
+                    method.Parameters,
+                    args,
+                    argRefKinds,
+                    argsToParams,
+                    this.LocalScopeDepth,
+                    diagnostics);
+            }
 
             if ((object)delegateTypeOpt != null)
             {
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/SpanStackSafetyTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/SpanStackSafetyTests.cs
index f54b18655fc13b8a2c9ed75a82e0dba5a096554b..7fb7c25287e535bba2539cc3d1ce5783ca7d2c35 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/SpanStackSafetyTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/SpanStackSafetyTests.cs
@@ -1382,5 +1382,41 @@ void Check()
                 //     public static Point field1;
                 Diagnostic(ErrorCode.ERR_FieldAutoPropCantBeByRefLike, "Point").WithArguments("Point").WithLocation(7, 19));
         }
+
+        [Fact]
+        [WorkItem(24627, "https://github.com/dotnet/roslyn/issues/24627")]
+        public void ArgMixingBogusInstanceCall()
+        {
+            var comp = CreateCompilationWithMscorlibAndSpan(@"
+class Program
+{
+    ref struct S1
+    {
+        public void Test(int x) => throw null;       
+        public int this[int x] => throw null;        
+        public S1(S1 x, int y) => throw null;            
+    }
+    
+    static void Main()
+    {
+        // these are all errors, we should not be doing escape analysis on them.
+        S1.Test(1);
+        var x = S1[1];       
+        var y = new S1(S1, 1);
+    }
+}");           
+            
+            comp.VerifyDiagnostics(
+                // (14,9): error CS0120: An object reference is required for the non-static field, method, or property 'Program.S1.Test(int)'
+                //         S1.Test(1);
+                Diagnostic(ErrorCode.ERR_ObjectRequired, "S1.Test").WithArguments("Program.S1.Test(int)").WithLocation(14, 9),
+                // (15,17): error CS0119: 'Program.S1' is a type, which is not valid in the given context
+                //         var x = S1[1];       
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "S1").WithArguments("Program.S1", "type").WithLocation(15, 17),
+                // (16,24): error CS0119: 'Program.S1' is a type, which is not valid in the given context
+                //         var y = new S1(S1, 1);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "S1").WithArguments("Program.S1", "type").WithLocation(16, 24)
+                );
+        }
     }
 }