Test plan for "file-scoped namespace declarations"

[jcouv]

Championed feature: dotnet/csharplang#137
Speclet at: https://github.com/dotnet/csharplang/blob/main/proposals/csharp-10.0/file-scoped-namespaces.md

(checklist currently references changes in #54669)

Compiler

• LangVer (see NamespaceWithSemicolon_CSharp9)
• Multiple file-scoped declarations (see MultipleSingleLineNamespaces)
• Mix and match declarations (see MultipleFileScopedNamespaces)
• GetDeclaredSymbol in mix&match scenarios (see TestGetDeclaredSymbolFromNestedNamespace)
• File-scoped declaration after type (see NamespaceWithPrecedingType)
• test with top-level statement (see FileScopedNamespaceWithPrecedingStatement)
• lookup rules, LookupSymbols (binder chain) (see SemanticModelAPITests.LookupInNamespace)
• double-check all NamespaceDeclarationSyntax and SyntaxKind.NamespaceDeclaration references have been adjusted after merge from main branch
  • note: this was done in the compiler but many places outside the compiler might still need to be changed. See Test plan for "file-scoped namespace declarations" #49000 (comment)
• PROTOTYPE markers
• EnC (manual validation)
• smoke build of VS
• can debug and set breakpoints (manual validation)
• public API review
• SyntaxNormalizer (see SyntaxNormalizerTests.TestFileScopedNamespace)

Productivity

• Formatting
  • Currently, changing a "regular" namespace declaration to file-scoped doesn't automatically unindent the subsequent members. I do not know if this should change or not.
• Indentation
• Classification
• Completion
• FAR (manual validation)
• NavBar (manual validation)
• Convert to file-scoped namespace + code style preference
• Remove unused usings
  • Currently doesn't work following a file-scoped namespace
• Move type to new file
  • Currently this doesn't work at all in the presence of a file-scoped namespace (even for members that precede the namespace)
• Region collapsing (seems fine as-is)
  • Currently, we can't collapse the file scoped namespace's members into the namespace
• LocationInfo currently doesn't work properly. See the following test:

  roslyn/src/EditorFeatures/CSharpTest/Debugging/LocationInfoGetterTests.cs

  Lines 71 to 87 in 9bcecd9

  	[Fact, Trait(Traits.Feature, Traits.Features.DebuggingLocationName)]
  	[WorkItem(49000, "https://github.com/dotnet/roslyn/issues/49000")]
  	public async Task TestFileScopedNamespace()
  	{
  	// This test behavior is incorrect. This should be Namespace.Class.Method.
  	// See the associated WorkItem for details.
  	await TestAsync(
  	@"namespace Namespace;
  	class Class
  	{
  	void Method()
  	{
  	}$$
  	}
  	", "Class.Method()", 2);
  	}

  • This doesn't seem to impact debugging, navbar, etc. It's not clear to me (@RikkiGibson) what pain is introduced if we merge before fixing this.

[RikkiGibson]

I did verify that all usages of NamespaceDeclarationSyntax are accompanied by a corresponding FileScopedNamespaceDeclarationSyntax in the compiler layer. The rest of the usages outside the compiler layer are included here:

178 results - 61 files

src\Analyzers\CSharp\Analyzers\AddAccessibilityModifiers\CSharpAddAccessibilityModifiersDiagnosticAnalyzer.cs:
  49          {
  50:             if (member.IsKind(SyntaxKind.NamespaceDeclaration, out NamespaceDeclarationSyntax namespaceDeclaration))
  51              {

src\Analyzers\CSharp\Analyzers\MatchFolderAndNamespace\CSharpMatchFolderAndNamespaceDiagnosticAnalyzer.cs:
  13      [DiagnosticAnalyzer(LanguageNames.CSharp)]
  14:     internal class CSharpMatchFolderAndNamespaceDiagnosticAnalyzer : AbstractMatchFolderAndNamespaceDiagnosticAnalyzer<NamespaceDeclarationSyntax>
  15      {

src\Analyzers\CSharp\Analyzers\MisplacedUsingDirectives\MisplacedUsingDirectivesDiagnosticAnalyzer.cs:
  66  
  67:             var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;
  68              ReportDiagnostics(context, s_outsideDiagnosticDescriptor, namespaceDeclaration.Usings, option);

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryImports\CSharpRemoveUnnecessaryImportsDiagnosticAnalyzer.cs:
  51              {
  52:                 var nodeContainingUnnecessaryUsings = node.GetAncestors().First(n => n is NamespaceDeclarationSyntax || n is CompilationUnitSyntax);
  53                  if (!nodesContainingUnnecessaryUsings.Add(nodeContainingUnnecessaryUsings))

  57  
  58:                 yield return nodeContainingUnnecessaryUsings is NamespaceDeclarationSyntax ?
  59:                     ((NamespaceDeclarationSyntax)nodeContainingUnnecessaryUsings).Usings.GetContainedSpan() :
  60                      ((CompilationUnitSyntax)nodeContainingUnnecessaryUsings).Usings.GetContainedSpan();

src\Analyzers\CSharp\Analyzers\UseAutoProperty\CSharpUseAutoPropertyAnalyzer.cs:
  49          {
  50:             if (member.IsKind(SyntaxKind.NamespaceDeclaration, out NamespaceDeclarationSyntax? namespaceDeclaration))
  51              {

src\Analyzers\CSharp\CodeFixes\MisplacedUsingDirectives\MisplacedUsingDirectivesCodeFixProvider.cs:
  178              // Fix the leading trivia for the namespace declaration.
  179:             var namespaceDeclaration = (NamespaceDeclarationSyntax)compilationUnitWithoutBlankLine.Members[0];
  180              var namespaceDeclarationWithBlankLine = EnsureLeadingBlankLineBeforeFirstMember(namespaceDeclaration);

  191          {
  192:             var namespaceDeclarations = compilationUnit.Members.OfType<NamespaceDeclarationSyntax>();
  193              var namespaceDeclarationMap = namespaceDeclarations.ToDictionary(

  222  
  223:         private static (NamespaceDeclarationSyntax namespaceWithoutUsings, IEnumerable<UsingDirectiveSyntax> usingsFromNamespace) RemoveUsingsFromNamespace(
  224:             NamespaceDeclarationSyntax usingContainer)
  225          {
  226:             var namespaceDeclarations = usingContainer.Members.OfType<NamespaceDeclarationSyntax>();
  227              var namespaceDeclarationMap = namespaceDeclarations.ToDictionary(

  283                  CompilationUnitSyntax compilationUnit => compilationUnit.Members,
  284:                 NamespaceDeclarationSyntax namespaceDeclaration => namespaceDeclaration.Members,
  285                  _ => throw ExceptionUtilities.UnexpectedValue(node)

  385              var allNamespaces = compilationUnit.DescendantNodes(
  386:                 node => node.IsKind(SyntaxKind.CompilationUnit, SyntaxKind.NamespaceDeclaration)).OfType<NamespaceDeclarationSyntax>();
  387  

src\Compilers\Core\Portable\Compilation\Extensions.cs:
  125          /// derived from MemberDeclarationSyntax, TypeDeclarationSyntax, EnumDeclarationSyntax,
  126:         /// NamespaceDeclarationSyntax, ParameterSyntax, TypeParameterSyntax, or the alias part of a
  127          /// UsingDirectiveSyntax</param>

src\Compilers\Core\Portable\Compilation\SemanticModel.cs:
  388          /// derived from MemberDeclarationSyntax, TypeDeclarationSyntax, EnumDeclarationSyntax,
  389:         /// NamespaceDeclarationSyntax, ParameterSyntax, TypeParameterSyntax, or the alias part of a
  390          /// UsingDirectiveSyntax</param>

  402          /// derived from MemberDeclarationSyntax, TypeDeclarationSyntax, EnumDeclarationSyntax,
  403:         /// NamespaceDeclarationSyntax, ParameterSyntax, TypeParameterSyntax, or the alias part of a
  404          /// UsingDirectiveSyntax</param>

  415          /// derived from MemberDeclarationSyntax, TypeDeclarationSyntax, EnumDeclarationSyntax,
  416:         /// NamespaceDeclarationSyntax, ParameterSyntax, TypeParameterSyntax, or the alias part of a
  417          /// UsingDirectiveSyntax</param>

  431          /// derived from MemberDeclarationSyntax, TypeDeclarationSyntax, EnumDeclarationSyntax,
  432:         /// NamespaceDeclarationSyntax, ParameterSyntax, TypeParameterSyntax, or the alias part of a
  433          /// UsingDirectiveSyntax</param>

src\Compilers\Core\Portable\Symbols\ISymbol.cs:
  177          /// For example, the declaring syntax node for N1 in "namespace N1.N2 {...}" is the entire
  178:         /// NamespaceDeclarationSyntax for N1.N2. For the global namespace, the declaring syntax will
  179          /// be the CompilationUnitSyntax.

src\EditorFeatures\CSharp\AutomaticCompletion\AutomaticLineEnderCommandHandler_Helpers.cs:
  416              {
  417:                 NamespaceDeclarationSyntax namespaceDeclarationNode => ShouldAddBraceForNamespaceDeclaration(namespaceDeclarationNode, caretPosition),
  418                  BaseTypeDeclarationSyntax baseTypeDeclarationNode => ShouldAddBraceForBaseTypeDeclaration(baseTypeDeclarationNode, caretPosition),

  442          /// </summary>
  443:         private static bool ShouldAddBraceForNamespaceDeclaration(NamespaceDeclarationSyntax namespaceDeclarationNode, int caretPosition)
  444              => !namespaceDeclarationNode.Name.IsMissing

src\EditorFeatures\CSharp\AutomaticCompletion\AutomaticLineEnderCommandHandler.cs:
  593              {
  594:                 NamespaceDeclarationSyntax => node.GetBraces().openBrace.SpanStart,
  595                  IndexerDeclarationSyntax indexerNode => indexerNode.ParameterList.Span.End,

src\EditorFeatures\CSharp\LineSeparators\CSharpLineSeparatorService.cs:
   57                          continue;
   58:                     case NamespaceDeclarationSyntax namespaceBlock:
   59                          ProcessUsings(namespaceBlock.Usings, spans, cancellationToken);

  101              return node is TypeDeclarationSyntax ||
  102:                 node is NamespaceDeclarationSyntax ||
  103                  node is CompilationUnitSyntax;

src\EditorFeatures\CSharpTest\Diagnostics\Suppression\SuppressionTests.cs:
   899                              case SyntaxKind.NamespaceDeclaration:
   900:                                 var ns = (NamespaceDeclarationSyntax)context.Node;
   901                                  context.ReportDiagnostic(Diagnostic.Create(Descriptor, ns.Name.GetLocation()));

  1905                              case SyntaxKind.NamespaceDeclaration:
  1906:                                 var ns = (NamespaceDeclarationSyntax)context.Node;
  1907                                  context.ReportDiagnostic(Diagnostic.Create(_descriptor, ns.Name.GetLocation()));

src\EditorFeatures\CSharpTest\Structure\NamespaceDeclarationStructureTests.cs:
  15  {
  16:     public class NamespaceDeclarationStructureTests : AbstractCSharpSyntaxNodeStructureTests<NamespaceDeclarationSyntax>
  17      {

src\Features\CSharp\Portable\AddImport\CSharpAddImportFeatureService.cs:
  454              var container = addImportService.GetImportContainer(root, contextNode, dummyUsing);
  455:             var namespaceToAddTo = container as NamespaceDeclarationSyntax;
  456  

  493              NameSyntax nameSyntax,
  494:             NamespaceDeclarationSyntax namespaceToAddTo)
  495          {

  513              SemanticModel semanticModel,
  514:             NamespaceDeclarationSyntax namespaceToAddTo,
  515              string rightOfAliasName)

src\Features\CSharp\Portable\CodeRefactorings\MoveType\CSharpMoveTypeService.cs:
  20      internal class CSharpMoveTypeService :
  21:         AbstractMoveTypeService<CSharpMoveTypeService, BaseTypeDeclarationSyntax, NamespaceDeclarationSyntax, MemberDeclarationSyntax, CompilationUnitSyntax>
  22      {

src\Features\CSharp\Portable\CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs:
   27      internal sealed class CSharpChangeNamespaceService :
   28:         AbstractChangeNamespaceService<NamespaceDeclarationSyntax, CompilationUnitSyntax, MemberDeclarationSyntax>
   29      {

   47              TextSpan containerSpan;
   48:             if (container is NamespaceDeclarationSyntax)
   49              {

   78  
   79:             if (container is NamespaceDeclarationSyntax namespaceDecl)
   80              {

   88          {
   89:             if (container is NamespaceDeclarationSyntax namespaceDecl)
   90              {

  253  
  254:             if (container is NamespaceDeclarationSyntax namespaceDecl)
  255              {

  273  
  274:         private static CompilationUnitSyntax MoveMembersFromNamespaceToGlobal(CompilationUnitSyntax root, NamespaceDeclarationSyntax namespaceDecl)
  275          {

  321          {
  322:             Debug.Assert(!compilationUnit.Members.Any(m => m is NamespaceDeclarationSyntax));
  323  

  375  
  376:                 var namespaceDecl = node.AncestorsAndSelf().OfType<NamespaceDeclarationSyntax>().SingleOrDefault();
  377                  if (namespaceDecl == null)

  405              static bool ContainsNamespaceDeclaration(SyntaxNode node)
  406:                 => node.DescendantNodes(n => n is CompilationUnitSyntax || n is NamespaceDeclarationSyntax)
  407:                 .OfType<NamespaceDeclarationSyntax>().Any();
  408          }

  472          private static (ImmutableArray<SyntaxTrivia> openingTrivia, ImmutableArray<SyntaxTrivia> closingTrivia)
  473:             GetOpeningAndClosingTriviaOfNamespaceDeclaration(NamespaceDeclarationSyntax namespaceDeclaration)
  474          {

src\Features\CSharp\Portable\CodeRefactorings\SyncNamespace\CSharpSyncNamespaceCodeRefactoringProvider.cs:
  22      internal sealed class CSharpSyncNamespaceCodeRefactoringProvider
  23:         : AbstractSyncNamespaceCodeRefactoringProvider<NamespaceDeclarationSyntax, CompilationUnitSyntax, MemberDeclarationSyntax>
  24      {

  40              var compilationUnit = (CompilationUnitSyntax)await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
  41:             var namespaceDecls = compilationUnit.DescendantNodes(n => n is CompilationUnitSyntax || n is NamespaceDeclarationSyntax)
  42:                 .OfType<NamespaceDeclarationSyntax>().ToImmutableArray();
  43  

src\Features\CSharp\Portable\Completion\KeywordRecommenders\AssemblyKeywordRecommender.cs:
  31                      case CompilationUnitSyntax _:
  32:                     case NamespaceDeclarationSyntax _:
  33                      // The case where the parent of attributeList is (Class/Interface/Enum/Struct)DeclarationSyntax, like:

src\Features\CSharp\Portable\ConvertAnonymousTypeToClass\CSharpConvertAnonymousTypeToClassCodeRefactoringProvider.cs:
  25              AnonymousObjectCreationExpressionSyntax,
  26:             NamespaceDeclarationSyntax>
  27      {

src\Features\CSharp\Portable\ConvertTupleToStruct\CSharpConvertTupleToStructCodeRefactoringProvider.cs:
  26              TypeDeclarationSyntax,
  27:             NamespaceDeclarationSyntax>
  28      {

src\Features\CSharp\Portable\Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.cs:
  100              {
  101:                 if (member is NamespaceDeclarationSyntax namespaceDeclaration)
  102                      AddAliasedNames(namespaceDeclaration);

  121  
  122:             void AddAliasedNames(NamespaceDeclarationSyntax namespaceDeclaration)
  123              {

  130                  {
  131:                     if (member is NamespaceDeclarationSyntax memberNamespace)
  132                          AddAliasedNames(memberNamespace);

src\Features\CSharp\Portable\EditAndContinue\CSharpEditAndContinueAnalyzer.cs:
  1491                  case SyntaxKind.NamespaceDeclaration:
  1492:                     var ns = (NamespaceDeclarationSyntax)node;
  1493                      return TextSpan.FromBounds(ns.NamespaceKeyword.SpanStart, ns.Name.Span.End);

  2502                      case SyntaxKind.NamespaceDeclaration:
  2503:                         ClassifyUpdate((NamespaceDeclarationSyntax)oldNode, (NamespaceDeclarationSyntax)newNode);
  2504                          return;

  2624  
  2625:             private void ClassifyUpdate(NamespaceDeclarationSyntax oldNode, NamespaceDeclarationSyntax newNode)
  2626              {

src\Features\CSharp\Portable\EditAndContinue\SyntaxComparer.cs:
  1357                  case SyntaxKind.NamespaceDeclaration:
  1358:                     return ((NamespaceDeclarationSyntax)node).Name;
  1359  

src\Features\CSharp\Portable\GenerateType\CSharpGenerateTypeService.cs:
  595  
  596:         private NamespaceDeclarationSyntax FindNamespaceInMemberDeclarations(SyntaxList<MemberDeclarationSyntax> members, int indexDone, List<string> containers)
  597          {

  599              {
  600:                 if (member is NamespaceDeclarationSyntax namespaceDeclaration)
  601                  {

  610  
  611:         private NamespaceDeclarationSyntax FindNamespaceInNamespace(NamespaceDeclarationSyntax namespaceDecl, int indexDone, List<string> containers)
  612          {

src\Features\CSharp\Portable\MetadataAsSource\CSharpMetadataAsSourceService.cs:
  153                  CompilationUnitSyntax compilationUnit => (TSyntax)(object)compilationUnit.WithMembers(AddNullableRegions(compilationUnit.Members, cancellationToken)),
  154:                 NamespaceDeclarationSyntax ns => (TSyntax)(object)ns.WithMembers(AddNullableRegions(ns.Members, cancellationToken)),
  155                  TypeDeclarationSyntax type => (TSyntax)(object)AddNullableRegionsAroundTypeMembers(type, cancellationToken),

src\Features\CSharp\Portable\MoveToNamespace\CSharpMoveToNamespaceService.cs:
  17      internal class CSharpMoveToNamespaceService :
  18:         AbstractMoveToNamespaceService<CompilationUnitSyntax, NamespaceDeclarationSyntax, BaseTypeDeclarationSyntax>
  19      {

  30              {
  31:                 NamespaceDeclarationSyntax namespaceSyntax => namespaceSyntax.Name.ToString(),
  32                  CompilationUnitSyntax _ => string.Empty,

  35  
  36:         protected override bool IsContainedInNamespaceDeclaration(NamespaceDeclarationSyntax namespaceDeclaration, int position)
  37          {

src\Features\CSharp\Portable\Structure\CSharpBlockStructureProvider.cs:
  39              builder.Add<MethodDeclarationSyntax, MethodDeclarationStructureProvider>();
  40:             builder.Add<NamespaceDeclarationSyntax, NamespaceDeclarationStructureProvider>();
  41              builder.Add<OperatorDeclarationSyntax, OperatorDeclarationStructureProvider>();

src\Features\CSharp\Portable\Structure\Providers\NamespaceDeclarationStructureProvider.cs:
  12  {
  13:     internal class NamespaceDeclarationStructureProvider : AbstractSyntaxNodeStructureProvider<NamespaceDeclarationSyntax>
  14      {
  15          protected override void CollectBlockSpans(
  16:             NamespaceDeclarationSyntax namespaceDeclaration,
  17              ref TemporaryArray<BlockSpan> spans,

src\VisualStudio\CSharp\Impl\CodeModel\CSharpCodeModelService.CodeModelEventCollector.cs:
  472              private bool CompareNamespaceDeclarations(
  473:                 NamespaceDeclarationSyntax oldNamespace,
  474:                 NamespaceDeclarationSyntax newNamespace,
  475                  SyntaxNode newNodeParent,

  670                  }
  671:                 else if (oldNamespaceOrType is NamespaceDeclarationSyntax namespaceDecl)
  672                  {
  673:                     return CompareNamespaceDeclarations(namespaceDecl, (NamespaceDeclarationSyntax)newNamespaceOrType, newNodeParent, eventQueue);
  674                  }

src\VisualStudio\CSharp\Impl\CodeModel\CSharpCodeModelService.cs:
   282                  SyntaxKind.CompilationUnit => ((CompilationUnitSyntax)parent).Usings,
   283:                 SyntaxKind.NamespaceDeclaration => ((NamespaceDeclarationSyntax)parent).Usings,
   284                  _ => SpecializedCollections.EmptyEnumerable<SyntaxNode>(),

   373              container is CompilationUnitSyntax ||
   374:             container is NamespaceDeclarationSyntax ||
   375              container is BaseTypeDeclarationSyntax;

   393              }
   394:             else if (container is NamespaceDeclarationSyntax namespaceDecl)
   395              {

   828                  case SyntaxKind.NamespaceDeclaration:
   829:                     return ((NamespaceDeclarationSyntax)node).Name.ToString();
   830                  case SyntaxKind.OperatorDeclaration:

   902                  case SyntaxKind.NamespaceDeclaration:
   903:                     return ((NamespaceDeclarationSyntax)node).WithName(
   904                          SyntaxFactory.ParseName(name)

  3205              }
  3206:             else if (container is NamespaceDeclarationSyntax namespaceDeclaration)
  3207              {

  3247              }
  3248:             else if (container is NamespaceDeclarationSyntax namespaceDeclaration)
  3249              {

src\VisualStudio\CSharp\Impl\CodeModel\CSharpCodeModelService.NodeLocator.cs:
    67                      case SyntaxKind.NamespaceDeclaration:
    68:                         return GetStartPoint(text, (NamespaceDeclarationSyntax)node, part);
    69                      case SyntaxKind.UsingDirective:

   117                      case SyntaxKind.NamespaceDeclaration:
   118:                         return GetEndPoint(text, (NamespaceDeclarationSyntax)node, part);
   119                      case SyntaxKind.UsingDirective:

   553  
   554:             private VirtualTreePoint GetStartPoint(SourceText text, NamespaceDeclarationSyntax node, EnvDTE.vsCMPart part)
   555              {

  1123  
  1124:             private VirtualTreePoint GetEndPoint(SourceText text, NamespaceDeclarationSyntax node, EnvDTE.vsCMPart part)
  1125              {

src\VisualStudio\CSharp\Impl\CodeModel\CSharpCodeModelService.NodeNameGenerator.cs:
  166                      case SyntaxKind.NamespaceDeclaration:
  167:                         var namespaceDeclaration = (NamespaceDeclarationSyntax)node;
  168                          AppendName(builder, namespaceDeclaration.Name);

src\Workspaces\CoreTest\SyntaxPathTests.cs:
  146              var tree = SyntaxFactory.ParseSyntaxTree(text);
  147:             var namespaceDecl = (NamespaceDeclarationSyntax)(tree.GetRoot() as CompilationUnitSyntax).Members[0];
  148              var classDecl = (TypeDeclarationSyntax)namespaceDecl.Members[0];

  184              var tree = SyntaxFactory.ParseSyntaxTree(text);
  185:             var namespaceDecl = (NamespaceDeclarationSyntax)(tree.GetRoot() as CompilationUnitSyntax).Members[0];
  186              var class1 = (TypeDeclarationSyntax)namespaceDecl.Members[0];

  217              var tree = SyntaxFactory.ParseSyntaxTree(text);
  218:             var namespaceDecl = (NamespaceDeclarationSyntax)((CompilationUnitSyntax)tree.GetRoot()).Members[0];
  219              var classDecl = (TypeDeclarationSyntax)namespaceDecl.Members[0];

  249              var tree = SyntaxFactory.ParseSyntaxTree(text);
  250:             var namespaceDecl = (NamespaceDeclarationSyntax)((CompilationUnitSyntax)tree.GetRoot()).Members[0];
  251              var class1 = (TypeDeclarationSyntax)namespaceDecl.Members[0];

  277              var tree = SyntaxFactory.ParseSyntaxTree(text);
  278:             var namespaceDecl = (NamespaceDeclarationSyntax)((CompilationUnitSyntax)tree.GetRoot()).Members[0];
  279              var class1 = (TypeDeclarationSyntax)namespaceDecl.Members[0];

  308              var tree = SyntaxFactory.ParseSyntaxTree(text);
  309:             var namespaceDecl = (NamespaceDeclarationSyntax)((CompilationUnitSyntax)tree.GetRoot()).Members[0];
  310              var class1 = (TypeDeclarationSyntax)namespaceDecl.Members[0];

  337              var tree = SyntaxFactory.ParseSyntaxTree(text);
  338:             var namespaceDecl = (NamespaceDeclarationSyntax)((CompilationUnitSyntax)tree.GetRoot()).Members[0];
  339              var class1 = (TypeDeclarationSyntax)namespaceDecl.Members[0];

  376              var tree = SyntaxFactory.ParseSyntaxTree(text);
  377:             var namespaceDecl = (NamespaceDeclarationSyntax)((CompilationUnitSyntax)tree.GetRoot()).Members[0];
  378              var class1 = (TypeDeclarationSyntax)namespaceDecl.Members[0];

src\Workspaces\CSharp\Portable\Classification\ClassificationHelpers.cs:
  316  
  317:             return parent is NamespaceDeclarationSyntax;
  318          }

src\Workspaces\CSharp\Portable\CodeGeneration\CSharpCodeGenerationService.cs:
  118  
  119:             CheckDeclarationNode<TypeDeclarationSyntax, CompilationUnitSyntax, NamespaceDeclarationSyntax>(destination);
  120  

  179  
  180:             var ns = Cast<NamespaceDeclarationSyntax>(destination);
  181              return Cast<TDeclarationNode>(

  244          {
  245:             CheckDeclarationNode<TypeDeclarationSyntax, NamespaceDeclarationSyntax, CompilationUnitSyntax>(destination);
  246  

  250              }
  251:             else if (destination is NamespaceDeclarationSyntax)
  252              {
  253:                 return Cast<TDeclarationNode>(NamedTypeGenerator.AddNamedTypeTo(this, Cast<NamespaceDeclarationSyntax>(destination), namedType, options, availableIndices, cancellationToken));
  254              }

  262          {
  263:             CheckDeclarationNode<CompilationUnitSyntax, NamespaceDeclarationSyntax>(destination);
  264  

  270              {
  271:                 return Cast<TDeclarationNode>(NamespaceGenerator.AddNamespaceTo(this, Cast<NamespaceDeclarationSyntax>(destination), @namespace, options, availableIndices, cancellationToken));
  272              }

  333          {
  334:             CheckDeclarationNode<EnumDeclarationSyntax, TypeDeclarationSyntax, NamespaceDeclarationSyntax, CompilationUnitSyntax>(destination);
  335  

  345              }
  346:             else if (destination is NamespaceDeclarationSyntax)
  347              {
  348:                 return Cast<TDeclarationNode>(Cast<NamespaceDeclarationSyntax>(destination)
  349                      .AddMembers(members.Cast<MemberDeclarationSyntax>().ToArray()));

src\Workspaces\CSharp\Portable\CodeGeneration\CSharpSyntaxGenerator.cs:
  1179                  SyntaxKind.CompilationUnit => ((CompilationUnitSyntax)declaration).Usings,
  1180:                 SyntaxKind.NamespaceDeclaration => ((NamespaceDeclarationSyntax)declaration).Usings,
  1181                  _ => SpecializedCollections.EmptyReadOnlyList<SyntaxNode>(),

  1196                  case SyntaxKind.NamespaceDeclaration:
  1197:                     var nd = (NamespaceDeclarationSyntax)declaration;
  1198                      return nd.WithUsings(nd.Usings.InsertRange(index, usingsToInsert));

  1208                  EnumDeclarationSyntax @enum => @enum.Members,
  1209:                 NamespaceDeclarationSyntax @namespace => @namespace.Members,
  1210                  CompilationUnitSyntax compilationUnit => compilationUnit.Members,

  1315                      EnumDeclarationSyntax @enum => @enum.WithMembers(@enum.Members.AddRange(newMembers.OfType<EnumMemberDeclarationSyntax>())),
  1316:                     NamespaceDeclarationSyntax @namespace => @namespace.WithMembers(@namespace.Members.AddRange(newMembers)),
  1317                      CompilationUnitSyntax compilationUnit => compilationUnit.WithMembers(compilationUnit.Members.AddRange(newMembers)),

  1335                      return this.AsEnumMember(member);
  1336:                 case NamespaceDeclarationSyntax:
  1337                      return AsNamespaceMember(member);

  1759                  EventDeclarationSyntax eventDeclaration => eventDeclaration.Identifier.ValueText,
  1760:                 NamespaceDeclarationSyntax namespaceDeclaration => namespaceDeclaration.Name.ToString(),
  1761                  UsingDirectiveSyntax usingDirective => usingDirective.Name.ToString(),

  1789                  EventDeclarationSyntax eventDeclaration => ReplaceWithTrivia(declaration, eventDeclaration.Identifier, id),
  1790:                 NamespaceDeclarationSyntax namespaceDeclaration => ReplaceWithTrivia(declaration, namespaceDeclaration.Name, this.DottedName(name)),
  1791                  UsingDirectiveSyntax usingDeclaration => ReplaceWithTrivia(declaration, usingDeclaration.Name, this.DottedName(name)),

src\Workspaces\CSharp\Portable\CodeGeneration\MethodGenerator.cs:
  21      {
  22:         internal static NamespaceDeclarationSyntax AddMethodTo(
  23:             NamespaceDeclarationSyntax destination,
  24              IMethodSymbol method,

src\Workspaces\CSharp\Portable\CodeGeneration\NamedTypeGenerator.cs:
  35  
  36:         public static NamespaceDeclarationSyntax AddNamedTypeTo(
  37              ICodeGenerationService service,
  38:             NamespaceDeclarationSyntax destination,
  39              INamedTypeSymbol namedType,

src\Workspaces\CSharp\Portable\CodeGeneration\NamespaceGenerator.cs:
   22      {
   23:         public static NamespaceDeclarationSyntax AddNamespaceTo(
   24              ICodeGenerationService service,
   25:             NamespaceDeclarationSyntax destination,
   26              INamespaceSymbol @namespace,

   31              var declaration = GenerateNamespaceDeclaration(service, @namespace, options, cancellationToken);
   32:             if (!(declaration is NamespaceDeclarationSyntax))
   33              {

   36  
   37:             var members = Insert(destination.Members, (NamespaceDeclarationSyntax)declaration, options, availableIndices);
   38              return destination.WithMembers(members);

   49              var declaration = GenerateNamespaceDeclaration(service, @namespace, options, cancellationToken);
   50:             if (!(declaration is NamespaceDeclarationSyntax))
   51              {

   54  
   55:             var members = Insert(destination.Members, (NamespaceDeclarationSyntax)declaration, options, availableIndices);
   56              return destination.WithMembers(members);

  121                  SyntaxKind.CompilationUnit => ((CompilationUnitSyntax)declaration).WithMembers(default),
  122:                 SyntaxKind.NamespaceDeclaration => ((NamespaceDeclarationSyntax)declaration).WithMembers(default),
  123                  _ => declaration,

src\Workspaces\CSharp\Portable\FindSymbols\CSharpDeclaredSymbolInfoFactoryService.cs:
   30          UsingDirectiveSyntax,
   31:         NamespaceDeclarationSyntax,
   32          TypeDeclarationSyntax,

   91              {
   92:                 if (current.IsKind(SyntaxKind.NamespaceDeclaration, out NamespaceDeclarationSyntax nsDecl))
   93                  {

  351  
  352:         protected override SyntaxList<MemberDeclarationSyntax> GetChildren(NamespaceDeclarationSyntax node)
  353              => node.Members;

  363  
  364:         protected override SyntaxList<UsingDirectiveSyntax> GetUsingAliases(NamespaceDeclarationSyntax node)
  365              => node.Usings;

src\Workspaces\CSharp\Portable\OrganizeImports\CSharpOrganizeImportsService.Rewriter.cs:
  48  
  49:             public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
  50              {
  51:                 node = (NamespaceDeclarationSyntax)base.VisitNamespaceDeclaration(node);
  52                  UsingsAndExternAliasesOrganizer.Organize(

src\Workspaces\CSharp\Portable\Recommendations\CSharpRecommendationServiceRunner.cs:
   99              {
  100:                 return GetSymbolsForNamespaceDeclarationNameContext<NamespaceDeclarationSyntax>();
  101              }

  276                  {
  277:                     var declarationSyntax = name.GetAncestorOrThis<NamespaceDeclarationSyntax>();
  278                      return new RecommendedSymbols(symbols.WhereAsArray(s => IsNonIntersectingNamespace(s, declarationSyntax)));

src\Workspaces\CSharp\Portable\Rename\CSharpRenameRewriterLanguageService.cs:
  886                      {
  887:                         usings = ((NamespaceDeclarationSyntax)namespaceDecl).Usings;
  888                      }

src\Workspaces\CSharp\Portable\Simplification\Simplifiers\AbstractCSharpSimplifier.cs:
  200              SyntaxList<MemberDeclarationSyntax> members;
  201:             if (syntax.IsKind(SyntaxKind.NamespaceDeclaration, out NamespaceDeclarationSyntax namespaceDeclaration))
  202              {

  319              // check whether I am under a namespace
  320:             var @namespace = startNode.GetAncestorOrThis<NamespaceDeclarationSyntax>();
  321              if (@namespace != null)

  347  
  348:         private static int GetNamespaceId(SyntaxNode container, NamespaceDeclarationSyntax target, ref int index)
  349              => container switch

  351                  CompilationUnitSyntax compilation => GetNamespaceId(compilation.Members, target, ref index),
  352:                 NamespaceDeclarationSyntax @namespace => GetNamespaceId(@namespace.Members, target, ref index),
  353                  _ => throw ExceptionUtilities.UnexpectedValue(container)

  355  
  356:         private static int GetNamespaceId(SyntaxList<MemberDeclarationSyntax> members, NamespaceDeclarationSyntax target, ref int index)
  357          {

  359              {
  360:                 if (!(member is NamespaceDeclarationSyntax childNamespace))
  361                  {

src\Workspaces\CSharp\Portable\Simplification\Simplifiers\NameSimplifier.cs:
  551                      case SyntaxKind.NamespaceDeclaration:
  552:                         var namespaceDeclaration = (NamespaceDeclarationSyntax)parent;
  553                          return object.Equals(namespaceDeclaration.Name, node);

src\Workspaces\CSharpTest\CodeGeneration\SyntaxGeneratorTests.cs:
  1412          {
  1413:             VerifySyntax<NamespaceDeclarationSyntax>(
  1414                  Generator.NamespaceDeclaration("n"),

  1416  
  1417:             VerifySyntax<NamespaceDeclarationSyntax>(
  1418                  Generator.NamespaceDeclaration("n.m"),

  1420  
  1421:             VerifySyntax<NamespaceDeclarationSyntax>(
  1422                  Generator.NamespaceDeclaration("n",

  1425  
  1426:             VerifySyntax<NamespaceDeclarationSyntax>(
  1427                  Generator.NamespaceDeclaration("n",

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs:
  207              {
  208:                 case NamespaceDeclarationSyntax namespaceNode:
  209                      return (namespaceNode.OpenBraceToken, namespaceNode.CloseBraceToken);

  476              return node.GetAncestorOrThis<CompilationUnitSyntax>()!.Usings
  477:                        .Concat(node.GetAncestorsOrThis<NamespaceDeclarationSyntax>()
  478                                     .Reverse()

  484              return node.GetAncestorOrThis<CompilationUnitSyntax>()!.Externs
  485:                        .Concat(node.GetAncestorsOrThis<NamespaceDeclarationSyntax>()
  486                                     .Reverse()

  545  
  546:         public static NamespaceDeclarationSyntax? GetInnermostNamespaceDeclarationWithUsings(this SyntaxNode contextNode)
  547          {

  550              {
  551:                 return contextNode.GetAncestorsOrThis<NamespaceDeclarationSyntax>().FirstOrDefault(n => n.Usings.Count > 0);
  552              }

  555                  // We are inside a using directive. In this case, we should find and return the first 'parent' namespace with usings.
  556:                 var containingNamespace = usingDirectiveAncestor.GetAncestor<NamespaceDeclarationSyntax>();
  557                  if (containingNamespace == null)

  563                  {
  564:                     return containingNamespace.GetAncestors<NamespaceDeclarationSyntax>().FirstOrDefault(n => n.Usings.Count > 0);
  565                  }

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Rules\AnchorIndentationFormattingRule.cs:
  56                      return;
  57:                 case NamespaceDeclarationSyntax namespaceNode:
  58                      AddAnchorIndentationOperation(list, namespaceNode);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Rules\NewLineUserSettingFormattingRule.cs:
  112              // * { in the type declaration context
  113:             if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent is BaseTypeDeclarationSyntax or NamespaceDeclarationSyntax)
  114              {

  288              // * { - in the type declaration context
  289:             if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent is BaseTypeDeclarationSyntax or NamespaceDeclarationSyntax)
  290              {

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Rules\TokenBasedFormattingRule.cs:
  252                  CompilationUnitSyntax compilationUnit => compilationUnit.Usings,
  253:                 NamespaceDeclarationSyntax namespaceDecl => namespaceDecl.Usings,
  254                  _ => throw ExceptionUtilities.UnexpectedValue(node.Kind()),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs:
  135              AppendAliasNames(root.Usings, builder);
  136:             AppendAliasNames(root.Members.OfType<NamespaceDeclarationSyntax>(), builder, cancellationToken);
  137  

  153  
  154:         private void AppendAliasNames(IEnumerable<NamespaceDeclarationSyntax> namespaces, ImmutableHashSet<string>.Builder builder, CancellationToken cancellationToken)
  155          {

  160                  AppendAliasNames(@namespace.Usings, builder);
  161:                 AppendAliasNames(@namespace.Members.OfType<NamespaceDeclarationSyntax>(), builder, cancellationToken);
  162              }

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs:
   953          public SyntaxNode? GetNameOfNamespaceDeclaration(SyntaxNode? node)
   954:             => node is NamespaceDeclarationSyntax namespaceDeclaration
   955              ? namespaceDeclaration.Name

   961          public SyntaxList<SyntaxNode> GetMembersOfNamespaceDeclaration(SyntaxNode namespaceDeclaration)
   962:             => ((NamespaceDeclarationSyntax)namespaceDeclaration).Members;
   963  

  1136                          continue;
  1137:                     case NamespaceDeclarationSyntax @namespace:
  1138                          AppendConstructors(@namespace.Members, constructors, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\FormattingRangeHelper.cs:
  350                                       previousToken.Parent is TypeDeclarationSyntax ||
  351:                                      previousToken.Parent is NamespaceDeclarationSyntax);
  352          }

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\CompilationUnitSyntaxExtensions.cs:
  50  
  51:         private static TextSpan GetUsingsSpan(CompilationUnitSyntax root, NamespaceDeclarationSyntax? namespaceDeclaration)
  52          {

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeSymbolExtensions.cs:
  148          {
  149:             var namespaceUsings = root.FindToken(position).Parent!.GetAncestors<NamespaceDeclarationSyntax>().SelectMany(n => n.Usings);
  150              var allUsings = root is CompilationUnitSyntax

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\NamespaceDeclarationSyntaxExtensions.cs:
  12      {
  13:         public static NamespaceDeclarationSyntax AddUsingDirectives(
  14:             this NamespaceDeclarationSyntax namespaceDeclaration,
  15              IList<UsingDirectiveSyntax> usingDirectives,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs:
  479  
  480:             if (token.IsKind(SyntaxKind.OpenBraceToken) && token.Parent is NamespaceDeclarationSyntax or TypeDeclarationSyntax)
  481                  return true;

  553                  var container = token.Parent?.Parent?.Parent;
  554:                 if (container is CompilationUnitSyntax or NamespaceDeclarationSyntax or TypeDeclarationSyntax)
  555                      return true;

  641  
  642:                 if (container is CompilationUnitSyntax or NamespaceDeclarationSyntax or TypeDeclarationSyntax)
  643                      return true;

  712  
  713:             var declaration = token.GetAncestor<NamespaceDeclarationSyntax>();
  714  

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpAddImportsService.cs:
   20      internal class CSharpAddImportsService : AbstractAddImportsService<
   21:         CompilationUnitSyntax, NamespaceDeclarationSyntax, UsingDirectiveSyntax, ExternAliasDirectiveSyntax>
   22      {

   65                  CompilationUnitSyntax c => c.Usings,
   66:                 NamespaceDeclarationSyntax n => n.Usings,
   67                  _ => default,

   73                  CompilationUnitSyntax c => c.Externs,
   74:                 NamespaceDeclarationSyntax n => n.Externs,
   75                  _ => default,

  124  
  125:             public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
  126              {
  127                  // recurse downwards so we visit inner namespaces first.
  128:                 var rewritten = (NamespaceDeclarationSyntax)(base.VisitNamespaceDeclaration(node) ?? throw ExceptionUtilities.Unreachable);
  129  

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.cs:
  78  
  79:             foreach (var @namespace in compilationUnit.Members.OfType<NamespaceDeclarationSyntax>())
  80              {

  85          private void AddFormattingSpans(
  86:             NamespaceDeclarationSyntax namespaceMember,
  87              List<TextSpan> spans,

  92  
  93:             foreach (var @namespace in namespaceMember.Members.OfType<NamespaceDeclarationSyntax>())
  94              {

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.Rewriter.cs:
  150  
  151:             public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
  152              {
  153:                 var namespaceDeclaration = (NamespaceDeclarationSyntax)base.VisitNamespaceDeclaration(node);
  154                  var usingsToRemove = GetUsingsToRemove(node.Usings, namespaceDeclaration.Usings);

[jcouv]

@CyrusNajmabadi @RikkiGibson I think the remaining unchecked bullets in "productivity" section have been addressed already by Cyrus's recent fixes. I'll go ahead and close this test plan.
We can file individual issues for any bugs from here.