Improved C# support

prelude/csharp/csharp.bzl

@@ -9,42 +9,39 @@
 load(":csharp_providers.bzl", "DllDepTSet", "DllReference", "DotNetLibraryInfo", "generate_target_tset_children")
 load(":toolchain.bzl", "CSharpToolchainInfo")
 
-def csharp_library_impl(ctx: AnalysisContext) -> list[Provider]:
+def _csharp_library_or_exe_artifact(ctx: AnalysisContext, library_or_exe_name: str, target_type: str) -> (Artifact, list[DllDepTSet]):
     toolchain = ctx.attrs._csharp_toolchain[CSharpToolchainInfo]
 
-    # Automatically set the output dll_name to this target's name if the caller did not specify a
-    # custom name.
-    dll_name = "{}.dll".format(ctx.attrs.name) if not ctx.attrs.dll_name else ctx.attrs.dll_name
-
-    # Declare that this rule will produce a dll.
-    library = ctx.actions.declare_output(dll_name, has_content_based_path = False)
+    # Declare that this rule will produce a dll or exe.
+    library_or_exe_artifact = ctx.actions.declare_output(library_or_exe_name, has_content_based_path = False)
 
-    # Create a command invoking a wrapper script that calls csc.exe to compile the .dll.
+    # Create a command invoking a wrapper script that calls csc.exe to compile the .dll or the .exe.
     cmd = [toolchain.csc]
 
     # Add caller specified compiler flags.
     cmd.append(ctx.attrs.compiler_flags)
 
     # Set the output target as a .NET library.
-    cmd.append("/target:library")
+    cmd.append("/target:" + target_type)
     cmd.append(
         cmd_args(
-            library.as_output(),
+            library_or_exe_artifact.as_output(),
             format = "/out:{}",
         )
     )
 
-    # Don't include any default .NET framework assemblies like "mscorlib" or "System" unless
-    # explicitly requested with `/reference:{}`. This flag also stops injection of other
-    # default compiler flags.
-    cmd.append("/noconfig")
+    if ctx.attrs.add_hermetic_arguments:
+        # Don't include any default .NET framework assemblies like "mscorlib" or "System" unless
+        # explicitly requested with `/reference:{}`. This flag also stops injection of other
+        # default compiler flags.
+        cmd.append("/noconfig")
 
-    # Don't reference mscorlib.dll unless asked for. This is required for targets that target
-    # embedded platforms such as Silverlight or WASM. (Originally for Buck1 compatibility.)
-    cmd.append("/nostdlib")
+        # Don't reference mscorlib.dll unless asked for. This is required for targets that target
+        # embedded platforms such as Silverlight or WASM. (Originally for Buck1 compatibility.)
+        cmd.append("/nostdlib")
 
-    # Don't search any paths for .NET libraries unless explicitly referenced with `/lib:{}`.
-    cmd.append("/nosdkpath")
+        # Don't search any paths for .NET libraries unless explicitly referenced with `/lib:{}`.
+        cmd.append("/nosdkpath")
 
     # Let csc know the directory path where it can find system assemblies. This is the path
     # that is searched by `/reference:{libname}` if `libname` is just a DLL name.
@@ -64,15 +61,38 @@ def csharp_library_impl(ctx: AnalysisContext) -> list[Provider]:
     # Run the C# compiler to produce the output artifact.
     ctx.actions.run(cmd, category = "csharp_compile")
 
+    return library_or_exe_artifact, child_deps
+
+def csharp_library_impl(ctx: AnalysisContext) -> list[Provider]:
+    # Automatically set the output dll_name to this target's name if the caller did not specify a
+    # custom name.
+    dll_name = "{}.dll".format(ctx.attrs.name) if not ctx.attrs.dll_name else ctx.attrs.dll_name
+
+    library_or_exe_artifact, child_deps = _csharp_library_or_exe_artifact(ctx, dll_name, "library")
+
     return [
-        DefaultInfo(default_output = library),
+        DefaultInfo(default_output = library_or_exe_artifact),
         DotNetLibraryInfo(
-            name = ctx.attrs.dll_name,
-            object = library,
-            dll_deps = ctx.actions.tset(DllDepTSet, value = DllReference(reference = library), children = child_deps),
+            name = library_or_exe_artifact.basename,
+            object = library_or_exe_artifact,
+            dll_deps = ctx.actions.tset(DllDepTSet, value = DllReference(reference = library_or_exe_artifact), children = child_deps),
         ),
     ]
 
