react-native-windows 0.0.0-canary.95 → 0.0.0-canary.950

package/Microsoft.ReactNative.Managed.CodeGen/ReactNativeNames.cs

@@ -0,0 +1,116 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Microsoft.CodeAnalysis;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace Microsoft.ReactNative.Managed.CodeGen
+{
+  /// <summary>
+  /// Naming constants used for analyzing and generating code.
+  /// </summary>
+  internal class ReactNativeNames
+  {
+    /// <summary>
+    /// The prefix when reporting errors to the user. i.e. RN100
+    /// </summary>
+    public const string ErrorCodePrefix = "RN";
+
+    /// <summary>
+    /// The category used when reporting errors for code generation
+    /// </summary>
+    public const string ErrorCategory = "CodeGen";
+
+    /// <nodoc />
+    public const string DefaultEventEmitterName = "RCTDeviceEventEmitter";
+
+    public static readonly SyntaxToken PackageBuilderId = Identifier("packageBuilder");
+    public static readonly SyntaxToken ModuleBuilder = Identifier("moduleBuilder");
+    public static readonly SyntaxToken Module = Identifier("module");
+    public static readonly SyntaxToken CreatePackage = Identifier("CreatePackage");
+    public static readonly SyntaxToken CreatePackageImplementation = Identifier("CreatePackageImplementation");
+    public static readonly SyntaxToken AddViewManager = Identifier("AddViewManager");
+    public static readonly SyntaxToken AddModule = Identifier("AddModule");
+
+    public static readonly SyntaxToken AddInitializer = Identifier("AddInitializer");
+    public static readonly SyntaxToken AddConstantProvider = Identifier("AddConstantProvider");
+    public static readonly SyntaxToken AddMethod = Identifier("AddMethod");
+    public static readonly SyntaxToken AddSyncMethod = Identifier("AddSyncMethod");
+
+    public static readonly SyntaxToken CreateViewManagers = Identifier("CreateViewManagers");
+    public static readonly SyntaxToken CreateModules = Identifier("CreateModules");
+    public static readonly SyntaxToken CreateSerializers = Identifier("CreateSerializers");
+    public static readonly SyntaxToken CreateEnumSerializers = Identifier("CreateEnumSerializers");
+    public static readonly SyntaxToken CreateObjectSerializers = Identifier("CreateObjectSerializers");
+    public static readonly SyntaxToken RegisterExtensionReaders = Identifier("RegisterExtensionReaders");
+    public static readonly SyntaxToken RegisterExtensionWriter = Identifier("RegisterExtensionWriter");
+
+    public static readonly SyntaxToken WriteObjectBeginMethodName = Identifier("WriteObjectBegin");
+    public static readonly SyntaxToken WriteObjectPropertyMethodName = Identifier("WriteObjectProperty");
+    public static readonly SyntaxToken WriteObjectEndMethodName = Identifier("WriteObjectEnd");
+    public static readonly SyntaxToken WriteNullMethodName = Identifier("WriteNull");
+    public static readonly SyntaxToken CallJSFunctionFunctionName = Identifier("CallJSFunction");
+    public static readonly SyntaxToken EmitJSEventFunctionName = Identifier("EmitJSEvent");
+    public static readonly SyntaxToken WriteArgsMethodName = Identifier("WriteArgs");
+    public static readonly SyntaxToken ReadArgsMethodName = Identifier("ReadArgs");
+    public static readonly SyntaxToken RegisterAssemblyMethodName = Identifier("RegisterAssembly");
+    public static readonly SyntaxToken GetTypeMethodName = Identifier("GetType");
+    public static readonly SyntaxToken ReadValueMethodName = Identifier("ReadValue");
+    public static readonly SyntaxToken WriteValueMethodName = Identifier("WriteValue");
+    public static readonly SyntaxToken ValueTypePropertyName = Identifier("ValueType");
+    public static readonly SyntaxToken GetNextObjectPropertyMethodName = Identifier("GetNextObjectProperty");
+    public static readonly SyntaxToken ObjectEnumMemberName = Identifier("Object");
+    public static readonly SyntaxToken RegisterCodeGeneratorGenericExtensionMethod = Identifier("RegisterCodeGeneratorGenericExtensionMethod");
+    public static readonly SyntaxToken WritePropertiesMethodName = Identifier("WriteProperties");
+
+    public static readonly SyntaxToken ConstantsLocalName = Identifier("constants");
+    public static readonly SyntaxToken ProviderLocalName = Identifier("provider");
+    public static readonly SyntaxToken WriterLocalName = Identifier("writer");
+    public static readonly SyntaxToken ReaderLocalName = Identifier("reader");
+    public static readonly SyntaxToken ResolveLocalName = Identifier("resolve");
+    public static readonly SyntaxToken RejectLocalName = Identifier("reject");
+    public static readonly SyntaxToken ReactContextLocalName = Identifier("reactContext");
+    public static readonly SyntaxToken PropertyNameLocalName = Identifier("propertyName");
+    public static readonly SyntaxToken ResultLocalName = Identifier("result");
+    public static readonly SyntaxToken ValueLocalName = Identifier("value");
+    public static readonly SyntaxToken AssemblyLocalName = Identifier("assembly");
+    public static readonly SyntaxToken AssemblyPropertyName = Identifier("Assembly");
+
+    public static readonly SyntaxToken ContinueWith = Identifier("ContinueWith");
+    public static readonly SyntaxToken TaskLocalName = Identifier("task");
+
+    public static readonly SyntaxToken Arg0LocalName = Identifier("arg0");
+    public static readonly SyntaxToken Arg1LocalName = Identifier("arg1");
+    public static readonly SyntaxToken Arg2LocalName = Identifier("arg2");
+    public static readonly SyntaxToken Arg3LocalName = Identifier("arg3");
+    public static readonly SyntaxToken Arg4LocalName = Identifier("arg4");
+    public static readonly SyntaxToken Arg5LocalName = Identifier("arg5");
+    public static readonly SyntaxToken Arg6LocalName = Identifier("arg6");
+    public static readonly SyntaxToken Arg7LocalName = Identifier("arg7");
+    public static readonly SyntaxToken Arg8LocalName = Identifier("arg8");
+    public static readonly SyntaxToken Arg9LocalName = Identifier("arg9");
+
+    public static readonly SyntaxToken[] ArgLocalNames = new SyntaxToken[] {
+      Arg0LocalName, Arg1LocalName, Arg2LocalName, Arg3LocalName,
+      Arg4LocalName, Arg5LocalName, Arg6LocalName, Arg7LocalName,
+      Arg8LocalName, Arg9LocalName
+    };
+
+    public static readonly SyntaxToken Value0LocalName = Identifier("value0");
+    public static readonly SyntaxToken Value1LocalName = Identifier("value1");
+    public static readonly SyntaxToken Value2LocalName = Identifier("value2");
+    public static readonly SyntaxToken Value3LocalName = Identifier("value3");
+    public static readonly SyntaxToken Value4LocalName = Identifier("value4");
+    public static readonly SyntaxToken Value5LocalName = Identifier("value5");
+    public static readonly SyntaxToken Value6LocalName = Identifier("value6");
+    public static readonly SyntaxToken Value7LocalName = Identifier("value7");
+    public static readonly SyntaxToken Value8LocalName = Identifier("value8");
+    public static readonly SyntaxToken Value9LocalName = Identifier("value9");
+
+    public static readonly SyntaxToken[] ValueLocalNames = new SyntaxToken[] {
+      Value0LocalName, Value1LocalName, Value2LocalName, Value3LocalName,
+      Value4LocalName, Value5LocalName, Value6LocalName, Value7LocalName,
+      Value8LocalName, Value9LocalName
+    };
+  }
+}

