First major update for 2017

While we haven’t made many public announcements since CppCon 2016, we have been hard at work on the next major update to C++/WinRT and in anticipation of releasing the cppwinrt.exe compiler to the public. Today’s update on GitHub is the result of months of hard work from our small team. It’s also an early look at what you’ll soon get directly from the Windows SDK.

https://github.com/microsoft/cppwinrt

What’s new

C++17

This update takes advantage of many improvements in C++17 to simplify and improve the quality of the library. These are only possible thanks to much hard work on the part of the Visual C++ team and delivered in the Visual Studio 2017 15.3 release. These include:

  • Simpler static_assert
  • Nested namespace definitions
  • constexpr functions
  • if constexpr
  • optional
  • string_view
  • __has_include
  • Logical operator traits

Coroutines

The base library has been updated to reflect the latest coroutine draft standard as we continue to track the progress of this new language feature.

Clang

While Visual C++ continues to be our primary target, we use Clang as our secondary compiler to ensure standard conformance. Many small changes have been made in this update to support Clang builds and to fix correctness bugs that were only found with Clang builds.

Support for [[deprecated]]

The C++/WinRT language projection now reports on any deprecated Windows APIs via the standard [[deprecated]] attribute. For example, the following code will produce a C++ compiler error:

using namespace Windows::Storage::Pickers;

FileOpenPicker::ResumePickSingleFileAsync();

error C4996: ‘winrt::Windows::Storage::Pickers::FileOpenPicker::ResumePickSingleFileAsync’: Instead, use PickSingleFileAsync

Arguably, this should be a warning, but the Visual C++ compiler currently treats it as an error.

Improved support for WinRT error origination, propagation, chaining, and extensibility

This is largely an improvement to enable the Windows Runtime to produce more coherent crash dumps for postmortem debugging, but a few small changes inside the C++/WinRT exception type – winrt::hresult_error – have also been made to provide improved error messages during live debugging. The debugger team has also done work to make it easier to debug errors that occur in a brokered process.

Improved code gen (fewer instructions) and build throughput

The C++/WinRT compiler now produces considerably smaller headers by omitting a lot of type information from internal type projections that weren’t adding any value and were only causing the C++ compiler to do more work unnecessarily. In addition, the code we generate for a few input parameter bindings now results in noticeably fewer CPU instructions, resulting in small binaries. This includes high-traffic types such as strings and collections.

Support for compile-time generic GUID calculation

This is one of the biggest improvements in this update. Previously, any generic interface that was not defined in metadata lacked a specialization informing the projection of the GUID for that particular interface specialization. For example:

using namespace Windows::Foundation::Collections;

IMap<hstring, float> map;

If you happened to use the map and the compiler could not find an appropriate specialization providing the GUID, a cryptic compiler error was produced. Even if you could recognize the problem, determining the correct GUID to assign to the specialization was non-trivial and largely undocumented. This update now codifies the algorithm for determining the GUID for arbitrary specializations purely in constexpr functions that C++/WinRT uses internally to compute GUIDs at compile-time as needed. This solves what is likely our top usability concern with C++/WinRT. It also provides a great stress test for the compiler. 🙂

Many thanks to Harry Pierson for building the first Clang prototype and proving that it could be done!

Simplified ABI interop

As we’ve improved the quality and maturity of the projection, we’ve also reduced the need for a developer to access the ABI. As such, the ABI generated by the C++/WinRT compiler is no longer something that we would like you to use. There simply isn’t any good reason for that and it allows us to optimize it for our own internal use to give you the fastest possible builds.

While the C++/WinRT language projection is designed to provide no-compromise access to the modern Windows API, we recognize that there are instances where you need to interop with other libraries or tools that may not support C++/WinRT directly. The base library (winrt/base.h) provides a set of helper functions that assist in converting between C++/WinRT types and their equivalents in other language projections such as C++/CX or the Windows SDK headers produced by the MIDL compiler. Although we don’t directly support interop with other language projections, to avoid cross-dependencies, you can use the following helper functions to streamline the process as you migrate your code to C++/WinRT.

The following helper function may be used to convert a C++/WinRT object to
an equivalent C++/CX object:

template <typename T>
T^ to_cx(winrt::Windows::Foundation::IUnknown const& from)
{
    return safe_cast<T^>(reinterpret_cast<Platform::Object^>(winrt::get_abi(from)));
}

This function uses the winrt::get_abi function to retrieve the source
object’s underlying IUnknown pointer and then casts this to a C++/CX
object before using the C++/CX safe_cast extension to query for the
requested C++/CX type.

The following helper function may be used to convert a C++/CX object to
an equivalent C++/WinRT object:

template <typename T>
T from_cx(Platform::Object^ from)
{
    T to{ nullptr };

    winrt::check_hresult(reinterpret_cast<::IUnknown*>(from)
        ->QueryInterface(winrt::guid_of<T>(),
                         reinterpret_cast<void**>(winrt::put_abi(to))));

    return to;
}

This function casts the C++/CX object to retrieve the source object’s
underlying IUnknown pointer and then calls QueryInterface (the ABI
equivalent of the C++/CX safe_cast extension) to query for the requested
C++/WinRT type.

The following helper function may be used to convert an interface pointer
defined by the Windows SDK headers produced by the MIDL compiler to an
equivalent C++/WinRT object:

template <typename T>
T from_abi(::IUnknown* from)
{
    T to{ nullptr };

    winrt::check_hresult(from->QueryInterface(winrt::guid_of<T>(),
                                              reinterpret_cast<void**>(winrt::put_abi(to))));

    return to;
}

