Improve nullable annotations for ILogger.BeginScope (#66960)

maxkoshevoi · web-flow · commit ea4ebaa3c516 · 2022-03-23T13:35:24.000-05:00
* BeginScope can return a null IDisposable. And TState is not nullable.
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
@@ -28,7 +28,7 @@ public partial interface IExternalScopeProvider
     }
     public partial interface ILogger
     {
-        System.IDisposable BeginScope<TState>(TState state);
+        System.IDisposable? BeginScope<TState>(TState state) where TState : notnull;
         bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel);
         void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter);
     }
@@ -55,7 +55,7 @@ public LogDefineOptions() { }
     }
     public static partial class LoggerExtensions
     {
-        public static System.IDisposable BeginScope(this Microsoft.Extensions.Logging.ILogger logger, string messageFormat, params object?[] args) { throw null; }
+        public static System.IDisposable? BeginScope(this Microsoft.Extensions.Logging.ILogger logger, string messageFormat, params object?[] args) { throw null; }
         public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { }
         public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { }
         public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, System.Exception? exception, string? message, params object?[] args) { }
@@ -100,13 +100,13 @@ public static partial class LoggerMessage
     {
         public static System.Action<Microsoft.Extensions.Logging.ILogger, System.Exception?> Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
         public static System.Action<Microsoft.Extensions.Logging.ILogger, System.Exception?> Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; }
-        public static System.Func<Microsoft.Extensions.Logging.ILogger, System.IDisposable> DefineScope(string formatString) { throw null; }
-        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, System.IDisposable> DefineScope<T1>(string formatString) { throw null; }
-        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, System.IDisposable> DefineScope<T1, T2>(string formatString) { throw null; }
-        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, System.IDisposable> DefineScope<T1, T2, T3>(string formatString) { throw null; }
-        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, System.IDisposable> DefineScope<T1, T2, T3, T4>(string formatString) { throw null; }
-        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, System.IDisposable> DefineScope<T1, T2, T3, T4, T5>(string formatString) { throw null; }
-        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, T6, System.IDisposable> DefineScope<T1, T2, T3, T4, T5, T6>(string formatString) { throw null; }
+        public static System.Func<Microsoft.Extensions.Logging.ILogger, System.IDisposable?> DefineScope(string formatString) { throw null; }
+        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, System.IDisposable?> DefineScope<T1>(string formatString) { throw null; }
+        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, System.IDisposable?> DefineScope<T1, T2>(string formatString) { throw null; }
+        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, System.IDisposable?> DefineScope<T1, T2, T3>(string formatString) { throw null; }
+        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, System.IDisposable?> DefineScope<T1, T2, T3, T4>(string formatString) { throw null; }
+        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, System.IDisposable?> DefineScope<T1, T2, T3, T4, T5>(string formatString) { throw null; }
+        public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, T6, System.IDisposable?> DefineScope<T1, T2, T3, T4, T5, T6>(string formatString) { throw null; }
         public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, System.Exception?> Define<T1>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
         public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, System.Exception?> Define<T1>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; }
         public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, System.Exception?> Define<T1, T2>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
@@ -134,7 +134,7 @@ public LoggerMessageAttribute(int eventId, Microsoft.Extensions.Logging.LogLevel
     public partial class Logger<T> : Microsoft.Extensions.Logging.ILogger, Microsoft.Extensions.Logging.ILogger<T>
     {
         public Logger(Microsoft.Extensions.Logging.ILoggerFactory factory) { }
-        System.IDisposable Microsoft.Extensions.Logging.ILogger.BeginScope<TState>(TState state) { throw null; }
+        System.IDisposable? Microsoft.Extensions.Logging.ILogger.BeginScope<TState>(TState state) { throw null; }
         bool Microsoft.Extensions.Logging.ILogger.IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }
         void Microsoft.Extensions.Logging.ILogger.Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { }
     }
