System.Text.Json Migration - Adding code to parse the Project.Assets.Json file using STJ.

src/NuGet.Core/NuGet.ProjectModel/JsonUtility.cs

@@ -43,6 +43,12 @@ internal static JObject LoadJson(TextReader reader)
             }
         }
 
+        internal static T LoadJson<T>(Stream stream, IUtf8JsonStreamReaderConverter<T> converter)
+        {
+            var streamingJsonReader = new Utf8JsonStreamReader(stream);
+            return converter.Read(ref streamingJsonReader);
+        }
+
         internal static PackageDependency ReadPackageDependency(string property, JToken json)
         {
             var versionStr = json.Value<string>();

src/NuGet.Core/NuGet.ProjectModel/LazyStringSplit.cs

@@ -0,0 +1,138 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+#nullable enable
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace NuGet.ProjectModel
+{
+    /// <summary>
+    ///     Splits a string by a delimiter, producing substrings lazily during enumeration.
+    ///     Skips empty items, behaving equivalently to <see cref="string.Split(char[])"/> with
+    ///     <see cref="StringSplitOptions.RemoveEmptyEntries"/>.
+    /// </summary>
+    /// <remarks>
+    ///     Unlike <see cref="string.Split(char[])"/> and overloads, <see cref="LazyStringSplit"/>
+    ///     does not allocate an array for the return, and allocates strings on demand during
+    ///     enumeration. A custom enumerator type is used so that the only allocations made are
+    ///     the substrings themselves. We also avoid the large internal arrays assigned by the
+    ///     methods on <see cref="string"/>.
+    /// </remarks>
+    internal readonly struct LazyStringSplit : IEnumerable<string>
+    {
+        private readonly string _input;
+        private readonly char _delimiter;
+
+        public LazyStringSplit(string input, char delimiter)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                throw new ArgumentNullException(nameof(input));
+            }
+
+            _input = input;
+            _delimiter = delimiter;
+        }
+
+        public Enumerator GetEnumerator() => new(this);
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        IEnumerator<string> IEnumerable<string>.GetEnumerator() => GetEnumerator();
+
+        public IEnumerable<T> Select<T>(Func<string, T> func)
+        {
+            foreach (string value in this)
+            {
+                yield return func(value);
+            }
+        }
+
+        public string First()
+        {
+            return FirstOrDefault() ?? throw new InvalidOperationException("Sequence is empty.");
+        }
+
+        public string? FirstOrDefault()
+        {
+            var enumerator = new Enumerator(this);
+            return enumerator.MoveNext() ? enumerator.Current : null;
+        }
+
+        public struct Enumerator : IEnumerator<string>
+        {
+            private readonly string _input;
+            private readonly char _delimiter;
+            private int _index;
+
+            internal Enumerator(in LazyStringSplit split)
+            {
+                _index = 0;
+                _input = split._input;
+                _delimiter = split._delimiter;
+                Current = null!;
+            }
+
+            public string Current { get; private set; }
+
+            public bool MoveNext()
+            {
+                while (_index != _input.Length)
+                {
+                    int delimiterIndex = _input.IndexOf(_delimiter, _index);
+
+                    if (delimiterIndex == -1)
+                    {
+                        Current = _input.Substring(_index);
+                        _index = _input.Length;
+                        return true;
+                    }
+
+                    int length = delimiterIndex - _index;
+
+                    if (length == 0)
+                    {
+                        _index++;
+                        continue;
+                    }
+
+                    Current = _input.Substring(_index, length);
+                    _index = delimiterIndex + 1;
+                    return true;
+                }
+
+                return false;
+            }
+
+            object IEnumerator.Current => Current;
+
+            void IEnumerator.Reset()
+            {
+                _index = 0;
+                Current = null!;
+            }
+
+            void IDisposable.Dispose() { }
+        }
+    }
+
+    internal static class LazyStringSplitExtensions
+    {
+        /// <remarks>
+        ///     This extension method has special knowledge of the <see cref="LazyStringSplit"/> type and
+        ///     can compute its result without allocation.
+        /// </remarks>
+        /// <inheritdoc cref="Enumerable.FirstOrDefault{TSource}(IEnumerable{TSource})"/>
+        public static string? FirstOrDefault(this LazyStringSplit lazyStringSplit)
+        {
+            LazyStringSplit.Enumerator enumerator = lazyStringSplit.GetEnumerator();
+
+            return enumerator.MoveNext()
+                ? enumerator.Current
+                : null;
+        }
+    }
+}

