Rebuild compilations that use top-level statements

eng/test-rebuild.ps1

@@ -116,7 +116,6 @@ try {
  " --exclude netcoreapp3.1\VBSyntaxGenerator.dll" +
 
  # Compilation Errors
- " --exclude net5.0\IOperationGenerator.dll" +
  " --exclude net472\Microsoft.CodeAnalysis.CSharp.Scripting.Desktop.UnitTests.dll" +
  " --exclude netcoreapp3.1\Microsoft.CodeAnalysis.CSharp.Scripting.dll" +
  " --exclude netstandard2.0\Microsoft.CodeAnalysis.CSharp.Scripting.dll" +

src/Compilers/Core/Rebuild/BuildConstructor.cs

@@ -298,8 +298,6 @@ public static unsafe EmitResult Emit(
  .Select(pair => EmbeddedText.FromSource(pair.path, pair.text))
  .ToImmutableArray();
 
- var debugEntryPoint = getDebugEntryPoint();
-
  var emitResult = producedCompilation.Emit(
  peStream: rebuildPeStream,
  pdbStream: null,
@@ -311,32 +309,14 @@ public static unsafe EmitResult Emit(
  debugInformationFormat: DebugInformationFormat.Embedded,
  highEntropyVirtualAddressSpace: (peHeader.DllCharacteristics & DllCharacteristics.HighEntropyVirtualAddressSpace) != 0,
  subsystemVersion: SubsystemVersion.Create(peHeader.MajorSubsystemVersion, peHeader.MinorSubsystemVersion)),
- debugEntryPoint: debugEntryPoint,
+ debugEntryPoint: producedCompilation.GetEntryPoint(cancellationToken),
  metadataPEStream: null,
  pdbOptionsBlobReader: optionsReader.GetMetadataCompilationOptionsBlobReader(),
  sourceLinkStream: sourceLink != null ? new MemoryStream(sourceLink) : null,
  embeddedTexts: embeddedTexts,
  cancellationToken: cancellationToken);
 
  return emitResult;
-
- IMethodSymbol? getDebugEntryPoint()
- {
- if (optionsReader.GetMainTypeName() is { } mainTypeName &&
- optionsReader.GetMainMethodName() is { } mainMethodName)
- {
- var typeSymbol = producedCompilation.GetTypeByMetadataName(mainTypeName);
- if (typeSymbol is object)
- {
- var methodSymbols = typeSymbol
- .GetMembers(mainMethodName)
- .OfType<IMethodSymbol>();
- return methodSymbols.FirstOrDefault();
- }
- }
-
- return null;
- }
  }
  }
 }

src/Compilers/Core/Rebuild/CompilationOptionsReader.cs

@@ -136,12 +136,11 @@ public OutputKind GetOutputKind() =>
  ? OutputKind.ConsoleApplication
  : OutputKind.DynamicallyLinkedLibrary;
 
- public string? GetMainTypeName() => GetMainMethodInfo() is { } tuple
- ? tuple.MainTypeName
- : null;
-
- public string? GetMainMethodName() => GetMainMethodInfo() is { } tuple
- ? tuple.MainMethodName
+ // Here we only want to give the caller the main type name if the main method is named "Main" per convention.
+ // If the main method has another name, we have to assume that specifying a main type name won't work.
+ // For example, if the compilation uses top-level statements.
+ public string? GetMainTypeName() => GetMainMethodInfo() is (string typeName, WellKnownMemberNames.EntryPointMethodName)
+ ? typeName
  : null;
 
  private (string MainTypeName, string MainMethodName)? GetMainMethodInfo()

src/Compilers/Core/RebuildTest/CSharpRebuildTests.cs

@@ -0,0 +1,62 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System;
+using System.Reflection.PortableExecutable;
+using BuildValidator;
+using Castle.Core.Logging;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.Extensions.Logging;
+using Xunit;
+using System.IO;
+using System.Threading;
+using Microsoft.CodeAnalysis.VisualBasic;
+using System.Text;
+
+namespace Microsoft.CodeAnalysis.Rebuild.UnitTests
+{
+ public class CSharpRebuildTests : CSharpTestBase
+ {
+ [Fact]
+ public void TopLevelStatements()
+ {
+ const string path = "test";
+
+ var original = CreateCompilation(
+ @"System.Console.WriteLine(""I'm using top-level statements!"");",
+ options: TestOptions.DebugExe);
+
+ original.VerifyDiagnostics();
+
+ var originalBytes = original.EmitToArray(new EmitOptions(debugInformationFormat: DebugInformationFormat.Embedded));
+ var peReader = new PEReader(originalBytes);
+ Assert.True(peReader.TryOpenAssociatedPortablePdb(path, path => null, out var provider, out _));
+ var pdbReader = provider!.GetMetadataReader();
+
+ var factory = LoggerFactory.Create(configure => { });
+ var logger = factory.CreateLogger(path);
+ var bc = new BuildConstructor(logger);
+
+ var optionsReader = new CompilationOptionsReader(logger, pdbReader, peReader);
+
+ var sources = original.SyntaxTrees.Select(st =>
+ {
+ var text = st.GetText();
+ return new ResolvedSource(OnDiskPath: null, text, new SourceFileInfo(path, text.ChecksumAlgorithm, text.GetChecksum().ToArray(), text, embeddedCompressedHash: null));
+ }).ToImmutableArray();
+ var references = original.References.ToImmutableArray();
+ var (compilation, isError) = bc.CreateCompilation(optionsReader, path, sources, references);
+
+ Assert.False(isError);
+ compilation.VerifyEmitDiagnostics();
+ }
+ }
+}