[Tooling] [0/1] Refactor FrontendActionFactory::create() to return std::unique_ptr<>

[lebedev.ri]

Summary

Noticed during review of D41102.

I'm not sure whether there are any principal reasons why it returns raw owning pointer,
or it is just a old code that was not updated post-C++11.

I'm not too sure what testing i should do, because check-all is not error clean here for some reason,
but it does not appear asif those failures are related to these changes.

This is clang part.
Clang-tools-extra part is D43780.

[alexfh]

Awesome, thank you for this cleanup!

[lebedev.ri]

And reverted.

This broke gcc4.8 builds, compiler just segfaults:
http://lab.llvm.org:8011/builders/clang-atom-d525-fedora-rel/builds/14909

...
[72/368] Building CXX object tools/clang/tools/extra/clang-tidy/CMakeFiles/clangTidy.dir/ClangTidyOptions.cpp.o
[73/368] Building CXX object tools/clang/tools/extra/clang-tidy/android/CMakeFiles/clangTidyAndroidModule.dir/AndroidTidyModule.cpp.o
[74/368] Building CXX object tools/clang/tools/extra/clang-tidy/android/CMakeFiles/clangTidyAndroidModule.dir/CloexecAccept4Check.cpp.o
FAILED: /bin/ccache  g++  -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/clang/tools/clang-check -I/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/clang-check -I/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include -Itools/clang/include -I/usr/include/libxml2 -Iinclude -I/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/include -fPIC -fvisibility-inlines-hidden -std=c++11 -Wall -W -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wno-maybe-uninitialized -Wdelete-non-virtual-dtor -Wno-comment -ffunction-sections -fdata-sections -fno-common -Woverloaded-virtual -fno-strict-aliasing -O3    -UNDEBUG  -fno-exceptions -fno-rtti -MMD -MT tools/clang/tools/clang-check/CMakeFiles/clang-check.dir/ClangCheck.cpp.o -MF tools/clang/tools/clang-check/CMakeFiles/clang-check.dir/ClangCheck.cpp.o.d -o tools/clang/tools/clang-check/CMakeFiles/clang-check.dir/ClangCheck.cpp.o -c /export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/clang-check/ClangCheck.cpp
In file included from /export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/clang-check/ClangCheck.cpp:28:0:
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h: In instantiation of 'clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*)::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor::ConsumerFactoryAdaptor(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = {anonymous}::ClangCheckActionFactory]':
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/include/llvm/ADT/STLExtras.h:951:63:   required from 'typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), std::unique_ptr<T> >::type llvm::make_unique(Args&& ...) [with T = clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = {anonymous}::ClangCheckActionFactory]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor; Args = {{anonymous}::ClangCheckActionFactory*&, clang::tooling::SourceFileCallbacks*&}; typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), std::unique_ptr<T> >::type = std::unique_ptr<clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = {anonymous}::ClangCheckActionFactory]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor, std::default_delete<clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = {anonymous}::ClangCheckActionFactory]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor> >]'
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h:390:65:   required from 'std::unique_ptr<clang::FrontendAction> clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*)::FrontendActionFactoryAdapter::create() [with FactoryT = {anonymous}::ClangCheckActionFactory]'
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h:425:3:   required from 'std::unique_ptr<clang::tooling::FrontendActionFactory> clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = {anonymous}::ClangCheckActionFactory]'
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/clang-check/ClangCheck.cpp:183:61:   required from here
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h:396:7: internal compiler error: Segmentation fault
       ConsumerFactoryAdaptor(FactoryT *ConsumerFactory,
       ^
Please submit a full bug report,
with preprocessed source if appropriate.
See <http://bugzilla.redhat.com/bugzilla> for instructions.
Preprocessed source stored into /tmp/ccYe9Zii.out file, please attach this to your bugreport.
FAILED: /bin/ccache  g++  -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/clang/tools/extra/clang-reorder-fields/tool -I/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/extra/clang-reorder-fields/tool -I/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include -Itools/clang/include -I/usr/include/libxml2 -Iinclude -I/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/include -fPIC -fvisibility-inlines-hidden -std=c++11 -Wall -W -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wno-maybe-uninitialized -Wdelete-non-virtual-dtor -Wno-comment -ffunction-sections -fdata-sections -fno-common -Woverloaded-virtual -fno-strict-aliasing -O3    -UNDEBUG  -fno-exceptions -fno-rtti -MMD -MT tools/clang/tools/extra/clang-reorder-fields/tool/CMakeFiles/clang-reorder-fields.dir/ClangReorderFields.cpp.o -MF tools/clang/tools/extra/clang-reorder-fields/tool/CMakeFiles/clang-reorder-fields.dir/ClangReorderFields.cpp.o.d -o tools/clang/tools/extra/clang-reorder-fields/tool/CMakeFiles/clang-reorder-fields.dir/ClangReorderFields.cpp.o -c /export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/extra/clang-reorder-fields/tool/ClangReorderFields.cpp
In file included from /export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Refactoring.h:23:0,
                 from /export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/extra/clang-reorder-fields/tool/../ReorderFieldsAction.h:19,
                 from /export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/extra/clang-reorder-fields/tool/ClangReorderFields.cpp:15:
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h: In instantiation of 'clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*)::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor::ConsumerFactoryAdaptor(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::reorder_fields::ReorderFieldsAction]':
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/include/llvm/ADT/STLExtras.h:951:63:   required from 'typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), std::unique_ptr<T> >::type llvm::make_unique(Args&& ...) [with T = clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::reorder_fields::ReorderFieldsAction]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor; Args = {clang::reorder_fields::ReorderFieldsAction*&, clang::tooling::SourceFileCallbacks*&}; typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), std::unique_ptr<T> >::type = std::unique_ptr<clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::reorder_fields::ReorderFieldsAction]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor, std::default_delete<clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::reorder_fields::ReorderFieldsAction]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor> >]'
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h:390:65:   required from 'std::unique_ptr<clang::FrontendAction> clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*)::FrontendActionFactoryAdapter::create() [with FactoryT = clang::reorder_fields::ReorderFieldsAction]'
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h:425:3:   required from 'std::unique_ptr<clang::tooling::FrontendActionFactory> clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::reorder_fields::ReorderFieldsAction]'
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/extra/clang-reorder-fields/tool/ClangReorderFields.cpp:63:59:   required from here
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h:396:7: internal compiler error: Segmentation fault
       ConsumerFactoryAdaptor(FactoryT *ConsumerFactory,
       ^
Please submit a full bug report,
with preprocessed source if appropriate.
See <http://bugzilla.redhat.com/bugzilla> for instructions.
Preprocessed source stored into /tmp/ccfU168e.out file, please attach this to your bugreport.
FAILED: /bin/ccache  g++  -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/clang/tools/clang-rename -I/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/clang-rename -I/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include -Itools/clang/include -I/usr/include/libxml2 -Iinclude -I/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/include -fPIC -fvisibility-inlines-hidden -std=c++11 -Wall -W -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wno-maybe-uninitialized -Wdelete-non-virtual-dtor -Wno-comment -ffunction-sections -fdata-sections -fno-common -Woverloaded-virtual -fno-strict-aliasing -O3    -UNDEBUG  -fno-exceptions -fno-rtti -MMD -MT tools/clang/tools/clang-rename/CMakeFiles/clang-rename.dir/ClangRename.cpp.o -MF tools/clang/tools/clang-rename/CMakeFiles/clang-rename.dir/ClangRename.cpp.o.d -o tools/clang/tools/clang-rename/CMakeFiles/clang-rename.dir/ClangRename.cpp.o -c /export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/clang-rename/ClangRename.cpp
In file included from /export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Refactoring.h:23:0,
                 from /export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/clang-rename/ClangRename.cpp:26:
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h: In instantiation of 'clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*)::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor::ConsumerFactoryAdaptor(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::tooling::USRFindingAction]':
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/include/llvm/ADT/STLExtras.h:951:63:   required from 'typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), std::unique_ptr<T> >::type llvm::make_unique(Args&& ...) [with T = clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::tooling::USRFindingAction]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor; Args = {clang::tooling::USRFindingAction*&, clang::tooling::SourceFileCallbacks*&}; typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), std::unique_ptr<T> >::type = std::unique_ptr<clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::tooling::USRFindingAction]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor, std::default_delete<clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::tooling::USRFindingAction]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor> >]'
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h:390:65:   required from 'std::unique_ptr<clang::FrontendAction> clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*)::FrontendActionFactoryAdapter::create() [with FactoryT = clang::tooling::USRFindingAction]'
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h:425:3:   required from 'std::unique_ptr<clang::tooling::FrontendActionFactory> clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::tooling::USRFindingAction]'
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/tools/clang-rename/ClangRename.cpp:163:60:   required from here
/export/users/atombot/llvm/clang-atom-d525-fedora-rel/llvm/tools/clang/include/clang/Tooling/Tooling.h:396:7: internal compiler error: Segmentation fault
       ConsumerFactoryAdaptor(FactoryT *ConsumerFactory,
       ^
Please submit a full bug report,
with preprocessed source if appropriate.
See <http://bugzilla.redhat.com/bugzilla> for instructions.
Preprocessed source stored into /tmp/ccQAAO2w.out file, please attach this to your bugreport.
ninja: build stopped: subcommand failed.
program finished with exit code 1
elapsedTime=225.461214

http://lab.llvm.org:8011/builders/clang-x86_64-linux-abi-test/builds/22673

...
492.612 [873/22/3876] Building CXX object tools/clang/tools/extra/clang-tidy/hicpp/CMakeFiles/clangTidyHICPPModule.dir/SignedBitwiseCheck.cpp.o
492.721 [873/21/3877] Building CXX object tools/clang/tools/extra/clang-tidy/hicpp/CMakeFiles/clangTidyHICPPModule.dir/NoAssemblerCheck.cpp.o
492.756 [873/20/3878] Building CXX object tools/clang/tools/extra/clang-tidy/hicpp/CMakeFiles/clangTidyHICPPModule.dir/HICPPTidyModule.cpp.o
493.097 [873/19/3879] Building CXX object tools/clang/tools/extra/clang-reorder-fields/tool/CMakeFiles/clang-reorder-fields.dir/ClangReorderFields.cpp.o
FAILED: tools/clang/tools/extra/clang-reorder-fields/tool/CMakeFiles/clang-reorder-fields.dir/ClangReorderFields.cpp.o 
/usr/bin/c++   -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/clang/tools/extra/clang-reorder-fields/tool -I/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/tools/extra/clang-reorder-fields/tool -I/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include -Itools/clang/include -Iinclude -I/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/include -fPIC -fvisibility-inlines-hidden -std=c++11 -Wall -W -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wno-maybe-uninitialized -Wdelete-non-virtual-dtor -Wno-comment -ffunction-sections -fdata-sections -fno-common -Woverloaded-virtual -fno-strict-aliasing -O3    -UNDEBUG  -fno-exceptions -fno-rtti -MD -MT tools/clang/tools/extra/clang-reorder-fields/tool/CMakeFiles/clang-reorder-fields.dir/ClangReorderFields.cpp.o -MF tools/clang/tools/extra/clang-reorder-fields/tool/CMakeFiles/clang-reorder-fields.dir/ClangReorderFields.cpp.o.d -o tools/clang/tools/extra/clang-reorder-fields/tool/CMakeFiles/clang-reorder-fields.dir/ClangReorderFields.cpp.o -c /home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/tools/extra/clang-reorder-fields/tool/ClangReorderFields.cpp
In file included from /home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include/clang/Tooling/Refactoring.h:23:0,
                 from /home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/tools/extra/clang-reorder-fields/tool/../ReorderFieldsAction.h:19,
                 from /home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/tools/extra/clang-reorder-fields/tool/ClangReorderFields.cpp:15:
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include/clang/Tooling/Tooling.h: In instantiation of ‘clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*)::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor::ConsumerFactoryAdaptor(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::reorder_fields::ReorderFieldsAction]’:
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/include/llvm/ADT/STLExtras.h:951:63:   required from ‘typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), std::unique_ptr<T> >::type llvm::make_unique(Args&& ...) [with T = clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::reorder_fields::ReorderFieldsAction]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor; Args = {clang::reorder_fields::ReorderFieldsAction*&, clang::tooling::SourceFileCallbacks*&}; typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), std::unique_ptr<T> >::type = std::unique_ptr<clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::reorder_fields::ReorderFieldsAction]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor, std::default_delete<clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::reorder_fields::ReorderFieldsAction]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor> >]’
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include/clang/Tooling/Tooling.h:390:65:   required from ‘std::unique_ptr<clang::FrontendAction> clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*)::FrontendActionFactoryAdapter::create() [with FactoryT = clang::reorder_fields::ReorderFieldsAction]’
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include/clang/Tooling/Tooling.h:425:3:   required from ‘std::unique_ptr<clang::tooling::FrontendActionFactory> clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = clang::reorder_fields::ReorderFieldsAction]’
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/tools/extra/clang-reorder-fields/tool/ClangReorderFields.cpp:63:59:   required from here
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include/clang/Tooling/Tooling.h:396:7: internal compiler error: Segmentation fault
       ConsumerFactoryAdaptor(FactoryT *ConsumerFactory,
       ^
Please submit a full bug report,
with preprocessed source if appropriate.
See <file:///usr/share/doc/gcc-4.8/README.Bugs> for instructions.
Preprocessed source stored into /tmp/ccNrAHqD.out file, please attach this to your bugreport.
ERROR: Cannot create report: [Errno 17] File exists: '/var/crash/_usr_lib_gcc_x86_64-linux-gnu_4.8_cc1plus.1001.crash'
493.171 [873/18/3880] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/MisplacedConstCheck.cpp.o
493.370 [873/17/3881] Building CXX object tools/clang/tools/extra/clang-tidy/llvm/CMakeFiles/clangTidyLLVMModule.dir/IncludeOrderCheck.cpp.o
493.479 [873/16/3882] Building CXX object tools/clang/tools/extra/clang-tidy/google/CMakeFiles/clangTidyGoogleModule.dir/TodoCommentCheck.cpp.o
493.799 [873/15/3883] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/MacroParenthesesCheck.cpp.o
493.913 [873/14/3884] Building CXX object tools/clang/tools/extra/clang-tidy/llvm/CMakeFiles/clangTidyLLVMModule.dir/HeaderGuardCheck.cpp.o
493.924 [873/13/3885] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/LambdaFunctionNameCheck.cpp.o
494.346 [873/12/3886] Building CXX object tools/clang/tools/extra/clang-tidy/llvm/CMakeFiles/clangTidyLLVMModule.dir/TwineLocalCheck.cpp.o
494.366 [873/11/3887] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/ForwardingReferenceOverloadCheck.cpp.o
495.010 [873/10/3888] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/DefinitionsInHeadersCheck.cpp.o
495.257 [873/9/3889] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/UnconventionalAssignOperatorCheck.cpp.o
495.407 [873/8/3890] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/NewDeleteOverloadsCheck.cpp.o
495.841 [873/7/3891] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/MiscTidyModule.cpp.o
495.946 [873/6/3892] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/MisplacedWideningCastCheck.cpp.o
496.463 [873/5/3893] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/MacroRepeatedSideEffectsCheck.cpp.o
496.841 [873/4/3894] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/SizeofContainerCheck.cpp.o
497.060 [873/3/3895] Building CXX object tools/clang/tools/clang-check/CMakeFiles/clang-check.dir/ClangCheck.cpp.o
FAILED: tools/clang/tools/clang-check/CMakeFiles/clang-check.dir/ClangCheck.cpp.o 
/usr/bin/c++   -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/clang/tools/clang-check -I/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/tools/clang-check -I/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include -Itools/clang/include -Iinclude -I/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/include -fPIC -fvisibility-inlines-hidden -std=c++11 -Wall -W -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wno-maybe-uninitialized -Wdelete-non-virtual-dtor -Wno-comment -ffunction-sections -fdata-sections -fno-common -Woverloaded-virtual -fno-strict-aliasing -O3    -UNDEBUG  -fno-exceptions -fno-rtti -MD -MT tools/clang/tools/clang-check/CMakeFiles/clang-check.dir/ClangCheck.cpp.o -MF tools/clang/tools/clang-check/CMakeFiles/clang-check.dir/ClangCheck.cpp.o.d -o tools/clang/tools/clang-check/CMakeFiles/clang-check.dir/ClangCheck.cpp.o -c /home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/tools/clang-check/ClangCheck.cpp
In file included from /home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/tools/clang-check/ClangCheck.cpp:28:0:
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include/clang/Tooling/Tooling.h: In instantiation of ‘clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*)::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor::ConsumerFactoryAdaptor(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = {anonymous}::ClangCheckActionFactory]’:
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/include/llvm/ADT/STLExtras.h:951:63:   required from ‘typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), std::unique_ptr<T> >::type llvm::make_unique(Args&& ...) [with T = clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = {anonymous}::ClangCheckActionFactory]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor; Args = {{anonymous}::ClangCheckActionFactory*&, clang::tooling::SourceFileCallbacks*&}; typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), std::unique_ptr<T> >::type = std::unique_ptr<clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = {anonymous}::ClangCheckActionFactory]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor, std::default_delete<clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = {anonymous}::ClangCheckActionFactory]::FrontendActionFactoryAdapter::ConsumerFactoryAdaptor> >]’
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include/clang/Tooling/Tooling.h:390:65:   required from ‘std::unique_ptr<clang::FrontendAction> clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*)::FrontendActionFactoryAdapter::create() [with FactoryT = {anonymous}::ClangCheckActionFactory]’
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include/clang/Tooling/Tooling.h:425:3:   required from ‘std::unique_ptr<clang::tooling::FrontendActionFactory> clang::tooling::newFrontendActionFactory(FactoryT*, clang::tooling::SourceFileCallbacks*) [with FactoryT = {anonymous}::ClangCheckActionFactory]’
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/tools/clang-check/ClangCheck.cpp:183:61:   required from here
/home/buildslave/buildslave1a/clang-x86_64-linux-abi-test/llvm/tools/clang/include/clang/Tooling/Tooling.h:396:7: internal compiler error: Segmentation fault
       ConsumerFactoryAdaptor(FactoryT *ConsumerFactory,
       ^
Please submit a full bug report,
with preprocessed source if appropriate.
See <file:///usr/share/doc/gcc-4.8/README.Bugs> for instructions.
Preprocessed source stored into /tmp/ccruvBXJ.out file, please attach this to your bugreport.
ERROR: Cannot create report: [Errno 17] File exists: '/var/crash/_usr_lib_gcc_x86_64-linux-gnu_4.8_cc1plus.1001.crash'
497.694 [873/2/3896] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/NonCopyableObjects.cpp.o
498.351 [873/1/3897] Building CXX object tools/clang/tools/extra/clang-tidy/misc/CMakeFiles/clangTidyMiscModule.dir/RedundantExpressionCheck.cpp.o
ninja: build stopped: subcommand failed.
program finished with exit code 1
elapsedTime=498.873315

[alexfh]

Do you have a way to reproduce the gcc crashes?

[lebedev.ri]

In D43779#1021959, @alexfh wrote:

Do you have a way to reproduce the gcc crashes?

Not presently.
I'm on debian sid, so gcc4.8 is a lost-for-good relic from ancient past.

I'll try to create an debian-oldstable chroot, which still has gcc4.8, maybe that will help.

[lebedev.ri]

Hmm.
Got back to this issue.

Not reproducible with gcc-4.8.5 and gcc-4.9.3 in ubuntu 16.04 chroot.
*Reproducible* with gcc-4.8.4 and gcc-4.9.2 in debian oldstable (Jessie) chroot.
So one might assume that it was fixed.

I did try to creduce the crasher, but not not much success, since gcc takes 10+ sec to crash.

Should i simply try to re-commit and see if the buildbots got upgraded so this is no longer an issue?

[alexfh]

In D43779#1061043, @lebedev.ri wrote:

Hmm.
Got back to this issue.

Not reproducible with gcc-4.8.5 and gcc-4.9.3 in ubuntu 16.04 chroot.
*Reproducible* with gcc-4.8.4 and gcc-4.9.2 in debian oldstable (Jessie) chroot.
So one might assume that it was fixed.

I did try to creduce the crasher, but not not much success, since gcc takes 10+ sec to crash.

That's unfortunate, but it could be even worse. My experience with creducing crashes is that the process can take up to several days. In this case, however, we know what changes cause the crash and it should be possible to construct the test case manually instead of creducing it.

Should i simply try to re-commit and see if the buildbots got upgraded so this is no longer an issue?

I wouldn't expect buildbots to have been upgraded without someone doing this on purpose. If you have the list of buildbots that crashed, you could look at their recent logs to figure out which GCC version they are using now. It *might* be fine to require a patched version of GCC, but in that case you would have to:
0. Ask llvm-dev+cfe-dev whether anyone has concerns in raising the minimum required version of GCC

1. Fix the documentation, in particular this list: https://llvm.org/docs/GettingStarted.html#software and these instructions: https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain
2. Get buildbot maintainers to upgrade their GCC to at least the new required version

An alternative would be to try working around the bug.

[lebedev.ri]

In D43779#1061444, @alexfh wrote:

In D43779#1061043, @lebedev.ri wrote:

Hmm.
Got back to this issue.

Not reproducible with gcc-4.8.5 and gcc-4.9.3 in ubuntu 16.04 chroot.
*Reproducible* with gcc-4.8.4 and gcc-4.9.2 in debian oldstable (Jessie) chroot.
So one might assume that it was fixed.

I did try to creduce the crasher, but not not much success, since gcc takes 10+ sec to crash.

That's unfortunate, but it could be even worse. My experience with creducing crashes is that the process can take up to several days. In this case, however, we know what changes cause the crash and it should be possible to construct the test case manually instead of creducing it.

Should i simply try to re-commit and see if the buildbots got upgraded so this is no longer an issue?

I wouldn't expect buildbots to have been upgraded without someone doing this on purpose. If you have the list of buildbots that crashed, you could look at their recent logs to figure out which GCC version they are using now.

Yes, it seems they weren't upgraded yet as of this time.

It *might* be fine to require a patched version of GCC, but in that case you would have to:
0. Ask llvm-dev+cfe-dev whether anyone has concerns in raising the minimum required version of GCC

Yep, did that right after posting that comment, http://lists.llvm.org/pipermail/llvm-dev/2018-April/122438.html

1. Fix the documentation, in particular this list: https://llvm.org/docs/GettingStarted.html#software and these instructions: https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain
2. Get buildbot maintainers to upgrade their GCC to at least the new required version

An alternative would be to try working around the bug.

[dblaikie]

FWIW - I had some thoughts on this a while back:
https://reviews.llvm.org/D4313

[lebedev.ri]

Superseded by D66960

cfe/trunk/docs/LibTooling.rst

 
 .. code-block:: c++
 
   #include "clang/Tooling/Tooling.h"
 
   TEST(runToolOnCode, CanSyntaxCheckCode) {
     // runToolOnCode returns whether the action was correctly run over the
     // given code.
-    EXPECT_TRUE(runToolOnCode(new clang::SyntaxOnlyAction, "class X {};"));
+    EXPECT_TRUE(runToolOnCode(llvm::make_unique<clang::SyntaxOnlyAction>(), "class X {};"));
   }
 
 Writing a standalone tool
 -------------------------
 
 Once you unit tested your ``FrontendAction`` to the point where it cannot
 possibly break, it's time to create a standalone tool.  For a standalone tool
 to run clang, it first needs to figure out what command line arguments to use

cfe/trunk/docs/RAVFrontendAction.rst

::
           clang::CompilerInstance &Compiler, llvm::StringRef InFile) {
           return std::unique_ptr<clang::ASTConsumer>(
               new FindNamedClassConsumer(&Compiler.getASTContext()));
         }
       };
 
       int main(int argc, char **argv) {
         if (argc > 1) {
-          clang::tooling::runToolOnCode(new FindNamedClassAction, argv[1]);
+          clang::tooling::runToolOnCode(llvm::make_unique<FindNamedClassAction>(), argv[1]);
         }
       }
 
 We store this into a file called FindClassDecls.cpp and create the
 following CMakeLists.txt to link it:
 
 ::
 