+def csharp_binary_impl(ctx: AnalysisContext) -> list[Provider]:
+    exe_name = "{}.exe".format(ctx.attrs.name) if not ctx.attrs.exe_name else ctx.attrs.exe_name
+
+    library_or_exe_artifact, child_deps = _csharp_library_or_exe_artifact(ctx, exe_name, "exe")
+
+    new_runtime_files = []
+    for child in child_deps:
+        new_runtime_files.extend([ctx.actions.symlink_file(dll_dep.reference.basename, dll_dep.reference) for dll_dep in child.traverse()])
+
+    return [
+        DefaultInfo(default_output = library_or_exe_artifact, other_outputs = new_runtime_files),
+        RunInfo(args = cmd_args(library_or_exe_artifact, hidden = new_runtime_files)),
+    ]
+
 def prebuilt_dotnet_library_impl(ctx: AnalysisContext) -> list[Provider]:
     # Prebuilt libraries are just passed through since they are already built.
     return [

prelude/decls/dotnet_common.bzl

@@ -0,0 +1,14 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is dual-licensed under either the MIT license found in the
+# LICENSE-MIT file in the root directory of this source tree or the Apache
+# License, Version 2.0 found in the LICENSE-APACHE file in the root directory
+# of this source tree. You may select, at your option, one of the
+# above-listed licenses.
+
+# TODO(cjhopman): This was generated by scripts/hacks/rules_shim_with_docs.py,
+# but should be manually edited going forward. There may be some errors in
+# the generated docs, and so those should be verified to be accurate and
+# well-formatted (and then delete this TODO)
+
+FrameworkVersion = ["net35", "net40", "net45", "net46"]

prelude/decls/dotnet_rules.bzl

@@ -12,8 +12,33 @@
 # well-formatted (and then delete this TODO)
 
 load(":common.bzl", "buck", "prelude_rule")
+load(":dotnet_common.bzl", "FrameworkVersion")
 
-FrameworkVersion = ["net35", "net40", "net45", "net46"]
+_CSHARP_LIBRARY_OR_EXE_ATTRIBUTES = {
+    "srcs": attrs.list(attrs.source(), default = [], doc = """
+              The set of C# source files to be compiled, and assembled by this rule.
+              Each element must a string specifying a source file.
+          """),
+    "resources": attrs.dict(key = attrs.string(), value = attrs.source(), sorted = False, default = {}, doc = """
+              Resources that should be embedded within the built DLL. The format
+              is the name of the resource once mapped into the DLL as the key, and
+              the value being the resource that should be merged. This allows
+              non-unique keys to be identified quickly.
+          """),
+    "framework_ver": attrs.enum(FrameworkVersion, doc = """
+              The version of the .Net framework that this library targets. This is
+              one of 'net35', 'net40', 'net45' and 'net46'.
+          """),
+    "deps": attrs.list(attrs.one_of(attrs.dep(), attrs.string()), default = [], doc = """
+              The set of targets or system-provided assemblies to rely on. Any
+              values that are targets must be either csharp\\_library or `prebuilt_dotnet_library`
+              instances.
+          """),
+    "compiler_flags": attrs.list(attrs.string(), default = [], doc = """
+              The set of additional compiler flags to pass to the compiler.
+          """),
+    "add_hermetic_arguments": attrs.bool(default = True),
+}
 
 csharp_library = prelude_rule(
     name = "csharp_library",
@@ -22,8 +47,6 @@ csharp_library = prelude_rule(
          and dependencies by invoking csc.
     """,
     examples = """
-        For more examples, check out our [integration tests](https://github.com/facebook/buck/tree/dev/test/com/facebook/buck/rust/testdata/).
-
         ```
         csharp_library(
           name = 'simple',
@@ -57,57 +80,64 @@ csharp_library = prelude_rule(
                 The output name of the dll. This allows you to specify the name of
                  the dll exactly. When this is not set, the dll will be named after
                  the short name of the target.
-            """,
-            ),
-            "srcs": attrs.list(
-                attrs.source(),
-                default = [],
-                doc = """
-                The collection of source files to compile.
-            """,
-            ),
-            "resources": attrs.dict(
-                key = attrs.string(),
-                value = attrs.source(),
-                sorted = False,
-                default = {},
-                doc = """
-                Resources that should be embedded within the built DLL. The format
-                 is the name of the resource once mapped into the DLL as the key, and
-                 the value being the resource that should be merged. This allows
-                 non-unique keys to be identified quickly.
-            """,
-            ),
-            "framework_ver": attrs.enum(
-                FrameworkVersion,
-                doc = """
-                The version of the .Net framework that this library targets. This is
-                 one of 'net35', 'net40', 'net45' and 'net46'.
-            """,
-            ),
-            "deps": attrs.list(
-                attrs.one_of(attrs.dep(), attrs.string()),
-                default = [],
-                doc = """
-                The set of targets or system-provided assemblies to rely on. Any
-                 values that are targets must be either csharp\\_library or `prebuilt_dotnet_library`
-                 instances.
-            """,
-            ),
-            "compiler_flags": attrs.list(
-                attrs.string(),
-                default = [],
-                doc = """
-                The set of additional compiler flags to pass to the compiler.
-            """,
-            ),
+            """),
         }
+        | _CSHARP_LIBRARY_OR_EXE_ATTRIBUTES
         | buck.licenses_arg()
         | buck.labels_arg()
         | buck.contacts_arg()
     ),
 )
 
+csharp_binary = prelude_rule(
+    name = "csharp_binary",
+    docs = """
+        A csharp\\_binary() rule builds a .Net library from the supplied set of C# source files
+         and dependencies by invoking csc.
+    """,
+    examples = """
+        ```
+
+        csharp_binary(
+          name = 'simple',
+          exe_name = 'Cake.exe',
+          framework_ver = 'net46',
+          srcs = [
+            'Hello.cs',
+          ],
+          resources = {
+            'greeting.txt': '//some:target',
+          },
+          deps=[
+            ':other',
+            'System.dll',
+          ],
+        )
+
+        prebuilt_dotnet_library(
+          name = 'other',
+          assembly = 'other-1.0.dll',
+        )
+
+        ```
+    """,
+    further = None,
+    attrs = (
+        # @unsorted-dict-items
+        {
+            "exe_name": attrs.string(default = "", doc = """
+                The output name of the dll. This allows you to specify the name of
+                 the dll exactly. When this is not set, the dll will be named after
+                 the short name of the target.
+            """),
+        } |
+        _CSHARP_LIBRARY_OR_EXE_ATTRIBUTES |
+        buck.licenses_arg() |
+        buck.labels_arg() |
+        buck.contacts_arg()
+    ),
+)
+
 prebuilt_dotnet_library = prelude_rule(
     name = "prebuilt_dotnet_library",
     docs = """
@@ -152,5 +182,6 @@ prebuilt_dotnet_library = prelude_rule(
 
 dotnet_rules = struct(
     csharp_library = csharp_library,
+    csharp_binary = csharp_binary,
     prebuilt_dotnet_library = prebuilt_dotnet_library,
 )

prelude/rules_impl.bzl

@@ -22,7 +22,7 @@ load("@prelude//apple:apple_common.bzl", "apple_common")
 load("@prelude//apple:apple_rules_decls.bzl", "apple_rules")
 load("@prelude//apple:apple_rules_impl.bzl", _apple_extra_attributes = "extra_attributes", _apple_implemented_rules = "implemented_rules")
 load("@prelude//configurations:rules.bzl", _config_extra_attributes = "extra_attributes", _config_implemented_rules = "implemented_rules")
-load("@prelude//csharp:csharp.bzl", "csharp_library_impl", "prebuilt_dotnet_library_impl")
+load("@prelude//csharp:csharp.bzl", "csharp_library_impl", "csharp_binary_impl", "prebuilt_dotnet_library_impl")
 load("@prelude//cxx:bitcode.bzl", "llvm_link_bitcode_impl")
 load("@prelude//cxx:cuda.bzl", "CudaCompileStyle")
 load("@prelude//cxx:cxx.bzl", "cxx_binary_impl", "cxx_library_impl", "cxx_precompiled_header_impl", "cxx_test_impl", "prebuilt_cxx_library_impl")
@@ -174,6 +174,7 @@ extra_implemented_rules = struct(
     worker_tool = worker_tool,
     # c#
     csharp_library = csharp_library_impl,
+    csharp_binary = csharp_binary_impl,
     prebuilt_dotnet_library = prebuilt_dotnet_library_impl,
     # c++
     cxx_binary = cxx_binary_impl,
@@ -266,6 +267,9 @@ _dotnet_extra_attributes = {
     "csharp_library": {
         "_csharp_toolchain": toolchains_common.csharp(),
     },
+    "csharp_binary": {
+        "_csharp_toolchain": toolchains_common.csharp(),
+    },
 }
 
 _cxx_extra_library_attrs = (

prelude/toolchains/csharp.bzl

@@ -12,10 +12,12 @@ def _system_csharp_toolchain_impl(ctx):
     if not host_info().os.is_windows:
         fail("csharp toolchain only supported on windows for now")
 
+    csc = ctx.attrs.csc or ctx.attrs._csharp_tools_info[CSharpToolchainInfo].csc
+
     return [
         DefaultInfo(),
         CSharpToolchainInfo(
-            csc = RunInfo(args = ctx.attrs.csc),
+            csc = RunInfo(args = csc),
             framework_dirs = {
                 "net35": "C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v3.5\\Profile\\Client",
                 "net40": "C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.0",
@@ -42,12 +44,13 @@ system_csharp_toolchain = rule(
       visibility = ["PUBLIC"],
   )""",
     attrs = {
-        "csc": attrs.string(default = "csc.exe", doc = "Executable name or a path to the C# compiler frequently referred to as csc.exe"),
+        "csc": attrs.option(attrs.string(), default = None, doc = "Executable name or a path to the C# compiler frequently referred to as csc.exe"),
         "framework_dirs": attrs.dict(
             key = attrs.string(),
             value = attrs.one_of(attrs.source(), attrs.string()),
-            doc = "Dictionary of .NET framework assembly directories, where each key is a supported value in `framework_ver` and the value is a path to a directory containing .net assemblies such as System.dll matching the given framework version",
+            doc = "Dictionary of .NET framework assembly directories, where each key is a supported value in `framework_ver` and the value is a path to a directory containing .net assemblies such as System.dll matching the given framework version"
         ),
+        "_csharp_tools_info": attrs.exec_dep(providers = [CSharpToolchainInfo], default = "prelude//toolchains/msvc:roslyn_tools"),
     },
     is_toolchain_rule = True,
 )

prelude/toolchains/msvc/BUCK

@@ -1,5 +1,5 @@
 load("@prelude//utils:source_listing.bzl", "source_listing")
-load(":tools.bzl", "find_msvc_tools")
+load(":tools.bzl", "find_msvc_tools", "find_roslyn_tools")
 
 oncall("build_infra")
 
@@ -22,3 +22,9 @@ find_msvc_tools(
     target_compatible_with = ["config//os:windows"],
     visibility = ["PUBLIC"],
 )
+
+find_roslyn_tools(
+    name = "roslyn_tools",
+    target_compatible_with = ["config//os:windows"],
+    visibility = ["PUBLIC"],
+)