Detect .NET SDK & VSLANG Custom Language Settings & Apply To MSBuild

src/MSBuild.UnitTests/XMake_Tests.cs

@@ -642,6 +642,35 @@ public void SetConsoleUICulture()
             thisThread.CurrentUICulture = originalUICulture;
         }
 
+
+        [Fact]
+        public void ConsoleUIRespectsSDKLanguage()
+        {
+            const string DOTNET_CLI_UI_LANGUAGE = nameof(DOTNET_CLI_UI_LANGUAGE);
+
+            // Save the current environment info so it can be restored.
+            var originalUILanguage = Environment.GetEnvironmentVariable(DOTNET_CLI_UI_LANGUAGE);
+            Encoding originalOutputEncoding = Console.OutputEncoding;
+            Encoding originalInputEncoding = Console.InputEncoding;
+            Thread thisThread = Thread.CurrentThread;
+            CultureInfo originalUICulture = thisThread.CurrentUICulture;
+
+            // Set the UI language based on the SDK environment var.
+            Environment.SetEnvironmentVariable(DOTNET_CLI_UI_LANGUAGE, "ja"); // japanese chose arbitrarily.
+
+            MSBuildApp.SetConsoleUI();
+
+            Assert.Equal(thisThread.CurrentUICulture, new CultureInfo("ja"));
+            Assert.Equal(65001, System.Console.OutputEncoding.CodePage); // utf 8 enabled for correct rendering.
+
+            // Restore the current UI culture back to the way it was at the beginning of this unit test.
+            thisThread.CurrentUICulture = originalUICulture;
+            Environment.SetEnvironmentVariable(DOTNET_CLI_UI_LANGUAGE, originalUILanguage);
+            // MSbuild should also restore the encoding upon exit, but we don't create that context here.
+            Console.OutputEncoding = originalOutputEncoding;
+            Console.InputEncoding = originalInputEncoding;
+        }
+
 #if FEATURE_SYSTEM_CONFIGURATION
         /// <summary>
         /// Invalid configuration file should not dump stack.

src/MSBuild/XMake.cs

@@ -37,6 +37,7 @@
 using Microsoft.Build.Shared.Debugging;
 using Microsoft.Build.Experimental;
 using Microsoft.Build.Framework.Telemetry;
+using System.Runtime.CompilerServices;
 using Microsoft.Build.Internal;
 using Microsoft.Build.Logging.LiveLogger;
 using System.Runtime.InteropServices;
@@ -665,6 +666,9 @@ private static void DebuggerLaunchCheck()
                 VerifyThrowSupportedOS();
 
                 // Setup the console UI.
+                Encoding originalOutputEncoding = Console.OutputEncoding;
+                Encoding originalInputEncoding = Console.InputEncoding;
+                CultureInfo originalThreadCulture = Thread.CurrentThread.CurrentUICulture;
                 SetConsoleUI();
 
                 // reset the application state for this new build
@@ -832,6 +836,10 @@ private static void DebuggerLaunchCheck()
                     // if there was no need to start the build e.g. because /help was triggered
                     // do nothing
                 }
+
+                // The encoding may be changed to support non-en characters for environment variables set by external tools. We don't want to impact other programs on the console.
+                Console.OutputEncoding = originalOutputEncoding;
+                Console.InputEncoding = originalInputEncoding;
             }
             /**********************************************************************************************************************
              * WARNING: Do NOT add any more catch blocks below! Exceptions should be caught as close to their point of origin as
@@ -1635,7 +1643,7 @@ internal static void SetConsoleUI()
             Thread thisThread = Thread.CurrentThread;
 
             // Eliminate the complex script cultures from the language selection.
-            thisThread.CurrentUICulture = CultureInfo.CurrentUICulture.GetConsoleFallbackUICulture();
+            thisThread.CurrentUICulture = GetExternalOverridenUILanguageIfSupportableWithEncoding() ?? CultureInfo.CurrentUICulture.GetConsoleFallbackUICulture();
 
             // Determine if the language can be displayed in the current console codepage, otherwise set to US English
             int codepage;
@@ -1669,6 +1677,74 @@ internal static void SetConsoleUI()
 #endif
         }
 
+        /// <summary>
+        /// The .NET SDK and Visual Studio both have environment variables that set a custom language. MSBuild should respect those variables.
+        /// To use the correspoding UI culture, in certain cases the console encoding must be changed. This function will change the encoding in these cases.
+        /// This code introduces a breaking change due to the encoding of the console being changed.
+        /// If the environment variables are undefined, this function should be a no-op.
+        /// </summary>
+        /// <returns>The custom language that was set by the user for an 'external' tool besides MSBuild.
+        /// DOTNET_CLI_UI_LANGUAGE > VSLANG. Returns null if none are set.</returns>
+        private static CultureInfo GetExternalOverridenUILanguageIfSupportableWithEncoding()
+        {
+            CultureInfo externalLanguageSetting = GetExternalOverriddenUILanguage();
+            if (externalLanguageSetting != null)
+            {
+                if (
+                    RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && // Encoding is only an issue on Windows
+                    !externalLanguageSetting.TwoLetterISOLanguageName.Equals("en", StringComparison.InvariantCultureIgnoreCase) &&
+                    Environment.OSVersion.Version.Major >= 10 // UTF-8 is only officially supported on 10+.
+                    )
+                {
+                    // Setting both encodings causes a change in the CHCP, making it so we dont need to P-Invoke ourselves.
+                    Console.OutputEncoding = Encoding.UTF8;
+                    // If the InputEncoding is not set, the encoding will work in CMD but not in Powershell, as the raw CHCP page won't be changed.
+                    Console.InputEncoding = Encoding.UTF8;
+                    return externalLanguageSetting;
+                }
+                else if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    return externalLanguageSetting;
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Look at UI language overrides that can be set by known external invokers. (DOTNET_CLI_UI_LANGUAGE and VSLANG).
+        /// Does NOT check System Locale or OS Display Language.
+        /// Ported from the .NET SDK: https://github.com/dotnet/sdk/src/Cli/Microsoft.DotNet.Cli.Utils/UILanguageOverride.cs.
+        /// </summary>
+        /// <returns>The custom language that was set by the user for an 'external' tool besides MSBuild.
+        /// DOTNET_CLI_UI_LANGUAGE > VSLANG. Returns null if none are set.</returns>
+        private static CultureInfo GetExternalOverriddenUILanguage()
+        {
+            // DOTNET_CLI_UI_LANGUAGE=<culture name> is the main way for users to customize the CLI's UI language via the .NET SDK.
+            string dotnetCliLanguage = Environment.GetEnvironmentVariable("DOTNET_CLI_UI_LANGUAGE");
+            if (dotnetCliLanguage != null)
+            {
+                try
+                {
+                    return new CultureInfo(dotnetCliLanguage);
+                }
+                catch (CultureNotFoundException) { }
+            }
+
+            // VSLANG=<lcid> is set by Visual Studio.
+            string vsLang = Environment.GetEnvironmentVariable("VSLANG");
+            if (vsLang != null && int.TryParse(vsLang, out int vsLcid))
+            {
+                try
+                {
+                    return new CultureInfo(vsLcid);
+                }
+                catch (ArgumentOutOfRangeException) { }
+                catch (CultureNotFoundException) { }
+            }
+
+            return null;
+        }
+
         /// <summary>
         /// Gets all specified switches, from the command line, as well as all
         /// response files, including the auto-response file.