cfe/trunk/include/clang/Tooling/Tooling.h

public:
   bool runInvocation(std::shared_ptr<clang::CompilerInvocation> Invocation,
                      FileManager *Files,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                      DiagnosticConsumer *DiagConsumer) override;
 
   /// \brief Returns a new clang::FrontendAction.
   ///
   /// The caller takes ownership of the returned action.
-  virtual clang::FrontendAction *create() = 0;
+  virtual std::unique_ptr<clang::FrontendAction> create() = 0;
 };
 
 /// \brief Returns a new FrontendActionFactory for a given type.
 ///
 /// T must derive from clang::FrontendAction.
 ///
 /// Example:
 /// FrontendActionFactory *Factory =

 ///
 /// \param ToolAction The action to run over the code.
 /// \param Code C++ code.
 /// \param FileName The file name which 'Code' will be mapped as.
 /// \param PCHContainerOps  The PCHContainerOperations for loading and creating
 ///                         clang modules.
 ///
 /// \return - True if 'ToolAction' was successfully executed.
-bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code,
-                   const Twine &FileName = "input.cc",
+bool runToolOnCode(std::unique_ptr<FrontendAction> ToolAction,
+                   const Twine &Code, const Twine &FileName = "input.cc",
                    std::shared_ptr<PCHContainerOperations> PCHContainerOps =
                        std::make_shared<PCHContainerOperations>());
 
 /// The first part of the pair is the filename, the second part the
 /// file-content.
 typedef std::vector<std::pair<std::string, std::string>> FileContentMappings;
 
 /// \brief Runs (and deletes) the tool on 'Code' with the -fsyntax-only flag and
 ///        with additional other flags.
 ///
 /// \param ToolAction The action to run over the code.
 /// \param Code C++ code.
 /// \param Args Additional flags to pass on.
 /// \param FileName The file name which 'Code' will be mapped as.
 /// \param ToolName The name of the binary running the tool. Standard library
 ///                 header paths will be resolved relative to this.
 /// \param PCHContainerOps   The PCHContainerOperations for loading and creating
 ///                          clang modules.
 ///
 /// \return - True if 'ToolAction' was successfully executed.
 bool runToolOnCodeWithArgs(
-    clang::FrontendAction *ToolAction, const Twine &Code,
+    std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
     const std::vector<std::string> &Args, const Twine &FileName = "input.cc",
     const Twine &ToolName = "clang-tool",
     std::shared_ptr<PCHContainerOperations> PCHContainerOps =
         std::make_shared<PCHContainerOperations>(),
     const FileContentMappings &VirtualMappedFiles = FileContentMappings());
 
 /// \brief Builds an AST for 'Code'.
 ///