package/Microsoft.ReactNative.Managed.CodeGen/SyntaxHelpers.cs

@@ -0,0 +1,155 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+
+namespace Microsoft.ReactNative.Managed.CodeGen
+{
+  /// <summary>
+  /// Roslyn has a set of static and extension methods to help create syntax Trees
+  /// This class adds some extra convenience helpers. The method names typically follow the
+  /// naming convention used in Roslyn but sets common defaults.
+  /// </summary>
+  public static class SyntaxHelpers
+  {
+    private static readonly SymbolDisplayFormat s_symbolFormat = SymbolDisplayFormat.FullyQualifiedFormat;
+
+    public static TypeSyntax ToTypeSyntax(this ISymbol symbol)
+    {
+      return SyntaxFactory.ParseTypeName(symbol.ToDisplayString(s_symbolFormat));
+    }
+
+    internal static ExpressionSyntax LiteralExpression(string value)
+    {
+      // generates:
+      //  "value"
+      return SyntaxFactory.LiteralExpression(
+        SyntaxKind.StringLiteralExpression,
+        SyntaxFactory.Literal(value));
+    }
+
+    internal static ExpressionStatementSyntax InvocationStatement(SyntaxToken methodName, params ExpressionSyntax[] arguments)
+    {
+      return InvocationStatement(SyntaxFactory.IdentifierName(methodName), arguments);
+    }
+
+    internal static ExpressionSyntax MemberAccessExpression(ExpressionSyntax instance, SyntaxToken member)
+    {
+      return SyntaxFactory.MemberAccessExpression(
+        SyntaxKind.SimpleMemberAccessExpression,
+        instance,
+        SyntaxFactory.IdentifierName(member));
+    }
+
+    internal static ExpressionSyntax MemberAccessExpression(SyntaxToken instance, SyntaxToken member)
+    {
+      return SyntaxFactory.MemberAccessExpression(
+        SyntaxKind.SimpleMemberAccessExpression,
+        SyntaxFactory.IdentifierName(instance),
+        SyntaxFactory.IdentifierName(member));
+    }
+
+    internal static ExpressionSyntax MemberAccessExpression(ISymbol type, SyntaxToken member)
+    {
+      return SyntaxFactory.MemberAccessExpression(
+        SyntaxKind.SimpleMemberAccessExpression,
+        type.ToTypeSyntax(),
+        SyntaxFactory.IdentifierName(member));
+    }
+
+    internal static StatementSyntax LocalDeclarationStatement(ISymbol type, SyntaxToken variableName, ExpressionSyntax initializer)
+    {
+      return SyntaxFactory.LocalDeclarationStatement(
+        SyntaxFactory.VariableDeclaration(
+           type.ToTypeSyntax())
+          .AddVariables(
+            SyntaxFactory.VariableDeclarator(variableName)
+              .WithInitializer(
+                SyntaxFactory.EqualsValueClause(
+                  initializer))));
+    }
+
+    internal static StatementSyntax LocalDeclarationStatement(SyntaxToken variableName, ExpressionSyntax initializer)
+    {
+      return SyntaxFactory.LocalDeclarationStatement(
+        SyntaxFactory.VariableDeclaration(
+            SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("var")))
+          .AddVariables(
+            SyntaxFactory.VariableDeclarator(variableName)
+              .WithInitializer(
+                SyntaxFactory.EqualsValueClause(
+                  initializer))));
+    }
+
+    internal static ExpressionStatementSyntax InvocationStatement(ExpressionSyntax method, params ExpressionSyntax[] arguments)
+    {
+      return InvocationStatement(method, arguments.Select(arg => SyntaxFactory.Argument(arg)));
+    }
+
+    internal static ExpressionStatementSyntax InvocationStatement(ExpressionSyntax method, IEnumerable<ArgumentSyntax> arguments)
+    {
+      // generates
+      //  method(arg1, arg2);
+      return SyntaxFactory.ExpressionStatement(InvocationExpression(method, arguments));
+    }
+
+    internal static ExpressionSyntax InvocationExpression(ExpressionSyntax method, params ExpressionSyntax[] arguments)
+    {
+      return InvocationExpression(method, arguments.AsEnumerable());
+    }
+
+    internal static ExpressionSyntax InvocationExpression(ExpressionSyntax method, IEnumerable<ExpressionSyntax> arguments)
+    {
+      return InvocationExpression(method, arguments.Select(arg => SyntaxFactory.Argument(arg)));
+    }
+
+    internal static ExpressionSyntax InvocationExpression(ExpressionSyntax method, IEnumerable<ArgumentSyntax> arguments)
+    {
+      // generates
+      //  method(arg1, arg2);
+      return SyntaxFactory.InvocationExpression(method)
+        .WithArgumentList(
+          SyntaxFactory.ArgumentList(
+            SyntaxFactory.SeparatedList<ArgumentSyntax>(
+              arguments)));
+    }
+
+    internal static ExpressionSyntax ObjectCreationExpression(ITypeSymbol symbol, params ExpressionSyntax[] arguments)
+    {
+      return SyntaxFactory
+        .ObjectCreationExpression(symbol.ToTypeSyntax())
+        .WithArgumentList(
+          SyntaxFactory.ArgumentList(
+            SyntaxFactory.SeparatedList<ArgumentSyntax>(
+              arguments.Select(arg => SyntaxFactory.Argument(arg)))));
+    }
+
+    internal static ParameterListSyntax ParameterList(params ParameterSyntax[] parameters)
+    {
+      return SyntaxFactory.ParameterList(
+        SyntaxFactory.SeparatedList<ParameterSyntax>(
+          parameters));
+    }
+
+    internal static GenericNameSyntax GenericName(SyntaxToken identifier, params TypeSyntax[] types)
+    {
+      return SyntaxFactory
+        .GenericName(identifier)
+        .WithTypeArgumentList(
+          SyntaxFactory.TypeArgumentList(
+            SyntaxFactory.SeparatedList<TypeSyntax>(
+              types)));
+    }
+
+    internal static Location GetLocation(this ISymbol symbol)
+    {
+      return symbol.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax(CancellationToken.None).GetLocation() ?? Location.None;
+    }
+  }
+}

