Code changes to allow 'using static unsafe'

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6854,7 +6854,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
     <value>Using alias cannot be a 'ref' type.</value>
   </data>
   <data name="ERR_BadUnsafeInUsingDirective" xml:space="preserve">
-    <value>Only a using alias can be 'unsafe'.</value>
+    <value>Only a 'using static' or 'using alias' can be 'unsafe'.</value>
   </data>
   <data name="ERR_BadNullableReferenceTypeInUsingAlias" xml:space="preserve">
     <value>Using alias cannot be a nullable reference type.</value>
@@ -7499,4 +7499,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="WRN_AddressOfInAsync_Title" xml:space="preserve">
     <value>The '&amp;' operator should not be used on parameters or local variables in async methods.</value>
   </data>
+  <data name="ERR_BadStaticAfterUnsafe" xml:space="preserve">
+    <value>'static' modifier must precede 'unsafe' modifier.</value>
+  </data>
 </root>

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

@@ -2186,6 +2186,7 @@ internal enum ErrorCode
         ERR_BadRefInUsingAlias = 9130,
         ERR_BadUnsafeInUsingDirective = 9131,
         ERR_BadNullableReferenceTypeInUsingAlias = 9132,
+        ERR_BadStaticAfterUnsafe = 9133,
         #endregion
 
         // Note: you will need to do the following after adding warnings:

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

@@ -2307,6 +2307,7 @@ internal static bool IsBuildOnlyDiagnostic(ErrorCode code)
                 case ErrorCode.ERR_BadRefInUsingAlias:
                 case ErrorCode.ERR_BadUnsafeInUsingDirective:
                 case ErrorCode.ERR_BadNullableReferenceTypeInUsingAlias:
+                case ErrorCode.ERR_BadStaticAfterUnsafe:
                     return false;
                 default:
                     // NOTE: All error codes must be explicitly handled in this switch statement

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

@@ -796,6 +796,14 @@ private UsingDirectiveSyntax ParseUsingDirective()
             var staticToken = this.TryEatToken(SyntaxKind.StaticKeyword);
             var unsafeToken = this.TryEatToken(SyntaxKind.UnsafeKeyword);
 
+            // if the user wrote `using unsafe static` skip the `static` and tell them it needs to be `using static unsafe`.
+            if (staticToken is null && unsafeToken != null && this.CurrentToken.Kind == SyntaxKind.StaticKeyword)
+            {
+                // create a missing 'static' token so that later binding does recognize what the user wanted.
+                staticToken = SyntaxFactory.MissingToken(SyntaxKind.StaticKeyword);
+                unsafeToken = AddTrailingSkippedSyntax(unsafeToken, AddError(this.EatToken(), ErrorCode.ERR_BadStaticAfterUnsafe));
+            }
+
             var alias = this.IsNamedAssignment() ? ParseNameEquals() : null;
 
             TypeSyntax type;

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