public:
   /// uses its binary name (CommandLine[0]) to locate its builtin headers.
   /// Callers have to ensure that they are installed in a compatible location
   /// (see clang driver implementation) or mapped in via mapVirtualFile.
   /// \param FAction The action to be executed. Class takes ownership.
   /// \param Files The FileManager used for the execution. Class does not take
   /// ownership.
   /// \param PCHContainerOps The PCHContainerOperations for loading and creating
   /// clang modules.
-  ToolInvocation(std::vector<std::string> CommandLine, FrontendAction *FAction,
-                 FileManager *Files,
+  ToolInvocation(std::vector<std::string> CommandLine,
+                 std::unique_ptr<FrontendAction> FAction, FileManager *Files,
                  std::shared_ptr<PCHContainerOperations> PCHContainerOps =
                      std::make_shared<PCHContainerOperations>());
 
   /// \brief Create a tool invocation.
   ///
   /// \param CommandLine The command line arguments to clang.
   /// \param Action The action to be executed.
   /// \param Files The FileManager used for the execution.
private:
 
   DiagnosticConsumer *DiagConsumer;
 };
 
 template <typename T>
 std::unique_ptr<FrontendActionFactory> newFrontendActionFactory() {
   class SimpleFrontendActionFactory : public FrontendActionFactory {
   public:
-    clang::FrontendAction *create() override { return new T; }
+    std::unique_ptr<clang::FrontendAction> create() override {
+      return llvm::make_unique<T>();
+    }
   };
 
   return std::unique_ptr<FrontendActionFactory>(
       new SimpleFrontendActionFactory);
 }
 
 template <typename FactoryT>
 inline std::unique_ptr<FrontendActionFactory> newFrontendActionFactory(
     FactoryT *ConsumerFactory, SourceFileCallbacks *Callbacks) {
   class FrontendActionFactoryAdapter : public FrontendActionFactory {
   public:
     explicit FrontendActionFactoryAdapter(FactoryT *ConsumerFactory,
                                           SourceFileCallbacks *Callbacks)
       : ConsumerFactory(ConsumerFactory), Callbacks(Callbacks) {}
 
-    clang::FrontendAction *create() override {
-      return new ConsumerFactoryAdaptor(ConsumerFactory, Callbacks);
+    std::unique_ptr<clang::FrontendAction> create() override {
+      return llvm::make_unique<ConsumerFactoryAdaptor>(ConsumerFactory,
+                                                       Callbacks);
     }
 
   private:
     class ConsumerFactoryAdaptor : public clang::ASTFrontendAction {
     public:
       ConsumerFactoryAdaptor(FactoryT *ConsumerFactory,
                              SourceFileCallbacks *Callbacks)
         : ConsumerFactory(ConsumerFactory), Callbacks(Callbacks) {}

cfe/trunk/lib/Tooling/Tooling.cpp

clang::CompilerInvocation *newInvocation(
   clang::CompilerInvocation::CreateFromArgs(
       *Invocation, CC1Args.data() + 1, CC1Args.data() + CC1Args.size(),
       *Diagnostics);
   Invocation->getFrontendOpts().DisableFree = false;
   Invocation->getCodeGenOpts().DisableFree = false;
   return Invocation;
 }
 
-bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code,
-                   const Twine &FileName,
+bool runToolOnCode(std::unique_ptr<FrontendAction> ToolAction,
+                   const Twine &Code, const Twine &FileName,
                    std::shared_ptr<PCHContainerOperations> PCHContainerOps) {
-  return runToolOnCodeWithArgs(ToolAction, Code, std::vector<std::string>(),
-                               FileName, "clang-tool",
-                               std::move(PCHContainerOps));
+  return runToolOnCodeWithArgs(std::move(ToolAction), Code,
+                               std::vector<std::string>(), FileName,
+                               "clang-tool", std::move(PCHContainerOps));
 }
 
 static std::vector<std::string>
 getSyntaxOnlyToolArgs(const Twine &ToolName,
                       const std::vector<std::string> &ExtraArgs,
                       StringRef FileName) {
   std::vector<std::string> Args;
   Args.push_back(ToolName.str());
   Args.push_back("-fsyntax-only");
   Args.insert(Args.end(), ExtraArgs.begin(), ExtraArgs.end());
   Args.push_back(FileName.str());
   return Args;
 }
 
 bool runToolOnCodeWithArgs(
-    clang::FrontendAction *ToolAction, const Twine &Code,
+    std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
     const std::vector<std::string> &Args, const Twine &FileName,
     const Twine &ToolName,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     const FileContentMappings &VirtualMappedFiles) {
 
   SmallString<16> FileNameStorage;
   StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage);
   llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem(
       new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
   llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), OverlayFileSystem));
   ArgumentsAdjuster Adjuster = getClangStripDependencyFileAdjuster();
   ToolInvocation Invocation(
       getSyntaxOnlyToolArgs(ToolName, Adjuster(Args, FileNameRef), FileNameRef),
-      ToolAction, Files.get(),
-      std::move(PCHContainerOps));
+      std::move(ToolAction), Files.get(), std::move(PCHContainerOps));
 
   SmallString<1024> CodeStorage;
   InMemoryFileSystem->addFile(FileNameRef, 0,
                               llvm::MemoryBuffer::getMemBuffer(
                                   Code.toNullTerminatedStringRef(CodeStorage)));
 
   for (auto &FilenameWithContent : VirtualMappedFiles) {
     InMemoryFileSystem->addFile(
if (!AlreadyHasTarget && TargetMode.TargetIsValid) {
                                                  TargetMode.TargetPrefix});
     }
   }
 }
 
 namespace {
 
 class SingleFrontendActionFactory : public FrontendActionFactory {
-  FrontendAction *Action;
+  std::unique_ptr<clang::FrontendAction> Action;
 
 public:
-  SingleFrontendActionFactory(FrontendAction *Action) : Action(Action) {}
+  SingleFrontendActionFactory(std::unique_ptr<clang::FrontendAction> Action)
+      : Action(std::move(Action)) {}
 
-  FrontendAction *create() override { return Action; }
+  std::unique_ptr<clang::FrontendAction> create() override {
+    return std::move(Action);
+  }
 };
 
-}
+} // namespace
 
 ToolInvocation::ToolInvocation(
     std::vector<std::string> CommandLine, ToolAction *Action,
     FileManager *Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps)
     : CommandLine(std::move(CommandLine)), Action(Action), OwnsAction(false),
       Files(Files), PCHContainerOps(std::move(PCHContainerOps)),
       DiagConsumer(nullptr) {}
 
 ToolInvocation::ToolInvocation(
-    std::vector<std::string> CommandLine, FrontendAction *FAction,
-    FileManager *Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps)
+    std::vector<std::string> CommandLine,
+    std::unique_ptr<FrontendAction> FAction, FileManager *Files,
+    std::shared_ptr<PCHContainerOperations> PCHContainerOps)
     : CommandLine(std::move(CommandLine)),