src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFileFormat.cs

@@ -6,6 +6,7 @@
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Text;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using NuGet.Common;
@@ -60,11 +61,10 @@ public LockFile Parse(string lockFileContent, string path)
 
         public LockFile Parse(string lockFileContent, ILogger log, string path)
         {
-            using (var reader = new StringReader(lockFileContent))
+            byte[] byteArray = Encoding.UTF8.GetBytes(lockFileContent);
+            using (var stream = new MemoryStream(byteArray))
             {
-#pragma warning disable CS0612 // Type or member is obsolete
-                return Read(reader, log, path);
-#pragma warning restore CS0612 // Type or member is obsolete
+                return Read(stream, log, path);
             }
         }
 
@@ -88,21 +88,51 @@ public LockFile Read(Stream stream, string path)
 
         public LockFile Read(Stream stream, ILogger log, string path)
         {
-            using (var textReader = new StreamReader(stream))
+            return Read(stream, log, path, EnvironmentVariableWrapper.Instance);
+        }
+
+        internal LockFile Read(string filePath, IEnvironmentVariableReader environmentVariableReader)
+        {
+            using (var stream = File.OpenRead(filePath))
             {
-#pragma warning disable CS0612 // Type or member is obsolete
-                return Read(textReader, log, path);
-#pragma warning restore CS0612 // Type or member is obsolete
+                return Read(stream, NullLogger.Instance, filePath, environmentVariableReader);
             }
         }
 
-        [Obsolete]
+        internal LockFile Parse(string lockFileContent, string path, IEnvironmentVariableReader environmentVariableReader)
+        {
+            byte[] byteArray = Encoding.UTF8.GetBytes(lockFileContent);
+            using (var stream = new MemoryStream(byteArray))
+            {
+                return Read(stream, NullLogger.Instance, path, environmentVariableReader);
+            }
+        }
+
+        internal LockFile Read(Stream stream, ILogger log, string path, IEnvironmentVariableReader environmentVariableReader)
+        {
+            var useNj = environmentVariableReader.GetEnvironmentVariable("NUGET_EXPERIMENTAL_USE_NJ_FOR_FILE_PARSING");
+            if (string.IsNullOrEmpty(useNj) || useNj.Equals("false", StringComparison.OrdinalIgnoreCase))
+            {
+                return Utf8JsonRead(stream, log, path);
+            }
+            else
+            {
+                using (var reader = new StreamReader(stream))
+                {
+#pragma warning disable CS0618 // Type or member is obsolete
+                    return Read(reader, log, path);
+#pragma warning restore CS0618 // Type or member is obsolete
+                }
+            }
+        }
+
+        [Obsolete("This method is deprecated. Use Read(Stream, string) instead.")]
         public LockFile Read(TextReader reader, string path)
         {
             return Read(reader, NullLogger.Instance, path);
         }
 
-        [Obsolete]
+        [Obsolete("This method is deprecated. Use Read(Stream, ILogger, string) instead.")]
         public LockFile Read(TextReader reader, ILogger log, string path)
         {
             try
@@ -167,6 +197,29 @@ public string Render(LockFile lockFile)
             }
         }
 
