Do not report parse errors for '#:' in miscellaneous files

src/Compilers/CSharp/Portable/CSharpParseOptions.cs

@@ -237,12 +237,12 @@ static void addSingleNamespaceParts(ArrayBuilder<ImmutableArray<string>> namespa
         }
 
         /// <summary>
-        /// Used for parsing .cs file-based programs.
+        /// Used for parsing .cs file-based programs, or for miscellaneous files (which aren't associated with any project and the full semantics of the code are not known).
         /// </summary>
         /// <remarks>
         /// In this mode, ignored directives <c>#:</c> are allowed.
         /// </remarks>
-        internal bool FileBasedProgram => Features.ContainsKey("FileBasedProgram");
+        internal bool AllowIgnoredDirectives => Features.ContainsKey("FileBasedProgram") || Features.ContainsKey("MiscellaneousFile");
 
         internal override void ValidateOptions(ArrayBuilder<Diagnostic> builder)
         {

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

@@ -686,7 +686,7 @@ private DirectiveTriviaSyntax ParsePragmaDirective(SyntaxToken hash, SyntaxToken
 
         private DirectiveTriviaSyntax ParseShebangDirective(SyntaxToken hash, SyntaxToken exclamation, bool isActive)
         {
-            if (lexer.Options.Kind != SourceCodeKind.Script && !lexer.Options.FileBasedProgram)
+            if (lexer.Options.Kind != SourceCodeKind.Script && !lexer.Options.AllowIgnoredDirectives)
             {
                 exclamation = this.AddError(exclamation, ErrorCode.ERR_PPShebangInProjectBasedProgram);
             }
@@ -698,7 +698,7 @@ private DirectiveTriviaSyntax ParseIgnoredDirective(SyntaxToken hash, SyntaxToke
         {
             if (isActive)
             {
-                if (!lexer.Options.FileBasedProgram)
+                if (!lexer.Options.AllowIgnoredDirectives)
                 {
                     colon = this.AddError(colon, ErrorCode.ERR_PPIgnoredNeedsFileBasedProgram);
                 }

src/Compilers/CSharp/Test/Syntax/Parsing/CSharpParseOptionsTests.cs

@@ -76,7 +76,7 @@ public void TestFieldsForEqualsAndGetHashCode()
             ReflectionAssert.AssertPublicAndInternalFieldsAndProperties(
                 typeof(CSharpParseOptions),
                 "Features",
-                "FileBasedProgram",
+                "AllowIgnoredDirectives",
                 "Language",
                 "LanguageVersion",
                 "InterceptorsNamespaces",

src/Compilers/CSharp/Test/Syntax/Parsing/IgnoredDirectiveParsingTests.cs

@@ -111,6 +111,19 @@ public void Semantics()
             expectedOutput: "123").VerifyDiagnostics();
     }
 
+    [Fact]
+    public void Semantics_MiscellaneousFile()
+    {
+        var source = """
+            #!xyz
+            #:name value
+            System.Console.WriteLine(123);
+            """;
+        CompileAndVerify(source,
+            parseOptions: TestOptions.Regular.WithFeature("MiscellaneousFile"),
+            expectedOutput: "123").VerifyDiagnostics();
+    }
+
     [Fact]
     public void Api()
     {

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/AppDirectiveCompletionProviderTests.cs

@@ -14,6 +14,7 @@
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests;
@@ -100,6 +101,27 @@ public async Task PathRecommendation_02()
         await VerifyItemExistsAsync(markup, expectedItem: "Project.csproj");
     }
 
+    [Fact]
+    public async Task PathRecommendation_03()
+    {
+        // Test a virtual file scenario (e.g. ctrl+N in VS Code or other cases where there is not an actual file on disk.)
+        var code = """
+            #:project $$
+            """;
+
+        var markup = $"""
+            <Workspace>
+                <Project Language="C#" CommonReferences="true" AssemblyName="Test1" Features="FileBasedProgram=true">
+                    <Document FilePath="Untitled-1" ResolveFilePath="false"><![CDATA[{code}]]></Document>
+                </Project>
+            </Workspace>
+            """;
+
+        // In this case, only stuff like drive roots would be recommended.
+        var expectedRoot = PlatformInformation.IsWindows ? @"C:" : "/";
+        await VerifyItemExistsAsync(markup, expectedRoot);
+    }
+
     // Note: The editor uses a shared mechanism to filter out completion items which don't match the prefix of what the user is typing.
     // Therefore we do not have "negative tests" here for file names.
 }

src/Features/CSharp/Portable/Completion/CompletionProviders/FileBasedPrograms/ProjectAppDirectiveCompletionProvider.cs

@@ -45,11 +45,12 @@ protected override async Task AddDirectiveContentCompletionsAsync(CompletionCont
         // Suppose we have a directive '#:project path/to/pr$$'
         // In this case, 'contentPrefix' is 'path/to/pr'.
 
+        var documentDirectory = PathUtilities.GetDirectoryName(context.Document.FilePath);
         var fileSystemHelper = new FileSystemCompletionHelper(
             Glyph.OpenFolder,
             Glyph.CSharpProject,
             searchPaths: [],
-            baseDirectory: PathUtilities.GetDirectoryName(context.Document.FilePath),
+            baseDirectory: PathUtilities.IsAbsolute(documentDirectory) ? documentDirectory : null,
             [".csproj", ".vbproj"],
             CompletionItemRules.Default);
 

src/Features/Core/Portable/Workspace/MiscellaneousFileUtilities.cs

@@ -54,10 +54,9 @@ languageInformation.ScriptExtension is not null &&
             compilationOptions = GetCompilationOptionsWithScriptReferenceResolvers(services, compilationOptions, filePath);
         }
 
-        if (parseOptions != null && languageInformation.ScriptExtension is not null && fileExtension != languageInformation.ScriptExtension)
+        if (parseOptions != null)
         {
-            // Any non-script misc file should not complain about usage of '#:' ignored directives.
-            parseOptions = parseOptions.WithFeatures([.. parseOptions.Features, new("FileBasedProgram", "true")]);
+            parseOptions = parseOptions.WithFeatures([.. parseOptions.Features, new("MiscellaneousFile", "true")]);
         }
 
         var projectId = ProjectId.CreateNewId(debugName: $"{workspace.GetType().Name} Files Project for {filePath}");

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/FileBasedProgramsWorkspaceTests.cs

@@ -145,13 +145,9 @@ await testLspServer.OpenDocumentAsync(nonFileUri, """
         Assert.Equal(2, primordialDocument.Project.Documents.Count());
         Assert.Empty(primordialDocument.Project.MetadataReferences);
 
+        // No errors for '#:' are expected.
         var primordialSyntaxTree = await primordialDocument.GetRequiredSyntaxTreeAsync(CancellationToken.None);
-        // TODO: we probably don't want to report syntax errors for '#:' in the primordial non-file document.
-        // The logic which decides whether to add '-features:FileBasedProgram' probably needs to be adjusted.
-        primordialSyntaxTree.GetDiagnostics(CancellationToken.None).Verify(
-            // vscode-notebook-cell://dev-container/test.cs(1,2): error CS9298: '#:' directives can be only used in file-based programs ('-features:FileBasedProgram')"
-            // #:sdk Microsoft.Net.Sdk
-            TestHelpers.Diagnostic(code: 9298, squiggledText: ":").WithLocation(1, 2));
+        Assert.Empty(primordialSyntaxTree.GetDiagnostics(CancellationToken.None));
 
         // Wait for the canonical project to finish loading.
         await testLspServer.TestWorkspace.GetService<AsynchronousOperationListenerProvider>().GetWaiter(FeatureAttribute.Workspace).ExpeditedWaitAsync();
@@ -164,13 +160,9 @@ await testLspServer.OpenDocumentAsync(nonFileUri, """
         // Should have the appropriate generated files now that we ran a design time build
         Assert.Contains(canonicalDocument.Project.Documents, d => d.Name == "Canonical.AssemblyInfo.cs");
 
+        // No errors for '#:' are expected.
         var canonicalSyntaxTree = await canonicalDocument.GetRequiredSyntaxTreeAsync(CancellationToken.None);
-        // TODO: we probably don't want to report syntax errors for '#:' in the canonical non-file document.
-        // The logic which decides whether to add '-features:FileBasedProgram' probably needs to be adjusted.
-        canonicalSyntaxTree.GetDiagnostics(CancellationToken.None).Verify(
-            // vscode-notebook-cell://dev-container/test.cs(1,2): error CS9298: '#:' directives can be only used in file-based programs ('-features:FileBasedProgram')"
-            // #:sdk Microsoft.Net.Sdk
-            TestHelpers.Diagnostic(code: 9298, squiggledText: ":").WithLocation(1, 2));
+        Assert.Empty(canonicalSyntaxTree.GetDiagnostics(CancellationToken.None));
     }
 
     [Theory, CombinatorialData]

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/CanonicalMiscFilesProjectLoader.cs

@@ -250,6 +250,7 @@ private TextDocument CreatePrimordialProjectAndAddDocument_NoLock(string documen
                 <TargetFramework>net$(BundledNETCoreAppTargetFrameworkVersion)</TargetFramework>
                 <ImplicitUsings>enable</ImplicitUsings>
                 <Nullable>enable</Nullable>
+                <Features>$(Features);MiscellaneousFile</Features>
               </PropertyGroup>
             </Project>
             """;

src/Workspaces/CoreTestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs

@@ -672,7 +672,8 @@ private TDocument CreateDocument(
             AssertEx.Fail($"The document attributes on file {fileName} conflicted");
         }
 
-        var filePath = Path.Combine(TestWorkspace.RootDirectory, fileName);
+        var resolveFilePath = (bool?)documentElement.Attribute("ResolveFilePath");
+        var filePath = resolveFilePath is null or true ? Path.Combine(TestWorkspace.RootDirectory, fileName) : fileName;
 
         return CreateDocument(
             exportProvider, languageServiceProvider, code, fileName, filePath, cursorPosition, spans, codeKind, folders, isLinkFile, documentServiceProvider);