@@ -168,7 +168,7 @@ public partial class NullLogger : Microsoft.Extensions.Logging.ILogger
     {
         internal NullLogger() { }
         public static Microsoft.Extensions.Logging.Abstractions.NullLogger Instance { get { throw null; } }
-        public System.IDisposable BeginScope<TState>(TState state) { throw null; }
+        public System.IDisposable BeginScope<TState>(TState state) where TState : notnull { throw null; }
         public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }
         public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { }
     }
@@ -191,7 +191,7 @@ public partial class NullLogger<T> : Microsoft.Extensions.Logging.ILogger, Micro
     {
         public static readonly Microsoft.Extensions.Logging.Abstractions.NullLogger<T> Instance;
         public NullLogger() { }
-        public System.IDisposable BeginScope<TState>(TState state) { throw null; }
+        public System.IDisposable BeginScope<TState>(TState state) where TState : notnull { throw null; }
         public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }
         public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { }
     }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/ILogger.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/ILogger.cs
@@ -35,6 +35,6 @@ public interface ILogger
         /// <param name="state">The identifier for the scope.</param>
         /// <typeparam name="TState">The type of the state to begin scope for.</typeparam>
         /// <returns>An <see cref="IDisposable"/> that ends the logical operation scope on dispose.</returns>