-      Action(new SingleFrontendActionFactory(FAction)), OwnsAction(true),
-      Files(Files), PCHContainerOps(std::move(PCHContainerOps)),
-      DiagConsumer(nullptr) {}
+      Action(new SingleFrontendActionFactory(std::move(FAction))),
+      OwnsAction(true), Files(Files),
+      PCHContainerOps(std::move(PCHContainerOps)), DiagConsumer(nullptr) {}
 
 ToolInvocation::~ToolInvocation() {
   if (OwnsAction)
     delete Action;
 }
 
 void ToolInvocation::mapVirtualFile(StringRef FilePath, StringRef Content) {
   SmallString<1024> PathStorage;

cfe/trunk/tools/clang-refactor/ClangRefactor.cpp

private:
       TUCallbackType Callback;
     };
 
     class ToolActionFactory : public FrontendActionFactory {
     public:
       ToolActionFactory(TUCallbackType Callback)
           : Callback(std::move(Callback)) {}
 
-      FrontendAction *create() override { return new ToolASTAction(Callback); }
+      std::unique_ptr<FrontendAction> create() override {
+        return llvm::make_unique<ToolASTAction>(Callback);
+      }
 
     private:
       TUCallbackType Callback;
     };
 
     return llvm::make_unique<ToolActionFactory>(
         [this](ASTContext &AST) { return callback(AST); });
   }