+        private LockFile Utf8JsonRead(Stream stream, ILogger log, string path)
+        {
+            try
+            {
+                var lockFile = JsonUtility.LoadJson<LockFile>(stream, Utf8JsonReaderExtensions.LockFileConverter);
+                lockFile.Path = path;
+                return lockFile;
+            }
+            catch (Exception ex)
+            {
+                log.LogInformation(string.Format(CultureInfo.CurrentCulture,
+                    Strings.Log_ErrorReadingLockFile,
+                    path, ex.Message));
+
+                // Ran into parsing errors, mark it as unlocked and out-of-date
+                return new LockFile
+                {
+                    Version = int.MinValue,
+                    Path = path
+                };
+            }
+        }
+
         [Obsolete]
         private static LockFile ReadLockFile(JObject cursor, string path)
         {

src/NuGet.Core/NuGet.ProjectModel/LockFile/Utf8JsonStreamAssetsLogMessageConverter.cs

@@ -0,0 +1,131 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.Json;
+using NuGet.Common;
+
+namespace NuGet.ProjectModel
+{
+    /// <summary>
+    /// A <see cref="JsonStreamReaderConverter{T}"/> to allow read JSON into <see cref="AssetsLogMessage"/>
+    /// </summary>
+    internal class Utf8JsonStreamAssetsLogMessageConverter : IUtf8JsonStreamReaderConverter<AssetsLogMessage>
+    {
+        private static readonly byte[] LevelPropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.LEVEL);
+        private static readonly byte[] CodePropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.CODE);
+        private static readonly byte[] WarningLevelPropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.WARNING_LEVEL);
+        private static readonly byte[] FilePathPropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.FILE_PATH);
+        private static readonly byte[] StartLineNumberPropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.START_LINE_NUMBER);
+        private static readonly byte[] StartColumnNumberPropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.START_COLUMN_NUMBER);
+        private static readonly byte[] EndLineNumberPropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.END_LINE_NUMBER);
+        private static readonly byte[] EndColumnNumberPropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.END_COLUMN_NUMBER);
+        private static readonly byte[] MessagePropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.MESSAGE);
+        private static readonly byte[] LibraryIdPropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.LIBRARY_ID);
+        private static readonly byte[] TargetGraphsPropertyName = Encoding.UTF8.GetBytes(LogMessageProperties.TARGET_GRAPHS);
+
+        public AssetsLogMessage Read(ref Utf8JsonStreamReader reader)
+        {
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException("Expected StartObject, found " + reader.TokenType);
+            }
+
+            var isValid = true;
+            LogLevel level = default;
+            NuGetLogCode code = default;
+            //matching default warning level when AssetLogMessage object is created
+            WarningLevel warningLevel = WarningLevel.Severe;
+            string message = default;
+            string filePath = default;
+            int startLineNumber = default;
+            int startColNumber = default;
+            int endLineNumber = default;
+            int endColNumber = default;
+            string libraryId = default;
+            IReadOnlyList<string> targetGraphs = null;
+
+            while (reader.Read() && reader.TokenType == JsonTokenType.PropertyName)
+            {
+                if (!isValid)
+                {
+                    reader.Skip();
+                }
+                if (reader.ValueTextEquals(LevelPropertyName))
+                {
+                    var levelString = reader.ReadNextTokenAsString();
+                    isValid &= Enum.TryParse(levelString, out level);
+                }
+                else if (reader.ValueTextEquals(CodePropertyName))
+                {
+                    var codeString = reader.ReadNextTokenAsString();
+                    isValid &= Enum.TryParse(codeString, out code);
+                }
+                else if (reader.ValueTextEquals(WarningLevelPropertyName))
+                {
+                    reader.Read();
+                    warningLevel = (WarningLevel)Enum.ToObject(typeof(WarningLevel), reader.GetInt32());
+                }
+                else if (reader.ValueTextEquals(FilePathPropertyName))
+                {
+                    filePath = reader.ReadNextTokenAsString();
+                }
+                else if (reader.ValueTextEquals(StartLineNumberPropertyName))
+                {
+                    reader.Read();
+                    startLineNumber = reader.GetInt32();
+                }
+                else if (reader.ValueTextEquals(StartColumnNumberPropertyName))
+                {
+                    reader.Read();
+                    startColNumber = reader.GetInt32();
+                }
+                else if (reader.ValueTextEquals(EndLineNumberPropertyName))
+                {
+                    reader.Read();
+                    endLineNumber = reader.GetInt32();
+                }
+                else if (reader.ValueTextEquals(EndColumnNumberPropertyName))
+                {
+                    reader.Read();
+                    endColNumber = reader.GetInt32();
+                }
+                else if (reader.ValueTextEquals(MessagePropertyName))
+                {
+                    message = reader.ReadNextTokenAsString();
+                }
+                else if (reader.ValueTextEquals(LibraryIdPropertyName))
+                {
+                    libraryId = reader.ReadNextTokenAsString();
+                }
+                else if (reader.ValueTextEquals(TargetGraphsPropertyName))
+                {
+                    reader.Read();
+                    targetGraphs = (List<string>)reader.ReadStringArrayAsIList();
+                }
+                else
+                {
+                    reader.Skip();
+                }
+            }
+            if (isValid)
+            {
+                var assetLogMessage = new AssetsLogMessage(level, code, message)
+                {
+                    TargetGraphs = targetGraphs ?? Array.Empty<string>(),
+                    FilePath = filePath,
+                    EndColumnNumber = endColNumber,
+                    EndLineNumber = endLineNumber,
+                    LibraryId = libraryId,
+                    StartColumnNumber = startColNumber,
+                    StartLineNumber = startLineNumber,
+                    WarningLevel = warningLevel
+                };
+                return assetLogMessage;
+            }
+            return null;
+        }
+    }
+}