-        IDisposable BeginScope<TState>(TState state);
+        IDisposable? BeginScope<TState>(TState state) where TState : notnull;
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExtensions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExtensions.cs
@@ -402,7 +402,7 @@ public static void Log(this ILogger logger!!, LogLevel logLevel, EventId eventId
         /// {
         /// }
         /// </example>
-        public static IDisposable BeginScope(
+        public static IDisposable? BeginScope(
             this ILogger logger!!,
             string messageFormat,
             params object?[] args)
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerMessage.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerMessage.cs
@@ -18,7 +18,7 @@ public static class LoggerMessage
         /// </summary>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log scope.</returns>
-        public static Func<ILogger, IDisposable> DefineScope(string formatString)
+        public static Func<ILogger, IDisposable?> DefineScope(string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 0);
 
@@ -33,7 +33,7 @@ public static Func<ILogger, IDisposable> DefineScope(string formatString)
         /// <typeparam name="T1">The type of the first parameter passed to the named format string.</typeparam>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log scope.</returns>
-        public static Func<ILogger, T1, IDisposable> DefineScope<T1>(string formatString)
+        public static Func<ILogger, T1, IDisposable?> DefineScope<T1>(string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 1);
 
@@ -47,7 +47,7 @@ public static Func<ILogger, T1, IDisposable> DefineScope<T1>(string formatString
         /// <typeparam name="T2">The type of the second parameter passed to the named format string.</typeparam>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log scope.</returns>
-        public static Func<ILogger, T1, T2, IDisposable> DefineScope<T1, T2>(string formatString)
+        public static Func<ILogger, T1, T2, IDisposable?> DefineScope<T1, T2>(string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 2);
 
@@ -62,7 +62,7 @@ public static Func<ILogger, T1, T2, IDisposable> DefineScope<T1, T2>(string form
         /// <typeparam name="T3">The type of the third parameter passed to the named format string.</typeparam>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log scope.</returns>
-        public static Func<ILogger, T1, T2, T3, IDisposable> DefineScope<T1, T2, T3>(string formatString)
+        public static Func<ILogger, T1, T2, T3, IDisposable?> DefineScope<T1, T2, T3>(string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 3);
 
@@ -78,7 +78,7 @@ public static Func<ILogger, T1, T2, T3, IDisposable> DefineScope<T1, T2, T3>(str
         /// <typeparam name="T4">The type of the fourth parameter passed to the named format string.</typeparam>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log scope.</returns>
-        public static Func<ILogger, T1, T2, T3, T4, IDisposable> DefineScope<T1, T2, T3, T4>(string formatString)
+        public static Func<ILogger, T1, T2, T3, T4, IDisposable?> DefineScope<T1, T2, T3, T4>(string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 4);
 
@@ -95,7 +95,7 @@ public static Func<ILogger, T1, T2, T3, T4, IDisposable> DefineScope<T1, T2, T3,
         /// <typeparam name="T5">The type of the fifth parameter passed to the named format string.</typeparam>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log scope.</returns>
-        public static Func<ILogger, T1, T2, T3, T4, T5, IDisposable> DefineScope<T1, T2, T3, T4, T5>(string formatString)
+        public static Func<ILogger, T1, T2, T3, T4, T5, IDisposable?> DefineScope<T1, T2, T3, T4, T5>(string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 5);
 
@@ -113,7 +113,7 @@ public static Func<ILogger, T1, T2, T3, T4, T5, IDisposable> DefineScope<T1, T2,
         /// <typeparam name="T6">The type of the sixth parameter passed to the named format string.</typeparam>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log scope.</returns>
-        public static Func<ILogger, T1, T2, T3, T4, T5, T6, IDisposable> DefineScope<T1, T2, T3, T4, T5, T6>(string formatString)
+        public static Func<ILogger, T1, T2, T3, T4, T5, T6, IDisposable?> DefineScope<T1, T2, T3, T4, T5, T6>(string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 6);
 
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerT.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerT.cs
@@ -25,7 +25,7 @@ public Logger(ILoggerFactory factory!!)
         }
 
         /// <inheritdoc />
-        IDisposable ILogger.BeginScope<TState>(TState state)
+        IDisposable? ILogger.BeginScope<TState>(TState state)
         {
             return _logger.BeginScope(state);
         }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLogger.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLogger.cs
@@ -20,7 +20,7 @@ private NullLogger()
         }
 
         /// <inheritdoc />
-        public IDisposable BeginScope<TState>(TState state)
+        public IDisposable BeginScope<TState>(TState state) where TState : notnull
         {
             return NullScope.Instance;
         }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLoggerT.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLoggerT.cs
@@ -17,7 +17,7 @@ public class NullLogger<T> : ILogger<T>
         public static readonly NullLogger<T> Instance = new NullLogger<T>();
 
         /// <inheritdoc />
-        public IDisposable BeginScope<TState>(TState state)
+        public IDisposable BeginScope<TState>(TState state) where TState : notnull
         {
             return NullScope.Instance;
         }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/MockLogger.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/MockLogger.cs
@@ -35,7 +35,7 @@ public MockLogger()
             Reset();
         }
 
-        public IDisposable BeginScope<TState>(TState state)
+        public IDisposable BeginScope<TState>(TState state) where TState : notnull
         {
             return new Disposable();
         }
diff --git a/src/libraries/Microsoft.Extensions.Logging/src/Logger.cs b/src/libraries/Microsoft.Extensions.Logging/src/Logger.cs
@@ -111,7 +111,7 @@ static bool LoggerIsEnabled(LogLevel logLevel, ILogger logger, ref List<Exceptio
             }
         }
 
-        public IDisposable BeginScope<TState>(TState state)
+        public IDisposable? BeginScope<TState>(TState state) where TState : notnull
         {
             ScopeLogger[]? loggers = ScopeLoggers;
 
diff --git a/src/libraries/Microsoft.Extensions.Logging/src/LoggerInformation.cs b/src/libraries/Microsoft.Extensions.Logging/src/LoggerInformation.cs
@@ -57,7 +57,7 @@ public ScopeLogger(ILogger? logger, IExternalScopeProvider? externalScopeProvide
 
         public IExternalScopeProvider? ExternalScopeProvider { get; }
 
-        public IDisposable CreateScope<TState>(TState state)
+        public IDisposable? CreateScope<TState>(TState state) where TState : notnull
         {
             if (ExternalScopeProvider != null)
             {

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public partial interface IExternalScopeProvider`
`28`	`28`	`}`
`29`	`29`	`public partial interface ILogger`
`30`	`30`	`{`
`31`		`- System.IDisposable BeginScope<TState>(TState state);`
	`31`	`+ System.IDisposable? BeginScope<TState>(TState state) where TState : notnull;`
`32`	`32`	`bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel);`
`33`	`33`	`void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter);`
`34`	`34`	`}`
`@@ -55,7 +55,7 @@ public LogDefineOptions() { }`
`55`	`55`	`}`
`56`	`56`	`public static partial class LoggerExtensions`
`57`	`57`	`{`
`58`		`- public static System.IDisposable BeginScope(this Microsoft.Extensions.Logging.ILogger logger, string messageFormat, params object?[] args) { throw null; }`
	`58`	`+ public static System.IDisposable? BeginScope(this Microsoft.Extensions.Logging.ILogger logger, string messageFormat, params object?[] args) { throw null; }`
`59`	`59`	`public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { }`
`60`	`60`	`public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { }`
`61`	`61`	`public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, System.Exception? exception, string? message, params object?[] args) { }`
`@@ -100,13 +100,13 @@ public static partial class LoggerMessage`
`100`	`100`	`{`
`101`	`101`	`public static System.Action<Microsoft.Extensions.Logging.ILogger, System.Exception?> Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }`
`102`	`102`	`public static System.Action<Microsoft.Extensions.Logging.ILogger, System.Exception?> Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; }`
`103`		`- public static System.Func<Microsoft.Extensions.Logging.ILogger, System.IDisposable> DefineScope(string formatString) { throw null; }`
`104`		`- public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, System.IDisposable> DefineScope<T1>(string formatString) { throw null; }`
`105`		`- public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, System.IDisposable> DefineScope<T1, T2>(string formatString) { throw null; }`
`106`		`- public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, System.IDisposable> DefineScope<T1, T2, T3>(string formatString) { throw null; }`
`107`		`- public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, System.IDisposable> DefineScope<T1, T2, T3, T4>(string formatString) { throw null; }`
`108`		`- public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, System.IDisposable> DefineScope<T1, T2, T3, T4, T5>(string formatString) { throw null; }`
`109`		`- public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, T6, System.IDisposable> DefineScope<T1, T2, T3, T4, T5, T6>(string formatString) { throw null; }`
	`103`	`+ public static System.Func<Microsoft.Extensions.Logging.ILogger, System.IDisposable?> DefineScope(string formatString) { throw null; }`
	`104`	`+ public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, System.IDisposable?> DefineScope<T1>(string formatString) { throw null; }`
	`105`	`+ public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, System.IDisposable?> DefineScope<T1, T2>(string formatString) { throw null; }`
	`106`	`+ public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, System.IDisposable?> DefineScope<T1, T2, T3>(string formatString) { throw null; }`
	`107`	`+ public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, System.IDisposable?> DefineScope<T1, T2, T3, T4>(string formatString) { throw null; }`
	`108`	`+ public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, System.IDisposable?> DefineScope<T1, T2, T3, T4, T5>(string formatString) { throw null; }`
	`109`	`+ public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, T6, System.IDisposable?> DefineScope<T1, T2, T3, T4, T5, T6>(string formatString) { throw null; }`
`110`	`110`	`public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, System.Exception?> Define<T1>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }`
`111`	`111`	`public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, System.Exception?> Define<T1>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; }`
`112`	`112`	`public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, System.Exception?> Define<T1, T2>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }`
`@@ -134,7 +134,7 @@ public LoggerMessageAttribute(int eventId, Microsoft.Extensions.Logging.LogLevel`
`134`	`134`	`public partial class Logger<T> : Microsoft.Extensions.Logging.ILogger, Microsoft.Extensions.Logging.ILogger<T>`
`135`	`135`	`{`
`136`	`136`	`public Logger(Microsoft.Extensions.Logging.ILoggerFactory factory) { }`
`137`		`- System.IDisposable Microsoft.Extensions.Logging.ILogger.BeginScope<TState>(TState state) { throw null; }`
	`137`	`+ System.IDisposable? Microsoft.Extensions.Logging.ILogger.BeginScope<TState>(TState state) { throw null; }`
`138`	`138`	`bool Microsoft.Extensions.Logging.ILogger.IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }`
`139`	`139`	`void Microsoft.Extensions.Logging.ILogger.Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { }`
`140`	`140`	`}`
`@@ -168,7 +168,7 @@ public partial class NullLogger : Microsoft.Extensions.Logging.ILogger`
`168`	`168`	`{`
`169`	`169`	`internal NullLogger() { }`
`170`	`170`	`public static Microsoft.Extensions.Logging.Abstractions.NullLogger Instance { get { throw null; } }`
`171`		`- public System.IDisposable BeginScope<TState>(TState state) { throw null; }`
	`171`	`+ public System.IDisposable BeginScope<TState>(TState state) where TState : notnull { throw null; }`
`172`	`172`	`public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }`
`173`	`173`	`public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { }`
`174`	`174`	`}`
`@@ -191,7 +191,7 @@ public partial class NullLogger<T> : Microsoft.Extensions.Logging.ILogger, Micro`
`191`	`191`	`{`
`192`	`192`	`public static readonly Microsoft.Extensions.Logging.Abstractions.NullLogger<T> Instance;`
`193`	`193`	`public NullLogger() { }`
`194`		`- public System.IDisposable BeginScope<TState>(TState state) { throw null; }`
	`194`	`+ public System.IDisposable BeginScope<TState>(TState state) where TState : notnull { throw null; }`
`195`	`195`	`public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }`
`196`	`196`	`public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { }`
`197`	`197`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,6 @@ public interface ILogger`
`35`	`35`	`/// <param name="state">The identifier for the scope.</param>`
`36`	`36`	`/// <typeparam name="TState">The type of the state to begin scope for.</typeparam>`
`37`	`37`	`/// <returns>An <see cref="IDisposable"/> that ends the logical operation scope on dispose.</returns>`
`38`		`- IDisposable BeginScope<TState>(TState state);`
	`38`	`+ IDisposable? BeginScope<TState>(TState state) where TState : notnull;`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public Logger(ILoggerFactory factory!!)`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`/// <inheritdoc />`