package/Mso/Mso.vcxitems.filters

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
     <Filter Include="future">
       <UniqueIdentifier>{4a2ca748-edd3-4161-a833-233130d84d4e}</UniqueIdentifier>
@@ -422,4 +422,4 @@
       <Filter>dispatchQueue</Filter>
     </None>
   </ItemGroup>
-</Project>
+</Project>

package/Mso/activeObject/activeObject.h

@@ -56,7 +56,7 @@ struct ActiveObjectMakePolicy {
   static const bool IsNoExcept{true};
 
   template <typename T, typename TMemoryGuard, typename... TArgs>
-  static void Make(TMemoryGuard &memoryGuard, TArgs &&... args) noexcept;
+  static void Make(TMemoryGuard &memoryGuard, TArgs &&...args) noexcept;
 };
 
 //! Custom deleter to call Finalize() or FinalizeSync() from the associated queue.
@@ -106,10 +106,8 @@ struct ActiveObjectBase : IUnknown {
   template <class TCallback>
   void InvokeInQueue(TCallback &&callback) noexcept {
     using Callback = std::decay_t<TCallback>;
-    m_queue.InvokeElsePost([
-      weakThis = Mso::WeakPtr<ActiveObjectBase>{this},
-      callback = Callback{std::forward<TCallback>(callback)}
-    ]() mutable noexcept {
+    m_queue.InvokeElsePost([weakThis = Mso::WeakPtr<ActiveObjectBase>{this},
+                            callback = Callback{std::forward<TCallback>(callback)}]() mutable noexcept {
       if (auto strongThis = weakThis.GetStrongPtr()) {
         callback();
       }
@@ -121,19 +119,15 @@ struct ActiveObjectBase : IUnknown {
   template <class TCallback>
   void InvokeInQueueStrong(TCallback &&callback) noexcept {
     using Callback = std::decay_t<TCallback>;
-    m_queue.InvokeElsePost([
-      strongThis = Mso::CntPtr<ActiveObjectBase>{this},
-      callback = Callback{std::forward<TCallback>(callback)}
-    ]() mutable noexcept { callback(); });
+    m_queue.InvokeElsePost([strongThis = Mso::CntPtr<ActiveObjectBase>{this},
+                            callback = Callback{std::forward<TCallback>(callback)}]() mutable noexcept { callback(); });
   }
 
   template <class TCallback>
   void InvokeInQueueStrong(TCallback &&callback) const noexcept {
     using Callback = std::decay_t<TCallback>;
-    m_queue.InvokeElsePost([
-      strongThis = Mso::CntPtr<const ActiveObjectBase>{this},
-      callback = Callback{std::forward<TCallback>(callback)}
-    ]() mutable noexcept { callback(); });
+    m_queue.InvokeElsePost([strongThis = Mso::CntPtr<const ActiveObjectBase>{this},
+                            callback = Callback{std::forward<TCallback>(callback)}]() mutable noexcept { callback(); });
   }
 
   //! Returns true if method is called from the associated queue.
@@ -165,7 +159,7 @@ struct ActiveObjectBase : IUnknown {
 //=============================================================================================
 
 template <typename T, typename TMemoryGuard, typename... TArgs>
-/*static*/ void ActiveObjectMakePolicy::Make(TMemoryGuard &memoryGuard, TArgs &&... args) noexcept {
+/*static*/ void ActiveObjectMakePolicy::Make(TMemoryGuard &memoryGuard, TArgs &&...args) noexcept {
   memoryGuard.Obj = ::new (memoryGuard.ObjMemory) T{std::forward<TArgs>(args)...};
   memoryGuard.ObjMemory = nullptr; // Memory is now controlled by the object. Set to null to avoid memory destruction.
 

package/Mso/comUtil/IUnknownShim.h

@@ -10,6 +10,10 @@
 
 // This is needed for compiling with Clang on Windows as well
 MSO_STRUCT_GUID(IUnknown, "00000000-0000-0000-C000-000000000046")
+MSO_STRUCT_GUID(IMarshal, "00000003-0000-0000-C000-000000000046")
+MSO_STRUCT_GUID(IWeakReference, "00000037-0000-0000-C000-000000000046")
+MSO_STRUCT_GUID(IGlobalInterfaceTable, "00000146-0000-0000-C000-000000000046")
+MSO_STRUCT_GUID(IAgileObject, "94ea2b94-e9cc-49e0-c0ff-ee64ca8f5b90")
 
 #if !defined(MS_TARGET_POSIX)
 

package/Mso/comUtil/qiCastCore.h

@@ -62,10 +62,6 @@ Mso::CntPtr<TTarget> qi_cast(const TSource *piSource, const IID &riid = __uuidof
   return qi_cast<TTarget, TSource *>(piSourceNonConst, riid);
 }
 
-#pragma warning(push)
-#pragma warning(disable : 4995) // VerifyElseCrashSz gives "warning C4995: 'IsDebuggerPresent': name was marked as
-                                // #pragma deprecated"
-
 /**
   qi_cast_or_crash<Type>(source, optional riid)
 
@@ -92,8 +88,6 @@ Mso::CntPtr<TTarget> qi_cast_or_crash(const TSource *piSource, const IID &riid =
   return target;
 }
 
-#pragma warning(pop)
-
 /**
   simpleqi_cast<Type>(source, optional riid)
 

package/Mso/compilerAdapters/compilerFeatures.h

@@ -20,7 +20,7 @@
 
 // Check if compiler supports UUID
 #ifndef COMPILER_SUPPORTS_UUID
-#if defined(__clang__) || defined(__GNUC__)
+#if (defined(__APPLE__) && defined(__clang__)) || defined(__GNUC__)
 #define COMPILER_SUPPORTS_UUID 0
 #elif defined(_MSC_VER)
 #define COMPILER_SUPPORTS_UUID 1

package/Mso/compilerAdapters/cppMacros.h

@@ -29,11 +29,9 @@
   Make the macro act like a statement.
 */
 #ifndef __GNUC__
-#define Statement(x)                                                   \
-  __pragma(warning(push)) __pragma(warning(disable : 4127 25037)) do { \
-    x;                                                                 \
-  }                                                                    \
-  while (0)                                                            \
+#define Statement(x)                                                        \
+  __pragma(warning(push)) __pragma(warning(disable : 4127 25037)) do { x; } \
+  while (0)                                                                 \
   __pragma(warning(pop))
 #else
 #define Statement(x) \

package/Mso/compilerAdapters/functionDecorations.h

@@ -91,13 +91,13 @@
 
   struct IBank
   {
-    // Generate mock_TryWithdrawlUint32
-    LIBLET_MOCKNAME("TryWithdrawlUint32")
-    virtual bool TryWithdrawl(uint32_t amount) = 0;
+    // Generate mock_TryWithdrawalUint32
+    LIBLET_MOCKNAME("TryWithdrawalUint32")
+    virtual bool TryWithdrawal(uint32_t amount) = 0;
 
-    // Generate mock_TryWithdrawlFloat
-    LIBLET_MOCKNAME("TryWithdrawlFloat")
-    virtual bool TryWithdrawl(float amount) = 0;
+    // Generate mock_TryWithdrawalFloat
+    LIBLET_MOCKNAME("TryWithdrawalFloat")
+    virtual bool TryWithdrawal(float amount) = 0;
   };
 */
 #if defined(__clangpluginrunner__)

package/Mso/cppExtensions/autoRestore.h

@@ -15,17 +15,12 @@
 #ifdef __cplusplus
 // 4091: extern __declspec(dllimport)' : ignored on left of 'double' when no variable is declared
 // 4472: 'pointer_safety' is a native enum: add an access specifier (private/public) to declare a managed enum
-// 4996: 'wmemcpy': This function or variable may be unsafe. Consider using wmemcpy_s instead
 #pragma warning(push)
-#pragma warning(disable : 4091 4472 4996)
+#pragma warning(disable : 4091 4472)
 #include <memory>
 #pragma warning(pop)
 
-// 4996: 'wmemcpy': This function or variable may be unsafe. Consider using wmemcpy_s instead
-#pragma warning(push)
-#pragma warning(disable : 4996)
 #include <utility>
-#pragma warning(pop)
 
 namespace Mso {
 

package/Mso/debugAssertApi/debugAssertApi.h

@@ -61,7 +61,6 @@ if (FAssertDo(f)) { ... } // same as "if (f) { ... } else Assert(false);"
 /**
 Suppressed warnings in Assert macros:
   C4127 - if/while loop condition is a constant
-  C4018 - signed/unsigned compare was converted to unsigned/unsigned compare
   C4389 - operation involved signed/unsigned variables
    6239 - OACR left expression is always false
   25011 - OACR missing 'break' or '__fallthrough' statement
@@ -73,8 +72,7 @@ Suppressed warnings in Assert macros:
   25064 - OACR function called twice in macro
 */
 #define AssertDetails_Statement_Begin \
-  __pragma(warning(push))             \
-      __pragma(warning(disable : 4127 4018 4389 6239 25037 25038 25039 25041 25042 25064 25306)) do {
+  __pragma(warning(push)) __pragma(warning(disable : 4127 4389 6239 25037 25038 25039 25041 25042 25064 25306)) do {
 #define AssertDetails_Statement_End \
   }                                 \
   while (0)                         \

package/Mso/debugAssertApi/debugAssertDetails.h

@@ -65,7 +65,7 @@ __pragma(warning(suppress : 4472)) enum class AssertResult : uint32_t {
 #endif // DEBUG
 #endif // C++
 
-// TODO: move this abstraction into compilerAdapters? Except it depends on windows - hmm
+// TODO: move this abstraction into compilerAdapters? Except it depends on Windows - hmm
 #if defined(__clang__) || defined(__cplusplus_cli) || defined(__INTELLISENSE__)
 #define AssertBreak(wzMsg) __debugbreak()
 #elif defined(_DBGRAISEASSERTIONFAILURE_)
@@ -97,7 +97,7 @@ static
 
   Converts variable arguments into the arg list format
 
-  Use a lamba function to generate a unique function providing storage of
+  Use a lambda function to generate a unique function providing storage of
   _fIgnore_ (for in-proc based assert management) and unique break address.
 */
 #define MsoAssertSzTagProcInline2(dwTag, szFile, iLine, wzAnnotation, szFmt, ...)                               \
@@ -109,8 +109,7 @@ static
           DeclareMsoAssertParams(dwTag, szFile, iLine);                                                         \
       params.framesToSkip++;                                                                                    \
       const int32_t _assertResult_ = MsoAssertSzTagProcInline(PassMsoAssertParams(params), szFmt, __VA_ARGS__); \
-      __pragma(warning(suppress : 4700)) /* MSVC is unhappy with this used in a loop conditional */             \
-          if (_assertResult_ == c_assertDebugBreak) {                                                           \
+      if (_assertResult_ == c_assertDebugBreak) {                                                               \
         AssertBreak(wzAnnotation);                                                                              \
       }                                                                                                         \
       _fIgnore_ = (_assertResult_ == c_assertAlwaysIgnore);                                                     \
@@ -209,7 +208,7 @@ static
   AssertDetails_Statement_End
 
 #define FAssertDoSucceededTag(expr, tag)                                              \
-  [&]() noexcept->bool {                                                              \
+  [&]() noexcept -> bool {                                                            \
     HRESULT _hr_ = (expr);                                                            \
     if (FAILED(_hr_)) {                                                               \
       if (MsoAssertSzTagProcInline(                                                   \
@@ -222,8 +221,7 @@ static
     }                                                                                 \
     return SUCCEEDED(_hr_);                                                           \
     OACR_WARNING_SUPPRESS(NOEXCEPT_FUNC_THROWS, "Ignore whether expr throws.");       \
-  }                                                                                   \
-  ()
+  }()
 
 #else
 

package/Mso/dispatchQueue/dispatchQueue.h

@@ -22,6 +22,7 @@ using DispatchTask = VoidFunctor;
 // Forward declarations
 struct DispatchLocalValueGuard;
 struct DispatchQueue;
+struct DispatchQueueSettings;
 struct DispatchSuspendGuard;
 struct DispatchTaskBatch;
 template <typename TInvoke, typename TCancel>
@@ -85,6 +86,13 @@ struct DispatchLocalValueGuard {
   void **m_tlsValue;
 };
 
+struct DispatchQueueSettings {
+  Mso::Functor<void(DispatchQueue const &)> TaskStarting;
+  Mso::Functor<void(DispatchQueue const &)> TaskCompleted;
+  Mso::Functor<void(DispatchQueue const &)> IdleWaitStarting;
+  Mso::Functor<void(DispatchQueue const &)> IdleWaitCompleted;
+};
+
 //! Serial or concurrent dispatch queue main API.
 //! Use Post or InvokeElsePost to post tasks for invocation.
 //! Use BeginTaskBatching to start tasks batching in current thread for the dispatch queue.
@@ -117,7 +125,7 @@ struct DispatchQueue {
   static DispatchQueue MakeSerialQueue() noexcept;
 
   //! Create new looper DispatchQueue on top of new std::thread. It owns the thread until shutdown.
-  static DispatchQueue MakeLooperQueue() noexcept;
+  static DispatchQueue MakeLooperQueue(DispatchQueueSettings const &settings = {}) noexcept;
 
   //! Get a dispatch queue for the current UI thread. The result is null if the UI thread has no system UI thread
   //! dispatcher.
@@ -300,7 +308,7 @@ struct IDispatchQueue : IUnknown {
 MSO_GUID(IDispatchQueueScheduler, "fd98f3c9-1343-4cbe-8758-a0322ffd253a")
 struct IDispatchQueueScheduler : IUnknown {
   //! Initializes scheduler by providing the dispatch queue service.
-  virtual void IntializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept = 0;
+  virtual void InitializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept = 0;
 
   //! True if the scheduler does processing in a serial order.
   virtual bool IsSerial() noexcept = 0;
@@ -368,8 +376,8 @@ struct IDispatchQueueService : IUnknown {
   virtual void UnlockLocalValue(void **tlsValue) noexcept = 0;
 
   //! Suspend task invocation and increment internal suspend count by one.
-  //! Note that we do not expose IsSuspeneded() method because the Suspend/Resume
-  //! methods can be called from different threads and using IsSuspeneded()
+  //! Note that we do not expose IsSuspended() method because the Suspend/Resume
+  //! methods can be called from different threads and using IsSuspended()
   //! could lead to errors because the status can be changed any time right after the check.
   virtual void Suspend() noexcept = 0;
 
@@ -417,7 +425,7 @@ struct IDispatchQueueStatic : IUnknown {
   virtual DispatchQueue MakeSerialQueue() noexcept = 0;
 
   //! Create new looper DispatchQueue on top of new std::thread. It owns the thread until shutdown.
-  virtual DispatchQueue MakeLooperQueue() noexcept = 0;
+  virtual DispatchQueue MakeLooperQueue(DispatchQueueSettings const &settings) noexcept = 0;
 
   //! Get a dispatch queue for the current UI thread. The result is null if the UI thread has no system UI thread
   //! dispatcher.
@@ -545,8 +553,8 @@ inline /*static*/ DispatchQueue DispatchQueue::MakeSerialQueue() noexcept {
   return IDispatchQueueStatic::Instance()->MakeSerialQueue();
 }
 
-inline /*static*/ DispatchQueue DispatchQueue::MakeLooperQueue() noexcept {
-  return IDispatchQueueStatic::Instance()->MakeLooperQueue();
+inline /*static*/ DispatchQueue DispatchQueue::MakeLooperQueue(DispatchQueueSettings const &settings) noexcept {
+  return IDispatchQueueStatic::Instance()->MakeLooperQueue(settings);
 }
 
 inline /*static*/ DispatchQueue DispatchQueue::GetCurrentUIThreadQueue() noexcept {
@@ -723,9 +731,14 @@ inline DispatchTaskImpl<TInvoke, TOnCancel>::~DispatchTaskImpl() noexcept {
   }
 }
 
+namespace details {
+template <typename>
+constexpr bool always_false = false;
+}
+
 template <typename T>
 inline void MustBeNoExceptVoidFunctor() {
-  static_assert(false, __FUNCTION__ ": not a noexcept callable functor returning void");
+  static_assert(details::always_false<T>, __FUNCTION__ ": not a noexcept callable functor returning void");
 }
 
 template <typename TInvoke, typename TOnCancel>

package/Mso/errorCode/errorProvider.h

@@ -28,7 +28,7 @@ class ErrorProvider final : public IErrorProvider {
   ErrorCode MakeErrorCode(const T &errorInfo) const noexcept;
 
   template <class TValue, class... TArgs>
-  Maybe<TValue> MakeMaybe(TArgs &&... errorArgs) const noexcept;
+  Maybe<TValue> MakeMaybe(TArgs &&...errorArgs) const noexcept;
 
   // TODO: deprecate this method in favor of TryGetErrorInfo
   bool IsOwnedErrorCode(const ErrorCode &errorCode) const noexcept;
@@ -87,7 +87,7 @@ ErrorCode ErrorProvider<T, GuidToken>::MakeErrorCode(const T &errorInfo) const n
 
 template <class T, class GuidToken>
 template <class TValue, class... TArgs>
-Maybe<TValue> ErrorProvider<T, GuidToken>::MakeMaybe(TArgs &&... errorArgs) const noexcept {
+Maybe<TValue> ErrorProvider<T, GuidToken>::MakeMaybe(TArgs &&...errorArgs) const noexcept {
   return Mso::Maybe<TValue>(MakeErrorCode(T(std::forward<TArgs>(errorArgs)...)));
 }
 

package/Mso/errorCode/maybe.h

@@ -46,14 +46,14 @@ class Maybe {
   _Allow_implicit_ctor_ Maybe(T &&value) noexcept;
 
   template <class... TArgs>
-  explicit Maybe(InPlaceTag, TArgs &&... args) noexcept;
+  explicit Maybe(InPlaceTag, TArgs &&...args) noexcept;
 
   template <
       class TItem,
       class... TArgs,
       class TDummy =
           typename std::enable_if<std::is_constructible<T, std::initializer_list<TItem> &, TArgs &&...>::value>::type>
-  explicit Maybe(InPlaceTag, std::initializer_list<TItem> il, TArgs &&... args) noexcept;
+  explicit Maybe(InPlaceTag, std::initializer_list<TItem> il, TArgs &&...args) noexcept;
 
   _Allow_implicit_ctor_ Maybe(const ErrorCode &error) noexcept;
   _Allow_implicit_ctor_ Maybe(ErrorCode &&error) noexcept;
@@ -163,13 +163,13 @@ Maybe<T>::Maybe(T &&value) noexcept {
 
 template <class T>
 template <class... TArgs>
-Maybe<T>::Maybe(InPlaceTag, TArgs &&... args) noexcept {
+Maybe<T>::Maybe(InPlaceTag, TArgs &&...args) noexcept {
   ::new (reinterpret_cast<T *>(&reinterpret_cast<char &>(m_value))) T(std::forward<TArgs>(args)...);
 }
 
 template <class T>
 template <class TItem, class... TArgs, class TDummy>
-Maybe<T>::Maybe(InPlaceTag, std::initializer_list<TItem> il, TArgs &&... args) noexcept {
+Maybe<T>::Maybe(InPlaceTag, std::initializer_list<TItem> il, TArgs &&...args) noexcept {
   ::new (reinterpret_cast<T *>(&reinterpret_cast<char &>(m_value))) T(il, std::forward<TArgs>(args)...);
 }