This function simply calls QueryInterface to query for the requested
C++/WinRT type.

A helper function is not required to convert from a C++/WinRT object to the
equivalent interface pointer defined by the Windows SDK headers produced by
the MIDL compiler. Simply use the as member function to query for the
requested interface. It will return a winrt::com_ptr object wrapping the
requested ABI type.

Simplified and more intuitive parameter binding for strings and collections

Strings, arrays, and collections all present unique challenges to any language projection. C++/WinRT is unique in that it provides blazingly fast performance for all three, avoiding copies, and minimizing machine instructions at call sites. We also provide natural conversion support for std::wstring_view and most C++ standard library containers without introducing copies.

Removal of implementation details from winrt namespace

We have steadily cleaned up the base library to avoid leaking any unnecessary implementation details. The winrt namespace is now a lot leaner, exposing only those functions and types that you could conceivably need to use in order to make the most of C++/WinRT. Anything that begins with impl_ or is within the winrt::impl namespace should be considered an implementation detail subject to change at any time. We do not consider it a breaking change to rename or remove an implementation detail and that includes the use of the internal ABI used by C++/WinRT.

As soon as the Visual C++ compiler resolves a few more bugs, we plan to provide C++/WinRT as a C++ module. At that point, all of these implementation details will physically be unavailable as they will not be epxorted by the C++/WinRT module.

Automatic object identity and hashing support

We now provide intelligent object identy and hashing support for all C++/WinRT types so that you can easily use them as keys in standard containers like std::map and std::unordered_map.

Optimized agility implementation

C++/WinRT favors agile object implementations and so should you. We make it very simple to create agile objects and also provide the leanest possible implementation, reducing the overhead of (automatically) implementing IAgileObject and IMarshal to the point where instances of C++/WinRT types are considerably smaller than their WRL and C++/CX counterparts.

Optimized delegate implementation

WinRT delegates are likewise optimized for space so that they may be safely used as ABI-portable callbacks without much concern for their overhead.

Support for derived classes and binary composability in winrt::implements

The implements class template remains at the heart of much of the C++/WinRT language projection when it comes to authoring types. It has received many improvements to make it easier to implement complex WinRT types and particularly in support for composable types, such as those required by the Windows.UI APIs.

Default implementation of GetRuntimeClassName

You may notice that objects created with winrt::implements now provide a default implementation of GetRuntimeClassName that returns the metadata name for the first interface being implemented. In many cases, this is sufficient to support the runtime, but you can of course override this with your own class names as necessary.

Support for disabling factory caching

C++/WinRT provides the fastest factory caching of any language projection. However, due to the unfortunate relationship between COM statics, the CRT, and the OS loader it is entirely possible that those statics are not torn down correctly when C++/WinRT is used within a DLL. We now provide an option to disable caching in those cases. We are also investigating how we might finally solve the problem of COM statics once and for all.

Experimental natvis support

The experimental natvis support makes it easier to interrogate C++/WinRT types from within a debugger.

Those are just a few highlights for now. We have worked hard to build a world-class language projection for the systems programmer and the app developer alike. Our goal is to enable C++ developers to write beautiful high-performance apps and components with incredible ease.

What’s next

In the coming weeks, we will release an insider build of the Windows SDK that will include both the C++/WinRT headers, targeting that particular build of the SDK, as well as the C++/WinRT compiler itself. You will be able to simply include the headers into any C++ project without having to worry about downloading the right set of headers from GitHub or worrying about include paths. Not only that, but you’ll be able to use the cppwinrt.exe compiler to generate your own projections and even create your own WinRT components with the same standard C++ that we all love.

Following the Windows SDK release, we plan to provide XAML compiler support and then C++/WinRT project support within Visual Studio.

Longer term, I’m working with the Visual C++ team to support the future of C++ including C++ modules, reflection, code synthesis, and metaclasses. It’s an exciting time to be a C++ developer on the Windows platform!

Credits

I would like to thank the team responsible for C++/WinRT this year: Scott Jones, Ryan Shepherd, Kevin Welton, Brent Rector, and Ben Kuhn. As always, I am indebted to the Visual C++ team for their incredible support. You can get a glimpse inside my relationship with the C++ team here from Andrew Pardoe’s comments here.

Kenny Kerr

3 thoughts on “First major update for 2017

  1. dbjsystems

    Truly ground breaking. At least in the context of a Windows Universe.

    I am interested in the wider picture though. The road map. The strategy. The architecture. The documentation. The diagrams. Where do I look?

    Kind regards …

    Reply
  2. ajorians

    Yay! I am looking forward to the updates!

    Regarding: Support for [[deprecated]] and it being an error there instead of a warning. If curious why it is an error and not a warning is because SDL Checks (https://msdn.microsoft.com/en-us/library/jj161081.aspx) is enabled by default which makes it an error. So you could turn SDL Checks off or perhaps add the command-line value “/wo4996” (https://msdn.microsoft.com/en-us/library/thxezb7y.aspx) and you’ll get a warning when you call a deprecated function. Though I agree it would be preferable to be a warning instead of an error by default.

    Reply
  3. dbjsystems

    Guys, I fully understand you are developers and not Public Relations specialist, but I do not understand how can we (the public) suffer the “radio silence” from WinRT project for months, to the point of wondering if project is about to be shut down…

    This project is the core of the cores of Windows future and lack of communication is astonishing.

    Kind regards Mr Dusan Jovanovic, Master Arch, TOGAF

    Sent from Mail for Windows 10

    Reply

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s