`28`		`- IDisposable ILogger.BeginScope<TState>(TState state)`
	`28`	`+ IDisposable? ILogger.BeginScope<TState>(TState state)`
`29`	`29`	`{`
`30`	`30`	`return _logger.BeginScope(state);`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ private NullLogger()`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`/// <inheritdoc />`
`23`		`- public IDisposable BeginScope<TState>(TState state)`
	`23`	`+ public IDisposable BeginScope<TState>(TState state) where TState : notnull`
`24`	`24`	`{`
`25`	`25`	`return NullScope.Instance;`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public class NullLogger<T> : ILogger<T>`
`17`	`17`	`public static readonly NullLogger<T> Instance = new NullLogger<T>();`
`18`	`18`
`19`	`19`	`/// <inheritdoc />`
`20`		`- public IDisposable BeginScope<TState>(TState state)`
	`20`	`+ public IDisposable BeginScope<TState>(TState state) where TState : notnull`
`21`	`21`	`{`
`22`	`22`	`return NullScope.Instance;`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public MockLogger()`
`35`	`35`	`Reset();`
`36`	`36`	`}`
`37`	`37`
`38`		`- public IDisposable BeginScope<TState>(TState state)`
	`38`	`+ public IDisposable BeginScope<TState>(TState state) where TState : notnull`
`39`	`39`	`{`
`40`	`40`	`return new Disposable();`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ static bool LoggerIsEnabled(LogLevel logLevel, ILogger logger, ref List<Exceptio`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`114`		`- public IDisposable BeginScope<TState>(TState state)`
	`114`	`+ public IDisposable? BeginScope<TState>(TState state) where TState : notnull`
`115`	`115`	`{`
`116`	`116`	`ScopeLogger[]? loggers = ScopeLoggers;`
`117`	`117`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public ScopeLogger(ILogger? logger, IExternalScopeProvider? externalScopeProvide`
`57`	`57`
`58`	`58`	`public IExternalScopeProvider? ExternalScopeProvider { get; }`
`59`	`59`
`60`		`- public IDisposable CreateScope<TState>(TState state)`
	`60`	`+ public IDisposable? CreateScope<TState>(TState state) where TState : notnull`
`61`	`61`	`{`
`62`	`62`	`if (ExternalScopeProvider != null)`
`63`	`63`	`{`