cfe/trunk/unittests/AST/EvaluateAsRValueTest.cpp

TEST(EvaluateAsRValue, FailsGracefullyForUnknownTypes) {
   // This is a regression test; the AST library used to trigger assertion
   // failures because it assumed that the type of initializers was always
   // known (which is true only after template instantiation).
   std::string ModesToTest[] = {"-std=c++03", "-std=c++11", "-std=c++1y"};
   for (std::string const &Mode : ModesToTest) {
     std::vector<std::string> Args(1, Mode);
     Args.push_back("-fno-delayed-template-parsing");
     ASSERT_TRUE(runToolOnCodeWithArgs(
-      new EvaluateConstantInitializersAction(),
+      llvm::make_unique<EvaluateConstantInitializersAction>(),
       "template <typename T>"
       "struct vector {"
       "  explicit vector(int size);"
       "};"
       "template <typename R>"
       "struct S {"
       "  vector<R> intervals() const {"
       "    vector<R> Dependent(2);"

cfe/trunk/unittests/CrossTU/CrossTranslationUnitTest.cpp

 private:
   bool *Success;
 };
 
 } // end namespace
 
 TEST(CrossTranslationUnit, CanLoadFunctionDefinition) {
   bool Success = false;
-  EXPECT_TRUE(tooling::runToolOnCode(new CTUAction(&Success), "int f(int);"));
+  EXPECT_TRUE(tooling::runToolOnCode(llvm::make_unique<CTUAction>(&Success),
+                                     "int f(int);"));
   EXPECT_TRUE(Success);
 }
 
 TEST(CrossTranslationUnit, IndexFormatCanBeParsed) {
   llvm::StringMap<std::string> Index;
   Index["a"] = "/b/f1";
   Index["c"] = "/d/f2";
   Index["e"] = "/f/f3";

cfe/trunk/unittests/Sema/CodeCompleteTest.cpp

assert(TokenOffset != StringRef::npos &&
          "Completion token ^ wasn't found in Code.");
   std::string WithoutToken = Code.take_front(TokenOffset);
   WithoutToken += Code.drop_front(WithoutToken.size() + 1);
   assert(StringRef(WithoutToken).find('^') == StringRef::npos &&
          "expected exactly one completion token ^ inside the code");
 
   auto Action = llvm::make_unique<CodeCompleteAction>(
       offsetToPosition(WithoutToken, TokenOffset), Results);
-  clang::tooling::runToolOnCodeWithArgs(Action.release(), Code, {"-std=c++11"},
+  clang::tooling::runToolOnCodeWithArgs(std::move(Action), Code, {"-std=c++11"},
                                         TestCCName);
   return Results;
 }
 
 TEST(SemaCodeCompleteTest, VisitedNSForValidQualifiedId) {
   auto VisitedNS = runCodeCompleteOnCode(R"cpp(
      namespace ns1 {}
      namespace ns2 {}

cfe/trunk/unittests/Sema/ExternalSemaSourceTest.cpp

void PushSource(clang::ExternalSemaSource *Source) {
     Sources.push_back(Source);
   }
 
   void PushWatcher(DiagnosticWatcher *Watcher) { Watchers.push_back(Watcher); }
 };
 
 // Make sure that the DiagnosticWatcher is not miscounting.
 TEST(ExternalSemaSource, SanityCheck) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   DiagnosticWatcher Watcher("AAB", "BBB");
   Installer->PushWatcher(&Watcher);
   std::vector<std::string> Args(1, "-std=c++11");
   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(), "namespace AAA { } using namespace AAB;", Args));
+      std::move(Installer), "namespace AAA { } using namespace AAB;", Args));
   ASSERT_EQ(0, Watcher.SeenCount);
 }
 
 // Check that when we add a NamespaceTypeProvider, we use that suggestion
 // instead of the usual suggestion we would use above.
 TEST(ExternalSemaSource, ExternalTypoCorrectionPrioritized) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   NamespaceTypoProvider Provider("AAB", "BBB");
   DiagnosticWatcher Watcher("AAB", "BBB");
   Installer->PushSource(&Provider);
   Installer->PushWatcher(&Watcher);
   std::vector<std::string> Args(1, "-std=c++11");
   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(), "namespace AAA { } using namespace AAB;", Args));