@@ -377,20 +377,23 @@ private NamespaceSymbol ResolveExternAliasTarget(BindingDiagnosticBag diagnostic
             BindingDiagnosticBag diagnostics,
             ConsList<TypeSymbol>? basesBeingResolved)
         {
+            var reportedError = false;
             if (usingDirective.UnsafeKeyword != default)
             {
-                MessageID.IDS_FeatureUsingTypeAlias.CheckFeatureAvailability(diagnostics, usingDirective, usingDirective.UnsafeKeyword.GetLocation());
+                reportedError = !MessageID.IDS_FeatureUsingTypeAlias.CheckFeatureAvailability(diagnostics, usingDirective, usingDirective.UnsafeKeyword.GetLocation());
             }
             else if (usingDirective.NamespaceOrType is not NameSyntax)
             {
-                MessageID.IDS_FeatureUsingTypeAlias.CheckFeatureAvailability(diagnostics, usingDirective.NamespaceOrType);
+                reportedError = !MessageID.IDS_FeatureUsingTypeAlias.CheckFeatureAvailability(diagnostics, usingDirective.NamespaceOrType);
             }
 
             var syntax = usingDirective.NamespaceOrType;
             var flags = BinderFlags.SuppressConstraintChecks | BinderFlags.SuppressObsoleteChecks;
             if (usingDirective.UnsafeKeyword != default)
             {
-                this.CheckUnsafeModifier(DeclarationModifiers.Unsafe, usingDirective.UnsafeKeyword.GetLocation(), diagnostics);
+                if (!reportedError)
+                    this.CheckUnsafeModifier(DeclarationModifiers.Unsafe, usingDirective.UnsafeKeyword.GetLocation(), diagnostics);
+
                 flags |= BinderFlags.UnsafeRegion;
             }
             else

src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.AliasesAndUsings.cs

@@ -721,14 +721,39 @@ private UsingsAndDiagnostics GetUsingsAndDiagnostics(ref UsingsAndDiagnostics? u
                                 continue;
                             }
 
+                            var flags = BinderFlags.SuppressConstraintChecks;
                             if (usingDirective.UnsafeKeyword != default)
-                                diagnostics.Add(ErrorCode.ERR_BadUnsafeInUsingDirective, usingDirective.UnsafeKeyword.GetLocation());
+                            {
+                                if (usingDirective.StaticKeyword == default)
+                                {
+                                    diagnostics.Add(ErrorCode.ERR_BadUnsafeInUsingDirective, usingDirective.UnsafeKeyword.GetLocation());
+                                }
+                                else
+                                {
+                                    // Make sure 'unsafe' is even allowed in this language version, reporting an error
+                                    // otherwise.  If it is available, ensure that the user passed the '/unsafe' flag to
+                                    // to the compiler.
+                                    if (MessageID.IDS_FeatureUsingTypeAlias.CheckFeatureAvailability(diagnostics, usingDirective, usingDirective.UnsafeKeyword.GetLocation()))
+                                        declaringSymbol.CheckUnsafeModifier(DeclarationModifiers.Unsafe, usingDirective.UnsafeKeyword.GetLocation(), diagnostics);
+                                }
+
+                                flags |= BinderFlags.UnsafeRegion;
+                            }
+                            else
+                            {
+                                // Prior to C#12, allow the using static type to be an unsafe region.  This allows us to
+                                // maintain compat with prior versions of the compiler that allowed `using static
+                                // List<int*[]>;` to be written.  In 12.0 and onwards though, we require the code to
+                                // explicitly contain the `unsafe` keyword.
+                                if (!compilation.IsFeatureEnabled(MessageID.IDS_FeatureUsingTypeAlias))
+                                    flags |= BinderFlags.UnsafeRegion;
+                            }
 
                             var directiveDiagnostics = BindingDiagnosticBag.GetInstance();
                             Debug.Assert(directiveDiagnostics.DiagnosticBag is object);
                             Debug.Assert(directiveDiagnostics.DependenciesBag is object);
 
-                            declarationBinder ??= compilation.GetBinderFactory(declarationSyntax.SyntaxTree).GetBinder(usingDirective.NamespaceOrType).WithAdditionalFlags(BinderFlags.SuppressConstraintChecks);
+                            declarationBinder ??= compilation.GetBinderFactory(declarationSyntax.SyntaxTree).GetBinder(usingDirective.NamespaceOrType).WithAdditionalFlags(flags);
                             var imported = declarationBinder.BindNamespaceOrTypeSymbol(usingDirective.NamespaceOrType, directiveDiagnostics, basesBeingResolved).NamespaceOrTypeSymbol;
 
                             if (imported.Kind == SymbolKind.Namespace)

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

@@ -293,8 +293,13 @@ internal static void CheckUnsafeModifier(this Symbol symbol, DeclarationModifier
         }
 
         internal static void CheckUnsafeModifier(this Symbol symbol, DeclarationModifiers modifiers, Location errorLocation, BindingDiagnosticBag diagnostics)
+            => CheckUnsafeModifier(symbol, modifiers, errorLocation, diagnostics.DiagnosticBag);
+
+        internal static void CheckUnsafeModifier(this Symbol symbol, DeclarationModifiers modifiers, Location errorLocation, DiagnosticBag? diagnostics)
         {
-            if (((modifiers & DeclarationModifiers.Unsafe) == DeclarationModifiers.Unsafe) && !symbol.CompilationAllowsUnsafe())
+            if (diagnostics != null &&
+                (modifiers & DeclarationModifiers.Unsafe) == DeclarationModifiers.Unsafe &&
+                !symbol.CompilationAllowsUnsafe())
             {
                 RoslynDebug.Assert(errorLocation != null);
                 diagnostics.Add(ErrorCode.ERR_IllegalUnsafe, errorLocation);