+      std::move(Installer), "namespace AAA { } using namespace AAB;", Args));
   ASSERT_LE(0, Provider.CallCount);
   ASSERT_EQ(1, Watcher.SeenCount);
 }
 
 // Check that we use the first successful TypoCorrection returned from an
 // ExternalSemaSource.
 TEST(ExternalSemaSource, ExternalTypoCorrectionOrdering) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   NamespaceTypoProvider First("XXX", "BBB");
   NamespaceTypoProvider Second("AAB", "CCC");
   NamespaceTypoProvider Third("AAB", "DDD");
   DiagnosticWatcher Watcher("AAB", "CCC");
   Installer->PushSource(&First);
   Installer->PushSource(&Second);
   Installer->PushSource(&Third);
   Installer->PushWatcher(&Watcher);
   std::vector<std::string> Args(1, "-std=c++11");
   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(), "namespace AAA { } using namespace AAB;", Args));
+      std::move(Installer), "namespace AAA { } using namespace AAB;", Args));
   ASSERT_LE(1, First.CallCount);
   ASSERT_LE(1, Second.CallCount);
   ASSERT_EQ(0, Third.CallCount);
   ASSERT_EQ(1, Watcher.SeenCount);
 }
 
 TEST(ExternalSemaSource, ExternalDelayedTypoCorrection) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   FunctionTypoProvider Provider("aaa", "bbb");
   DiagnosticWatcher Watcher("aaa", "bbb");
   Installer->PushSource(&Provider);
   Installer->PushWatcher(&Watcher);
   std::vector<std::string> Args(1, "-std=c++11");
   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(), "namespace AAA { } void foo() { AAA::aaa(); }",
+      std::move(Installer), "namespace AAA { } void foo() { AAA::aaa(); }",
       Args));
   ASSERT_LE(0, Provider.CallCount);
   ASSERT_EQ(1, Watcher.SeenCount);
 }
 
 // We should only try MaybeDiagnoseMissingCompleteType if we can't otherwise
 // solve the problem.
 TEST(ExternalSemaSource, TryOtherTacticsBeforeDiagnosing) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   CompleteTypeDiagnoser Diagnoser(false);
   Installer->PushSource(&Diagnoser);
   std::vector<std::string> Args(1, "-std=c++11");
   // This code hits the class template specialization/class member of a class
   // template specialization checks in Sema::RequireCompleteTypeImpl.
   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(),
+      std::move(Installer),
       "template <typename T> struct S { class C { }; }; S<char>::C SCInst;",
       Args));
   ASSERT_EQ(0, Diagnoser.CallCount);
 }
 
 // The first ExternalSemaSource where MaybeDiagnoseMissingCompleteType returns
 // true should be the last one called.
 TEST(ExternalSemaSource, FirstDiagnoserTaken) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   CompleteTypeDiagnoser First(false);
   CompleteTypeDiagnoser Second(true);
   CompleteTypeDiagnoser Third(true);
   Installer->PushSource(&First);
   Installer->PushSource(&Second);
   Installer->PushSource(&Third);
   std::vector<std::string> Args(1, "-std=c++11");
   ASSERT_FALSE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(), "class Incomplete; Incomplete IncompleteInstance;",
+      std::move(Installer), "class Incomplete; Incomplete IncompleteInstance;",
       Args));
   ASSERT_EQ(1, First.CallCount);
   ASSERT_EQ(1, Second.CallCount);
   ASSERT_EQ(0, Third.CallCount);
 }
 
 } // anonymous namespace

cfe/trunk/unittests/Tooling/CommentHandlerTest.cpp

bool HandleComment(Preprocessor &PP, SourceRange Loc) override {
 
     Comments.push_back(Comment(C, CLine, CCol));
     return false;
   }
 
   CommentVerifier GetVerifier();
 
 protected:
-  ASTFrontendAction *CreateTestAction() override {
-    return new CommentHandlerAction(this);
+  std::unique_ptr<FrontendAction> CreateTestAction() override {
+    return llvm::make_unique<CommentHandlerAction>(this);
   }
 
 private:
   Preprocessor *PP;
   CommentList Comments;
   bool Verified;
 
   class CommentHandlerAction : public base::TestAction {

cfe/trunk/unittests/Tooling/ExecutionTest.cpp

 
 private:
   ExecutionContext *const Context;
 };
 
 class ReportResultActionFactory : public FrontendActionFactory {
 public:
   ReportResultActionFactory(ExecutionContext *Context) : Context(Context) {}
-  FrontendAction *create() override { return new ReportResultAction(Context); }
+  std::unique_ptr<FrontendAction> create() override {
+    return llvm::make_unique<ReportResultAction>(Context);
+  }
 
 private:
   ExecutionContext *const Context;
 };
 
 } // namespace
 
 class TestToolExecutor : public ToolExecutor {

cfe/trunk/unittests/Tooling/RefactoringTest.cpp

EXPECT_EQ("line1\nreplaced\nline3\nline4",
             getFileContentFromDisk("input.cpp"));
 }
 
 namespace {
 template <typename T>
 class TestVisitor : public clang::RecursiveASTVisitor<T> {
 public:
   bool runOver(StringRef Code) {
-    return runToolOnCode(new TestAction(this), Code);
+    return runToolOnCode(llvm::make_unique<TestAction>(this), Code);
   }
 
 protected:
   clang::SourceManager *SM;
   clang::ASTContext *Context;
 
 private:
   class FindConsumer : public clang::ASTConsumer {

cfe/trunk/unittests/Tooling/TestVisitor.h

bool shouldVisitTemplateInstantiations() const {
     return true;
   }
 
   bool shouldVisitImplicitCode() const {
     return true;
   }
 
 protected:
-  virtual ASTFrontendAction* CreateTestAction() {
-    return new TestAction(this);
+  virtual std::unique_ptr<FrontendAction> CreateTestAction() {
+    return llvm::make_unique<TestAction>(this);
   }
 
   class FindConsumer : public ASTConsumer {
   public:
     FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {}
 
     void HandleTranslationUnit(clang::ASTContext &Context) override {
       Visitor->Context = &Context;

cfe/trunk/unittests/Tooling/ToolingTest.cpp

public:
   }
  private:
   bool * const FoundTopLevelDecl;
 };
 } // end namespace
 
 TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) {
   bool FoundTopLevelDecl = false;
-  EXPECT_TRUE(
-      runToolOnCode(new TestAction(llvm::make_unique<FindTopLevelDeclConsumer>(
-                        &FoundTopLevelDecl)),
-                    ""));
+  EXPECT_TRUE(runToolOnCode(
+      llvm::make_unique<TestAction>(
+          llvm::make_unique<FindTopLevelDeclConsumer>(&FoundTopLevelDecl)),
   EXPECT_FALSE(FoundTopLevelDecl);
 }
 
 namespace {
 class FindClassDeclXConsumer : public clang::ASTConsumer {
  public:
   FindClassDeclXConsumer(bool *FoundClassDeclX)
       : FoundClassDeclX(FoundClassDeclX) {}
for (std::vector<Decl *>::iterator i = AST->top_level_begin(),
     }
   }
   return false;
 }
 } // end namespace
 
 TEST(runToolOnCode, FindsClassDecl) {
   bool FoundClassDeclX = false;
-  EXPECT_TRUE(
-      runToolOnCode(new TestAction(llvm::make_unique<FindClassDeclXConsumer>(
-                        &FoundClassDeclX)),
-                    "class X;"));
+  EXPECT_TRUE(runToolOnCode(
+      llvm::make_unique<TestAction>(
+          llvm::make_unique<FindClassDeclXConsumer>(&FoundClassDeclX)),
   EXPECT_TRUE(FoundClassDeclX);
 
   FoundClassDeclX = false;
-  EXPECT_TRUE(
-      runToolOnCode(new TestAction(llvm::make_unique<FindClassDeclXConsumer>(
-                        &FoundClassDeclX)),
-                    "class Y;"));
+  EXPECT_TRUE(runToolOnCode(
+      llvm::make_unique<TestAction>(
+          llvm::make_unique<FindClassDeclXConsumer>(&FoundClassDeclX)),
   EXPECT_FALSE(FoundClassDeclX);
 }
 
 TEST(buildASTFromCode, FindsClassDecl) {
   std::unique_ptr<ASTUnit> AST = buildASTFromCode("class X;");
   ASSERT_TRUE(AST.get());
   EXPECT_TRUE(FindClassDeclX(AST.get()));
 
TEST(ToolInvocation, TestMapVirtualFile) {
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), OverlayFileSystem));
   std::vector<std::string> Args;
   Args.push_back("tool-executable");
   Args.push_back("-Idef");
   Args.push_back("-fsyntax-only");
   Args.push_back("test.cpp");
-  clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction,
-                                            Files.get());
+  clang::tooling::ToolInvocation Invocation(
+      Args, llvm::make_unique<SyntaxOnlyAction>(), Files.get());
   InMemoryFileSystem->addFile(
       "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include <abc>\n"));
   InMemoryFileSystem->addFile("def/abc", 0,
                               llvm::MemoryBuffer::getMemBuffer("\n"));
   EXPECT_TRUE(Invocation.run());
 }
 
 TEST(ToolInvocation, TestVirtualModulesCompilation) {
   // FIXME: Currently, this only tests that we don't exit with an error if a
   // mapped module.map is found on the include path. In the future, expand this
   // test to run a full modules enabled compilation, so we make sure we can
   // rerun modules compilations with a virtual file system.
   llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem(
       new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
   llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), OverlayFileSystem));
   std::vector<std::string> Args;
   Args.push_back("tool-executable");
   Args.push_back("-Idef");
   Args.push_back("-fsyntax-only");
   Args.push_back("test.cpp");
-  clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction,
-                                            Files.get());
+  clang::tooling::ToolInvocation Invocation(
+      Args, llvm::make_unique<SyntaxOnlyAction>(), Files.get());
   InMemoryFileSystem->addFile(
       "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include <abc>\n"));
   InMemoryFileSystem->addFile("def/abc", 0,
                               llvm::MemoryBuffer::getMemBuffer("\n"));
   // Add a module.map file in the include directory of our header, so we trigger
   // the module.map header search logic.
   InMemoryFileSystem->addFile("def/module.map", 0,
                               llvm::MemoryBuffer::getMemBuffer("\n"));
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
     return llvm::make_unique<SkipBodyConsumer>();
   }
 };
 
 TEST(runToolOnCode, TestSkipFunctionBody) {
   std::vector<std::string> Args = {"-std=c++11"};
   std::vector<std::string> Args2 = {"-fno-delayed-template-parsing"};
 
-  EXPECT_TRUE(runToolOnCode(new SkipBodyAction,
+  EXPECT_TRUE(runToolOnCode(llvm::make_unique<SkipBodyAction>(),
                             "int skipMe() { an_error_here }"));
-  EXPECT_FALSE(runToolOnCode(new SkipBodyAction,
+  EXPECT_FALSE(runToolOnCode(llvm::make_unique<SkipBodyAction>(),
                              "int skipMeNot() { an_error_here }"));
 
   // Test constructors with initializers
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new SkipBodyAction,
+      llvm::make_unique<SkipBodyAction>(),
       "struct skipMe { skipMe() : an_error() { more error } };", Args));
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new SkipBodyAction, "struct skipMe { skipMe(); };"
-                          "skipMe::skipMe() : an_error([](){;}) { more error }",
+      llvm::make_unique<SkipBodyAction>(),
+      "struct skipMe { skipMe(); };"
       Args));
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new SkipBodyAction, "struct skipMe { skipMe(); };"
-                          "skipMe::skipMe() : an_error{[](){;}} { more error }",
+      llvm::make_unique<SkipBodyAction>(),
+      "struct skipMe { skipMe(); };"
       Args));
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new SkipBodyAction,
+      llvm::make_unique<SkipBodyAction>(),
       "struct skipMe { skipMe(); };"
       "skipMe::skipMe() : a<b<c>(e)>>(), f{}, g() { error }",
       Args));
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new SkipBodyAction, "struct skipMe { skipMe() : bases()... { error } };",
-      Args));
+      llvm::make_unique<SkipBodyAction>(),
+      "struct skipMe { skipMe() : bases()... { error } };", Args));
 
   EXPECT_FALSE(runToolOnCodeWithArgs(
-      new SkipBodyAction, "struct skipMeNot { skipMeNot() : an_error() { } };",
-      Args));
-  EXPECT_FALSE(runToolOnCodeWithArgs(new SkipBodyAction,
+      llvm::make_unique<SkipBodyAction>(),
+      "struct skipMeNot { skipMeNot() : an_error() { } };", Args));
+  EXPECT_FALSE(runToolOnCodeWithArgs(llvm::make_unique<SkipBodyAction>(),
                                      "struct skipMeNot { skipMeNot(); };"
                                      "skipMeNot::skipMeNot() : an_error() { }",
                                      Args));
 
   // Try/catch
   EXPECT_TRUE(runToolOnCode(
-      new SkipBodyAction,
+      llvm::make_unique<SkipBodyAction>(),
       "void skipMe() try { an_error() } catch(error) { error };"));
   EXPECT_TRUE(runToolOnCode(
-      new SkipBodyAction,
+      llvm::make_unique<SkipBodyAction>(),
       "struct S { void skipMe() try { an_error() } catch(error) { error } };"));
   EXPECT_TRUE(
-      runToolOnCode(new SkipBodyAction,
+      runToolOnCode(llvm::make_unique<SkipBodyAction>(),
                     "void skipMe() try { an_error() } catch(error) { error; }"
                     "catch(error) { error } catch (error) { }"));
   EXPECT_FALSE(runToolOnCode(
-      new SkipBodyAction,
+      llvm::make_unique<SkipBodyAction>(),
       "void skipMe() try something;")); // don't crash while parsing
 
   // Template
-  EXPECT_TRUE(runToolOnCode(
-      new SkipBodyAction, "template<typename T> int skipMe() { an_error_here }"
-                          "int x = skipMe<int>();"));
+  EXPECT_TRUE(
+      runToolOnCode(llvm::make_unique<SkipBodyAction>(),
+                    "template<typename T> int skipMe() { an_error_here }"
   EXPECT_FALSE(runToolOnCodeWithArgs(
-      new SkipBodyAction,
+      llvm::make_unique<SkipBodyAction>(),
       "template<typename T> int skipMeNot() { an_error_here }", Args2));
 }
 
 TEST(runToolOnCodeWithArgs, TestNoDepFile) {
   llvm::SmallString<32> DepFilePath;
   ASSERT_FALSE(
       llvm::sys::fs::createTemporaryFile("depfile", "d", DepFilePath));
   std::vector<std::string> Args;
   Args.push_back("-MMD");
   Args.push_back("-MT");
   Args.push_back(DepFilePath.str());
   Args.push_back("-MF");
   Args.push_back(DepFilePath.str());
-  EXPECT_TRUE(runToolOnCodeWithArgs(new SkipBodyAction, "", Args));
+  EXPECT_TRUE(
+      runToolOnCodeWithArgs(llvm::make_unique<SkipBodyAction>(), "", Args));
   EXPECT_FALSE(llvm::sys::fs::exists(DepFilePath.str()));
   EXPECT_FALSE(llvm::sys::fs::remove(DepFilePath.str()));
 }
 
 struct CheckColoredDiagnosticsAction : public clang::ASTFrontendAction {
   CheckColoredDiagnosticsAction(bool ShouldShowColor)
       : ShouldShowColor(ShouldShowColor) {}
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
                                                  StringRef) override {
     if (Compiler.getDiagnosticOpts().ShowColors != ShouldShowColor)
       Compiler.getDiagnostics().Report(
           Compiler.getDiagnostics().getCustomDiagID(
               DiagnosticsEngine::Fatal,
               "getDiagnosticOpts().ShowColors != ShouldShowColor"));
     return llvm::make_unique<ASTConsumer>();
   }
 
 private:
   bool ShouldShowColor = true;
 };
 
 TEST(runToolOnCodeWithArgs, DiagnosticsColor) {
 
-  EXPECT_TRUE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(true), "",
-                                    {"-fcolor-diagnostics"}));
-  EXPECT_TRUE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false),
-                                    "", {"-fno-color-diagnostics"}));
-  EXPECT_TRUE(
-      runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(true), "",
-                            {"-fno-color-diagnostics", "-fcolor-diagnostics"}));
-  EXPECT_TRUE(
-      runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false), "",
-                            {"-fcolor-diagnostics", "-fno-color-diagnostics"}));
+  EXPECT_TRUE(runToolOnCodeWithArgs(
+      llvm::make_unique<CheckColoredDiagnosticsAction>(true), "",
+  EXPECT_TRUE(runToolOnCodeWithArgs(
+      llvm::make_unique<CheckColoredDiagnosticsAction>(false), "",
+      {"-fno-color-diagnostics"}));
+  EXPECT_TRUE(runToolOnCodeWithArgs(
+      llvm::make_unique<CheckColoredDiagnosticsAction>(true), "",
+  EXPECT_TRUE(runToolOnCodeWithArgs(
+      llvm::make_unique<CheckColoredDiagnosticsAction>(false), "",
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new CheckColoredDiagnosticsAction(true), "",
+      llvm::make_unique<CheckColoredDiagnosticsAction>(true), "",
       {"-fno-color-diagnostics", "-fdiagnostics-color=always"}));
 
   // Check that this test would fail if ShowColors is not what it should.
-  EXPECT_FALSE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false),
-                                     "", {"-fcolor-diagnostics"}));
+  EXPECT_FALSE(runToolOnCodeWithArgs(
+      llvm::make_unique<CheckColoredDiagnosticsAction>(false), "",
+      {"-fcolor-diagnostics"}));
 }
 
 TEST(ClangToolTest, ArgumentAdjusters) {
   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
 
   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
   Tool.mapVirtualFile("/a.cc", "void a() {}");
 
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
         }
       };
       return llvm::make_unique<Consumer>();
     }
   };
 
   // Should not crash
   EXPECT_FALSE(
-      runToolOnCode(new ResetDiagnosticAction,
+      runToolOnCode(llvm::make_unique<ResetDiagnosticAction>(),
                     "struct Foo { Foo(int); ~Foo(); struct Fwd _fwd; };"
                     "void func() { long x; Foo f(x); }"));
 }
 
 } // end namespace tooling
 } // end namespace clang