[clang-tools-extra] r185535 - cpp11-migrate: Add Replace-AutoPtr Transform
Edwin Vane
edwin.vane at intel.com
Wed Jul 3 06:21:24 PDT 2013
Author: revane
Date: Wed Jul 3 08:21:24 2013
New Revision: 185535
URL: http://llvm.org/viewvc/llvm-project?rev=185535&view=rev
Log:
cpp11-migrate: Add Replace-AutoPtr Transform
Add a new transform to replace uses of 'std::auto_ptr' by 'std::unique_ptr'.
Copy-ctor and assign-operator are wrapped with a call to 'std::move()'.
Note that until header modification is ready it is not that useful, that's why
it's marked as (EXPERIMENTAL) in the command line description and a "Known
Limitations" section is present in the transform documentation.
Author: Guillaume Papin <guillaume.papin at epitech.eu>
Added:
clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/
clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtr.cpp
clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtr.h
clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrActions.cpp
clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrActions.h
clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrMatchers.cpp
clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrMatchers.h
clang-tools-extra/trunk/docs/ReplaceAutoPtrTransform.rst
clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/
clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/
clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/basic.h
clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/memory_stub.h
clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/basic.cpp
clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/move.cpp
clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/template_fail.cpp
Modified:
clang-tools-extra/trunk/cpp11-migrate/tool/CMakeLists.txt
clang-tools-extra/trunk/cpp11-migrate/tool/Cpp11Migrate.cpp
clang-tools-extra/trunk/cpp11-migrate/tool/Makefile
clang-tools-extra/trunk/docs/MigratorUsage.rst
clang-tools-extra/trunk/docs/README.txt
clang-tools-extra/trunk/docs/cpp11-migrate.rst
Added: clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtr.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtr.cpp?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtr.cpp (added)
+++ clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtr.cpp Wed Jul 3 08:21:24 2013
@@ -0,0 +1,55 @@
+//===-- ReplaceAutoPtr.cpp ---------- std::auto_ptr replacement -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file provides the implementation of the ReplaceAutoPtrTransform
+/// class.
+///
+//===----------------------------------------------------------------------===//
+
+#include "ReplaceAutoPtr.h"
+#include "ReplaceAutoPtrActions.h"
+#include "ReplaceAutoPtrMatchers.h"
+
+#include "clang/Tooling/Refactoring.h"
+#include "clang/Tooling/Tooling.h"
+
+using namespace clang;
+using namespace clang::tooling;
+using namespace clang::ast_matchers;
+
+int
+ReplaceAutoPtrTransform::apply(FileOverrides &InputStates,
+ const CompilationDatabase &Database,
+ const std::vector<std::string> &SourcePaths) {
+ ClangTool Tool(Database, SourcePaths);
+
+ unsigned AcceptedChanges = 0;
+
+ MatchFinder Finder;
+ AutoPtrReplacer Replacer(getReplacements(), AcceptedChanges,
+ /*Owner=*/*this);
+ OwnershipTransferFixer Fixer(getReplacements(), AcceptedChanges,
+ /*Owner=*/*this);
+
+ Finder.addMatcher(makeAutoPtrTypeLocMatcher(), &Replacer);
+ Finder.addMatcher(makeAutoPtrUsingDeclMatcher(), &Replacer);
+ Finder.addMatcher(makeTransferOwnershipExprMatcher(), &Fixer);
+
+ setOverrides(InputStates);
+
+ if (Tool.run(createActionFactory(Finder))) {
+ llvm::errs() << "Error encountered during translation.\n";
+ return 1;
+ }
+
+ setAcceptedChanges(AcceptedChanges);
+
+ return 0;
+}
Added: clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtr.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtr.h?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtr.h (added)
+++ clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtr.h Wed Jul 3 08:21:24 2013
@@ -0,0 +1,54 @@
+//===-- ReplaceAutoPtr.h ------------ std::auto_ptr replacement -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file provides the declaration of the ReplaceAutoPtrTransform
+/// class.
+///
+//===----------------------------------------------------------------------===//
+#ifndef CPP11_MIGRATE_REPLACE_AUTO_PTR_H
+#define CPP11_MIGRATE_REPLACE_AUTO_PTR_H
+
+#include "Core/Transform.h"
+#include "llvm/Support/Compiler.h"
+
+/// \brief Subclass of Transform that transforms the deprecated \c std::auto_ptr
+/// into the C++11 \c std::unique_ptr.
+///
+/// Note that both the \c std::auto_ptr type and the transfer of ownership are
+/// transformed. \c std::auto_ptr provides two ways to transfer the ownership,
+/// the copy-constructor and the assignment operator. Unlike most classes theses
+/// operations do not 'copy' the resource but they 'steal' it.
+/// \c std::unique_ptr uses move semantics instead, which makes the intent of
+/// transferring the resource explicit. This difference between the two smart
+/// pointers requires to wrap the copy-ctor and assign-operator with
+/// \c std::move().
+///
+/// For example, given:
+/// \code
+/// std::auto_ptr<int> i, j;
+/// i = j;
+/// \endcode
+/// the code is transformed to:
+/// \code
+/// std::unique_ptr<int> i, j;
+/// i = std::move(j);
+/// \endcode
+class ReplaceAutoPtrTransform : public Transform {
+public:
+ ReplaceAutoPtrTransform(const TransformOptions &Options)
+ : Transform("ReplaceAutoPtr", Options) {}
+
+ /// \see Transform::run().
+ virtual int apply(FileOverrides &InputStates,
+ const clang::tooling::CompilationDatabase &Database,
+ const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
+};
+
+#endif // CPP11_MIGRATE_REPLACE_AUTO_PTR_H
Added: clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrActions.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrActions.cpp?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrActions.cpp (added)
+++ clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrActions.cpp Wed Jul 3 08:21:24 2013
@@ -0,0 +1,107 @@
+//===-- ReplaceAutoPtrActions.cpp --- std::auto_ptr replacement -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file contains the definition of the ASTMatcher callback
+/// for the ReplaceAutoPtr transform.
+///
+//===----------------------------------------------------------------------===//
+
+#include "ReplaceAutoPtrActions.h"
+#include "ReplaceAutoPtrMatchers.h"
+#include "Core/Transform.h"
+
+#include "clang/AST/ASTContext.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang;
+using namespace clang::tooling;
+using namespace clang::ast_matchers;
+
+namespace {
+
+/// \brief Verifies that the token at \p BeginningOfToken is 'auto_ptr'.
+bool checkTokenIsAutoPtr(clang::SourceLocation BeginningOfToken,
+ const clang::SourceManager &SM,
+ const clang::LangOptions &LangOptions) {
+ llvm::SmallVector<char, 8> Buffer;
+ bool Invalid = false;
+ llvm::StringRef Res =
+ Lexer::getSpelling(BeginningOfToken, Buffer, SM, LangOptions, &Invalid);
+
+ if (Invalid)
+ return false;
+
+ return Res == "auto_ptr";
+}
+
+} // end anonymous namespace
+
+void AutoPtrReplacer::run(const MatchFinder::MatchResult &Result) {
+ SourceManager &SM = *Result.SourceManager;
+ SourceLocation IdentifierLoc;
+
+ if (const TypeLoc *TL = Result.Nodes.getNodeAs<TypeLoc>(AutoPtrTokenId)) {
+ IdentifierLoc = locateFromTypeLoc(*TL, SM);
+ } else {
+ const UsingDecl *D = Result.Nodes.getNodeAs<UsingDecl>(AutoPtrTokenId);
+ assert(D && "Bad Callback. No node provided.");
+ IdentifierLoc = locateFromUsingDecl(D, SM);
+ }
+
+ if (IdentifierLoc.isMacroID())
+ IdentifierLoc = SM.getSpellingLoc(IdentifierLoc);
+
+ if (!Owner.isFileModifiable(SM, IdentifierLoc))
+ return;
+
+ // make sure that only the 'auto_ptr' token is replaced and not the template
+ // aliases [temp.alias]
+ if (!checkTokenIsAutoPtr(IdentifierLoc, SM, LangOptions()))
+ return;
+
+ Replace.insert(
+ Replacement(SM, IdentifierLoc, strlen("auto_ptr"), "unique_ptr"));
+ ++AcceptedChanges;
+}
+
+SourceLocation AutoPtrReplacer::locateFromTypeLoc(TypeLoc AutoPtrTypeLoc,
+ const SourceManager &SM) {
+ TemplateSpecializationTypeLoc TL =
+ AutoPtrTypeLoc.getAs<TemplateSpecializationTypeLoc>();
+ if (TL.isNull())
+ return SourceLocation();
+
+ return TL.getTemplateNameLoc();
+}
+
+SourceLocation
+AutoPtrReplacer::locateFromUsingDecl(const UsingDecl *UsingAutoPtrDecl,
+ const SourceManager &SM) {
+ return UsingAutoPtrDecl->getNameInfo().getBeginLoc();
+}
+
+void OwnershipTransferFixer::run(const MatchFinder::MatchResult &Result) {
+ SourceManager &SM = *Result.SourceManager;
+ const Expr *E = Result.Nodes.getNodeAs<Expr>(AutoPtrOwnershipTransferId);
+ assert(E && "Bad Callback. No node provided.");
+
+ CharSourceRange Range = Lexer::makeFileCharRange(
+ CharSourceRange::getTokenRange(E->getSourceRange()), SM, LangOptions());
+
+ if (Range.isInvalid())
+ return;
+
+ if (!Owner.isFileModifiable(SM, Range.getBegin()))
+ return;
+
+ Replace.insert(Replacement(SM, Range.getBegin(), 0, "std::move("));
+ Replace.insert(Replacement(SM, Range.getEnd(), 0, ")"));
+ AcceptedChanges += 2;
+}
Added: clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrActions.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrActions.h?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrActions.h (added)
+++ clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrActions.h Wed Jul 3 08:21:24 2013
@@ -0,0 +1,102 @@
+//===-- ReplaceAutoPtrActions.h ----- std::auto_ptr replacement -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file contains the declaration of the ASTMatcher callback
+/// for the ReplaceAutoPtr transform.
+///
+//===----------------------------------------------------------------------===//
+#ifndef CPP11_MIGRATE_REPLACE_AUTO_PTR_ACTIONS_H
+#define CPP11_MIGRATE_REPLACE_AUTO_PTR_ACTIONS_H
+
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Tooling/Refactoring.h"
+
+class Transform;
+
+/// \brief The callback to be used when replacing the \c std::auto_ptr types and
+/// using declarations.
+class AutoPtrReplacer : public clang::ast_matchers::MatchFinder::MatchCallback {
+public:
+ AutoPtrReplacer(clang::tooling::Replacements &Replace,
+ unsigned &AcceptedChanges, const Transform &Owner)
+ : Replace(Replace), AcceptedChanges(AcceptedChanges), Owner(Owner) {}
+
+ /// \brief Entry point to the callback called when matches are made.
+ virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
+ LLVM_OVERRIDE;
+
+private:
+ /// \brief Locates the \c auto_ptr token when it is referred by a \c TypeLoc.
+ ///
+ /// \code
+ /// std::auto_ptr<int> i;
+ /// ^~~~~~~~~~~~~
+ /// \endcode
+ /// The caret represents the location returned and the tildes cover the
+ /// parameter \p AutoPtrTypeLoc.
+ ///
+ /// \return An invalid \c SourceLocation if not found, otherwise the location
+ /// of the beginning of the \c auto_ptr token.
+ clang::SourceLocation locateFromTypeLoc(clang::TypeLoc AutoPtrTypeLoc,
+ const clang::SourceManager &SM);
+
+ /// \brief Locates the \c auto_ptr token in using declarations.
+ ///
+ /// \code
+ /// using std::auto_ptr;
+ /// ^
+ /// \endcode
+ /// The caret represents the location returned.
+ ///
+ /// \return An invalid \c SourceLocation if not found, otherwise the
+ /// location of the beginning of the \c auto_ptr token.
+ clang::SourceLocation
+ locateFromUsingDecl(const clang::UsingDecl *UsingAutoPtrDecl,
+ const clang::SourceManager &SM);
+
+private:
+ clang::tooling::Replacements &Replace;
+ unsigned &AcceptedChanges;
+ const Transform &Owner;
+};
+
+/// \brief The callback to be used to fix the ownership transfers of
+/// \c auto_ptr,
+///
+/// \c unique_ptr requires to use \c std::move() explicitly in order to transfer
+/// the ownership.
+///
+/// Given:
+/// \code
+/// std::auto_ptr<int> a, b;
+/// a = b;
+/// \endcode
+/// The last statement is transformed to:
+/// \code
+/// a = std::move(b);
+/// \endcode
+class OwnershipTransferFixer
+ : public clang::ast_matchers::MatchFinder::MatchCallback {
+public:
+ OwnershipTransferFixer(clang::tooling::Replacements &Replace,
+ unsigned &AcceptedChanges, const Transform &Owner)
+ : Replace(Replace), AcceptedChanges(AcceptedChanges), Owner(Owner) {}
+
+ /// \brief Entry point to the callback called when matches are made.
+ virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
+ LLVM_OVERRIDE;
+
+private:
+ clang::tooling::Replacements &Replace;
+ unsigned &AcceptedChanges;
+ const Transform &Owner;
+};
+
+#endif // CPP11_MIGRATE_REPLACE_AUTO_PTR_ACTIONS_H
Added: clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrMatchers.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrMatchers.cpp?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrMatchers.cpp (added)
+++ clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrMatchers.cpp Wed Jul 3 08:21:24 2013
@@ -0,0 +1,113 @@
+//===-- ReplaceAutoPtrMatchers.cpp - std::auto_ptr replacement -*- C++ -*--===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file contains the definitions for matcher-generating functions
+/// and names for bound nodes found by AST matchers.
+///
+//===----------------------------------------------------------------------===//
+
+#include "ReplaceAutoPtrMatchers.h"
+
+const char *AutoPtrTokenId = "AutoPtrTokenId";
+const char *AutoPtrOwnershipTransferId = "AutoPtrOwnershipTransferId";
+
+namespace clang {
+namespace ast_matchers {
+
+/// \brief Matches expressions that are lvalues.
+///
+/// In the following example, a[0] matches expr(isLValue()):
+/// \code
+/// std::string a[2];
+/// std::string b;
+/// b = a[0];
+/// b = "this string won't match";
+/// \endcode
+AST_MATCHER(Expr, isLValue) {
+ return Node.getValueKind() == VK_LValue;
+}
+
+/// \brief Matches declarations whose declaration context is the C++ standard
+/// library namespace \c std.
+///
+/// Note that inline namespaces are silently ignored during the lookup since
+/// both libstdc++ and libc++ are known to use them for versioning purposes.
+///
+/// Given
+/// \code
+/// namespace ns {
+/// struct my_type {};
+/// using namespace std;
+/// }
+///
+/// using std::vector;
+/// using ns::my_type;
+/// using ns::list;
+/// \endcode
+/// usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(isFromStdNamespace())))
+/// matches "using std::vector" and "using ns::list".
+AST_MATCHER(Decl, isFromStdNamespace) {
+ const DeclContext *D = Node.getDeclContext();
+
+ while (D->isInlineNamespace())
+ D = D->getParent();
+
+ if (!D->isNamespace() || !D->getParent()->isTranslationUnit())
+ return false;
+
+ const IdentifierInfo *Info = cast<NamespaceDecl>(D)->getIdentifier();
+
+ return Info && Info->isStr("std");
+}
+
+} // end namespace ast_matchers
+} // end namespace clang
+
+using namespace clang;
+using namespace clang::ast_matchers;
+
+// shared matchers
+static DeclarationMatcher AutoPtrDecl =
+ recordDecl(hasName("auto_ptr"), isFromStdNamespace());
+
+static TypeMatcher AutoPtrType = qualType(hasDeclaration(AutoPtrDecl));
+
+// Matcher that finds expressions that are candidates to be wrapped with
+// 'std::move()'.
+//
+// Binds the id \c AutoPtrOwnershipTransferId to the expression.
+static StatementMatcher MovableArgumentMatcher = expr(
+ allOf(isLValue(), hasType(AutoPtrType))).bind(AutoPtrOwnershipTransferId);
+
+TypeLocMatcher makeAutoPtrTypeLocMatcher() {
+ // skip elaboratedType() as the named type will match soon thereafter.
+ return typeLoc(loc(qualType(AutoPtrType, unless(elaboratedType()))))
+ .bind(AutoPtrTokenId);
+}
+
+DeclarationMatcher makeAutoPtrUsingDeclMatcher() {
+ return usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(
+ allOf(hasName("auto_ptr"), isFromStdNamespace())))).bind(AutoPtrTokenId);
+}
+
+StatementMatcher makeTransferOwnershipExprMatcher() {
+ StatementMatcher assignOperator =
+ operatorCallExpr(allOf(
+ hasOverloadedOperatorName("="),
+ callee(methodDecl(ofClass(AutoPtrDecl))),
+ hasArgument(1, MovableArgumentMatcher)));
+
+ StatementMatcher copyCtor =
+ constructExpr(allOf(hasType(AutoPtrType),
+ argumentCountIs(1),
+ hasArgument(0, MovableArgumentMatcher)));
+
+ return anyOf(assignOperator, copyCtor);
+}
Added: clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrMatchers.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrMatchers.h?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrMatchers.h (added)
+++ clang-tools-extra/trunk/cpp11-migrate/ReplaceAutoPtr/ReplaceAutoPtrMatchers.h Wed Jul 3 08:21:24 2013
@@ -0,0 +1,63 @@
+//===-- ReplaceAutoPtrMatchers.h --- std::auto_ptr replacement -*- C++ -*--===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file contains the declarations for matcher-generating functions
+/// and names for bound nodes found by AST matchers.
+///
+//===----------------------------------------------------------------------===//
+#ifndef CPP11_MIGRATE_REPLACE_AUTO_PTR_MATCHERS_H
+#define CPP11_MIGRATE_REPLACE_AUTO_PTR_MATCHERS_H
+
+#include "clang/ASTMatchers/ASTMatchers.h"
+
+/// Names to bind with matched expressions.
+extern const char *AutoPtrTokenId;
+extern const char *AutoPtrOwnershipTransferId;
+
+/// \brief Creates a matcher that finds the locations of types referring to the
+/// \c std::auto_ptr() type.
+///
+/// \code
+/// std::auto_ptr<int> a;
+/// ^~~~~~~~~~~~~
+///
+/// typedef std::auto_ptr<int> int_ptr_t;
+/// ^~~~~~~~~~~~~
+///
+/// std::auto_ptr<int> fn(std::auto_ptr<int>);
+/// ^~~~~~~~~~~~~ ^~~~~~~~~~~~~
+///
+/// <etc...>
+/// \endcode
+clang::ast_matchers::TypeLocMatcher makeAutoPtrTypeLocMatcher();
+
+/// \brief Creates a matcher that finds the using declarations referring to
+/// \c std::auto_ptr.
+///
+/// \code
+/// using std::auto_ptr;
+/// ^~~~~~~~~~~~~~~~~~~
+/// \endcode
+clang::ast_matchers::DeclarationMatcher makeAutoPtrUsingDeclMatcher();
+
+/// \brief Creates a matcher that finds the \c std::auto_ptr copy-ctor and
+/// assign-operator expressions.
+///
+/// \c AutoPtrOwnershipTransferId is assigned to the argument of the expression,
+/// this is the part that has to be wrapped by \c std::move().
+///
+/// \code
+/// std::auto_ptr<int> i, j;
+/// i = j;
+/// ~~~~^
+/// \endcode
+clang::ast_matchers::StatementMatcher makeTransferOwnershipExprMatcher();
+
+#endif // CPP11_MIGRATE_REPLACE_AUTO_PTR_MATCHERS_H
Modified: clang-tools-extra/trunk/cpp11-migrate/tool/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/cpp11-migrate/tool/CMakeLists.txt?rev=185535&r1=185534&r2=185535&view=diff
==============================================================================
--- clang-tools-extra/trunk/cpp11-migrate/tool/CMakeLists.txt (original)
+++ clang-tools-extra/trunk/cpp11-migrate/tool/CMakeLists.txt Wed Jul 3 08:21:24 2013
@@ -19,6 +19,9 @@ list(APPEND Cpp11MigrateSources ${UseAut
file(GLOB_RECURSE AddOverrideSources "../AddOverride/*.cpp")
list(APPEND Cpp11MigrateSources ${AddOverrideSources})
+file(GLOB_RECURSE ReplaceAutoPtrSources "../ReplaceAutoPtr/*.cpp")
+list(APPEND Cpp11MigrateSources ${ReplaceAutoPtrSources})
+
add_clang_executable(cpp11-migrate
${Cpp11MigrateSources}
)
Modified: clang-tools-extra/trunk/cpp11-migrate/tool/Cpp11Migrate.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/cpp11-migrate/tool/Cpp11Migrate.cpp?rev=185535&r1=185534&r2=185535&view=diff
==============================================================================
--- clang-tools-extra/trunk/cpp11-migrate/tool/Cpp11Migrate.cpp (original)
+++ clang-tools-extra/trunk/cpp11-migrate/tool/Cpp11Migrate.cpp Wed Jul 3 08:21:24 2013
@@ -23,6 +23,7 @@
#include "UseNullptr/UseNullptr.h"
#include "UseAuto/UseAuto.h"
#include "AddOverride/AddOverride.h"
+#include "ReplaceAutoPtr/ReplaceAutoPtr.h"
#include "clang/Frontend/FrontendActions.h"
#include "clang/Tooling/CommonOptionsParser.h"
#include "clang/Tooling/Tooling.h"
@@ -105,6 +106,10 @@ int main(int argc, const char **argv) {
TransformManager.registerTransform(
"add-override", "Make use of override specifier where possible",
&ConstructTransform<AddOverrideTransform>);
+ TransformManager.registerTransform(
+ "replace-auto_ptr", "Replace auto_ptr (deprecated) by unique_ptr"
+ " (EXPERIMENTAL)",
+ &ConstructTransform<ReplaceAutoPtrTransform>);
// Add more transform options here.
// This causes options to be parsed.
Modified: clang-tools-extra/trunk/cpp11-migrate/tool/Makefile
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/cpp11-migrate/tool/Makefile?rev=185535&r1=185534&r2=185535&view=diff
==============================================================================
--- clang-tools-extra/trunk/cpp11-migrate/tool/Makefile (original)
+++ clang-tools-extra/trunk/cpp11-migrate/tool/Makefile Wed Jul 3 08:21:24 2013
@@ -30,6 +30,8 @@ SOURCES += $(addprefix ../UseAuto/,$(not
BUILT_SOURCES += $(ObjDir)/../UseAuto/.objdir
SOURCES += $(addprefix ../AddOverride/,$(notdir $(wildcard $(PROJ_SRC_DIR)/../AddOverride/*.cpp)))
BUILT_SOURCES += $(ObjDir)/../AddOverride/.objdir
+SOURCES += $(addprefix ../ReplaceAutoPtr/,$(notdir $(wildcard $(PROJ_SRC_DIR)/../ReplaceAutoPtr/*.cpp)))
+BUILT_SOURCES += $(ObjDir)/../ReplaceAutoPtr/.objdir
LINK_COMPONENTS := $(TARGETS_TO_BUILD) asmparser bitreader support mc mcparser option
USEDLIBS = migrateCore.a clangTooling.a clangFrontend.a clangSerialization.a clangDriver.a \
Modified: clang-tools-extra/trunk/docs/MigratorUsage.rst
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/docs/MigratorUsage.rst?rev=185535&r1=185534&r2=185535&view=diff
==============================================================================
--- clang-tools-extra/trunk/docs/MigratorUsage.rst (original)
+++ clang-tools-extra/trunk/docs/MigratorUsage.rst Wed Jul 3 08:21:24 2013
@@ -126,3 +126,9 @@ Transform-Specific Command Line Options
projects that use such macros to maintain build compatibility with non-C++11
code.
+.. option:: -replace-auto_ptr
+
+ Replace ``std::auto_ptr`` (deprecated in C++11) by ``std::unique_ptr`` and
+ wrap calls to the copy constructor and assignment operator with
+ ``std::move()``.
+ See :doc:`ReplaceAutoPtrTransform`.
Modified: clang-tools-extra/trunk/docs/README.txt
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/docs/README.txt?rev=185535&r1=185534&r2=185535&view=diff
==============================================================================
--- clang-tools-extra/trunk/docs/README.txt (original)
+++ clang-tools-extra/trunk/docs/README.txt Wed Jul 3 08:21:24 2013
@@ -1,6 +1,6 @@
-------------------------------------------------------------
-Documetation for the tools of clang-tools-extra repo project
-------------------------------------------------------------
+-------------------------------------------------------------
+Documentation for the tools of clang-tools-extra repo project
+-------------------------------------------------------------
Sphinx and doxygen documentation is generated by executing make.
Added: clang-tools-extra/trunk/docs/ReplaceAutoPtrTransform.rst
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/docs/ReplaceAutoPtrTransform.rst?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/docs/ReplaceAutoPtrTransform.rst (added)
+++ clang-tools-extra/trunk/docs/ReplaceAutoPtrTransform.rst Wed Jul 3 08:21:24 2013
@@ -0,0 +1,72 @@
+.. index:: Replace-AutoPtr Transform
+
+=========================
+Replace-AutoPtr Transform
+=========================
+
+The Replace-AutoPtr Transform replaces the uses of the deprecated class
+``std::auto_ptr`` by ``std::unique_ptr`` (introduced in C++11). The transfer of
+ownership, done by the copy-constructor and the assignment operator, is changed
+to match ``std::unique_ptr`` usage by using explicit calls to ``std::move()``.
+The transform is enabled with the :option:`-replace-auto_ptr` option of
+:program:`cpp11-migrate`.
+
+Migration example:
+
+.. code-block:: c++
+
+ -void take_ownership_fn(std::auto_ptr<int> int_ptr);
+ +void take_ownership_fn(std::unique_ptr<int> int_ptr);
+
+ void f(int x) {
+ - std::auto_ptr<int> a(new int(x));
+ - std::auto_ptr<int> b;
+ + std::unique_ptr<int> a(new int(x));
+ + std::unique_ptr<int> b;
+
+ - b = a;
+ - take_ownership_fn(b);
+ + b = std::move(a);
+ + take_ownership_fn(std::move(b));
+ }
+
+
+Known Limitations
+=================
+* If headers modification is not activated or if a header is not allowed to be
+ changed this transform will produce broken code (compilation error), where the
+ the headers' code will stay unchanged while the code using them will be
+ changed.
+
+* Client code that declares a reference to an ``std::auto_ptr`` coming from code
+ that can't be migrated (such as a header coming from a 3\ :sup:`rd` party
+ library) will produce a compilation error after migration. This is because the
+ type of the reference will be changed to ``std::unique_ptr`` but the type
+ returned by the library won't change, binding a reference to
+ ``std::unique_ptr`` from an ``std::auto_ptr``. This pattern doesn't make much
+ sense and usually ``std::auto_ptr`` are stored by value (otherwise what is the
+ point in using them instead of a reference or a pointer?).
+
+ .. code-block:: c++
+
+ // <3rd-party header...>
+ std::auto_ptr<int> get_value();
+ const std::auto_ptr<int> & get_ref();
+
+ // <calling code (with migration)...>
+ -std::auto_ptr<int> a(get_value());
+ +std::unique_ptr<int> a(get_value()); // ok, unique_ptr constructed from auto_ptr
+
+ -const std::auto_ptr<int> & p = get_ptr();
+ +const std::unique_ptr<int> & p = get_ptr(); // won't compile
+
+* Non-instantiated templates aren't modified.
+
+ .. code-block:: c++
+
+ template <typename X>
+ void f() {
+ std::auto_ptr<X> p;
+ }
+
+ // only 'f<int>()' (or similar) will trigger the replacement
Modified: clang-tools-extra/trunk/docs/cpp11-migrate.rst
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/docs/cpp11-migrate.rst?rev=185535&r1=185534&r2=185535&view=diff
==============================================================================
--- clang-tools-extra/trunk/docs/cpp11-migrate.rst (original)
+++ clang-tools-extra/trunk/docs/cpp11-migrate.rst Wed Jul 3 08:21:24 2013
@@ -11,6 +11,7 @@ C++11 Migrator User's Manual
UseNullptrTransform
LoopConvertTransform
AddOverrideTransform
+ ReplaceAutoPtrTransform
MigratorUsage
:program:`cpp11-migrate` is a standalone tool used to automatically convert
@@ -113,3 +114,5 @@ independently enabled. The transforms cu
* :doc:`UseAutoTransform`
* :doc:`AddOverrideTransform`
+
+* :doc:`ReplaceAutoPtrTransform`
Added: clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/basic.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/basic.h?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/basic.h (added)
+++ clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/basic.h Wed Jul 3 08:21:24 2013
@@ -0,0 +1,56 @@
+#ifndef INPUTS_BASIC_H
+#define INPUTS_BASIC_H
+
+#include "memory_stub.h"
+
+// Instrumentation for auto_ptr_ref test
+// @{
+struct Base {};
+struct Derived : Base {};
+std::auto_ptr<Derived> create_derived_ptr();
+// CHECK: std::unique_ptr<Derived> create_derived_ptr();
+// }
+
+// Test function return values (declaration)
+std::auto_ptr<char> f_5();
+// CHECK: std::unique_ptr<char> f_5()
+
+// Test function parameters
+void f_6(std::auto_ptr<int>);
+// CHECK: void f_6(std::unique_ptr<int>);
+void f_7(const std::auto_ptr<int> &);
+// CHECK: void f_7(const std::unique_ptr<int> &);
+
+// Test on record type fields
+struct A {
+ std::auto_ptr<int> field;
+ // CHECK: std::unique_ptr<int> field;
+
+ typedef std::auto_ptr<int> int_ptr_type;
+ // CHECK: typedef std::unique_ptr<int> int_ptr_type;
+};
+
+// Test template WITH instantiation
+template <typename T> struct B {
+ typedef typename std::auto_ptr<T> created_type;
+ // CHECK: typedef typename std::unique_ptr<T> created_type;
+
+ created_type create() { return std::auto_ptr<T>(new T()); }
+ // CHECK: created_type create() { return std::unique_ptr<T>(new T()); }
+};
+
+// Test 'using' in a namespace (declaration)
+namespace ns_1 {
+// Test multiple using declarations
+using std::auto_ptr;
+using std::auto_ptr;
+// CHECK: using std::unique_ptr;
+// CHECK-NEXT: using std::unique_ptr;
+}
+
+namespace ns_2 {
+template <typename T> struct auto_ptr {};
+// CHECK: template <typename T> struct auto_ptr {};
+}
+
+#endif // INPUTS_BASIC_H
Added: clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/memory_stub.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/memory_stub.h?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/memory_stub.h (added)
+++ clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/Inputs/memory_stub.h Wed Jul 3 08:21:24 2013
@@ -0,0 +1,61 @@
+//===-----------------------------------------------------------*- C++ -*--===//
+//
+// This file contains a shell implementation of the 'auto_ptr' type from the
+// standard library. This shell aims to support the variations between standard
+// library implementations.
+//
+// Variations for how 'auto_ptr' is presented:
+// 1. Defined directly in namespace std
+// 2. Use a versioned inline namespace in std (default on libc++).
+//
+// Use the preprocessor to define USE_INLINE_NAMESPACE=1 and use the second
+// variation.
+//
+//===----------------------------------------------------------------------===//
+
+namespace std {
+
+#if USE_INLINE_NAMESPACE
+inline namespace _1 {
+#endif
+
+template <class Y> struct auto_ptr_ref {
+ Y *y_;
+};
+
+template <class X> class auto_ptr {
+public:
+ typedef X element_type;
+ // D.10.1.1 construct/copy/destroy:
+ explicit auto_ptr(X *p = 0) throw() {}
+ auto_ptr(auto_ptr &) throw() {}
+ template <class Y> auto_ptr(auto_ptr<Y> &) throw() {}
+ auto_ptr &operator=(auto_ptr &) throw() { return *this; }
+ template <class Y> auto_ptr &operator=(auto_ptr<Y> &) throw() {
+ return *this;
+ }
+ auto_ptr &operator=(auto_ptr_ref<X> r) throw() { return *this; }
+ ~auto_ptr() throw() {}
+ // D.10.1.3 conversions:
+ auto_ptr(auto_ptr_ref<X> r) throw() : x_(r.y_) {}
+ template <class Y> operator auto_ptr_ref<Y>() throw() {
+ auto_ptr_ref<Y> r;
+ r.y_ = x_;
+ return r;
+ }
+ template <class Y> operator auto_ptr<Y>() throw() { return auto_ptr<Y>(x_); }
+
+private:
+ X *x_;
+};
+
+template <> class auto_ptr<void> {
+public:
+ typedef void element_type;
+};
+
+#if USE_INLINE_NAMESPACE
+} // namespace _1
+#endif
+
+} // end namespace std
Added: clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/basic.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/basic.cpp?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/basic.cpp (added)
+++ clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/basic.cpp Wed Jul 3 08:21:24 2013
@@ -0,0 +1,154 @@
+// RUN: mkdir -p %T/Inputs
+//
+// Without inline namespace:
+//
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: grep -Ev "// *[A-Z-]+:" %S/Inputs/basic.h > %T/Inputs/basic.h
+// RUN: grep -Ev "// *[A-Z-]+:" %S/Inputs/memory_stub.h > %T/Inputs/memory_stub.h
+// RUN: cpp11-migrate -headers -include=%T -replace-auto_ptr %t.cpp -- \
+// RUN: -std=c++11 -I %T
+// RUN: FileCheck -input-file=%t.cpp %s
+// RUN: FileCheck -input-file=%T/Inputs/basic.h %S/Inputs/basic.h
+//
+// With inline namespace:
+//
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: grep -Ev "// *[A-Z-]+:" %S/Inputs/basic.h > %T/Inputs/basic.h
+// RUN: grep -Ev "// *[A-Z-]+:" %S/Inputs/memory_stub.h > %T/Inputs/memory_stub.h
+// RUN: cpp11-migrate -headers -include=%T -replace-auto_ptr %t.cpp -- \
+// RUN: -DUSE_INLINE_NAMESPACE=1 -std=c++11 -I %T
+// RUN: FileCheck -input-file=%t.cpp %s
+// RUN: FileCheck -input-file=%T/Inputs/basic.h %S/Inputs/basic.h
+
+#include "Inputs/basic.h"
+
+void f_1() {
+ std::auto_ptr<int> a;
+ // CHECK: std::unique_ptr<int> a;
+
+ // check that spaces aren't modified unnecessarily
+ std:: auto_ptr <int> b;
+ // CHECK: std:: unique_ptr <int> b;
+ std :: auto_ptr < char > c(new char());
+ // CHECK: std :: unique_ptr < char > c(new char());
+
+ // Test construction from a temporary
+ std::auto_ptr<char> d = std::auto_ptr<char>();
+ // CHECK: std::unique_ptr<char> d = std::unique_ptr<char>();
+
+ typedef std::auto_ptr<int> int_ptr_t;
+ // CHECK: typedef std::unique_ptr<int> int_ptr_t;
+ int_ptr_t e(new int());
+ // CHECK: int_ptr_t e(new int());
+
+ // Test pointers
+ std::auto_ptr<int> *f;
+ // CHECK: std::unique_ptr<int> *f;
+
+ // Test 'static' declarations
+ static std::auto_ptr<int> g;
+ // CHECK: static std::unique_ptr<int> g;
+
+ // Test with cv-qualifiers
+ const std::auto_ptr<int> h;
+ // CHECK: const std::unique_ptr<int> h;
+ volatile std::auto_ptr<int> i;
+ // CHECK: volatile std::unique_ptr<int> i;
+ const volatile std::auto_ptr<int> j;
+ // CHECK: const volatile std::unique_ptr<int> j;
+
+ // Test auto and initializer-list
+ auto k = std::auto_ptr<int>{};
+ // CHECK: auto k = std::unique_ptr<int>{};
+ std::auto_ptr<int> l{std::auto_ptr<int>()};
+ // CHECK: std::unique_ptr<int> l{std::unique_ptr<int>()};
+
+ // Test interlocked auto_ptr
+ std::auto_ptr<std::auto_ptr<int> > m;
+ // CHECK: std::unique_ptr<std::unique_ptr<int> > m;
+
+ // Test temporaries
+ std::auto_ptr<char>();
+ // CHECK: std::unique_ptr<char>();
+
+ // Test void-specialization
+ std::auto_ptr<void> n;
+ // CHECK: std::unique_ptr<void> n;
+
+ // Test template WITH instantiation (instantiation)
+ B<double> o;
+ std::auto_ptr<double> p(o.create());
+ // CHECK: std::unique_ptr<double> p(o.create());
+
+ // Test 'using' in a namespace ("definition")
+ ns_1::auto_ptr<int> q;
+ // CHECK: ns_1::unique_ptr<int> q;
+
+ // Test construction with an 'auto_ptr_ref'
+ std::auto_ptr<Base> r(create_derived_ptr());
+ // CHECK: std::unique_ptr<Base> r(create_derived_ptr());
+}
+
+// Test without the nested name specifiers
+void f_2() {
+ using namespace std;
+
+ auto_ptr<int> a;
+ // CHECK: unique_ptr<int> a;
+}
+
+// Test using declaration
+void f_3() {
+ using std::auto_ptr;
+ // CHECK: using std::unique_ptr;
+
+ auto_ptr<int> a;
+ // CHECK: unique_ptr<int> a;
+}
+
+// Test messing-up with macros
+void f_4() {
+#define MACRO_1 <char>
+ std::auto_ptr MACRO_1 p(new char());
+// CHECK: std::unique_ptr MACRO_1 p(new char());
+#define MACRO_2 auto_ptr
+ std::MACRO_2<int> q;
+// CHECK: #define MACRO_2 unique_ptr
+#define MACRO_3(Type) std::auto_ptr<Type>
+ MACRO_3(float)r(new float());
+// CHECK: #define MACRO_3(Type) std::unique_ptr<Type>
+#define MACRO_4 std::auto_ptr
+ using MACRO_4;
+// CHECK: #define MACRO_4 std::unique_ptr
+#undef MACRO_1
+#undef MACRO_2
+#undef MACRO_3
+#undef MACRO_4
+}
+
+// Test function return values (definition)
+std::auto_ptr<char> f_5()
+// CHECK: std::unique_ptr<char> f_5()
+{
+ // Test constructor
+ return std::auto_ptr<char>(new char());
+ // CHECK: return std::unique_ptr<char>(new char());
+}
+
+// Test that non-std auto_ptr aren't replaced
+void f_8() {
+ ns_2::auto_ptr<char> a;
+ // CHECK: ns_2::auto_ptr<char> a;
+ using namespace ns_2;
+ auto_ptr<int> b;
+ // CHECK: auto_ptr<int> b;
+}
+
+namespace std {
+template <typename T> using aaaaaaaa = auto_ptr<T>;
+}
+// We want to avoid replacing 'aaaaaaaa' by unique_ptr here. It's better to
+// change the type alias directly.
+// XXX: maybe another test will be more relevant to test this potential error.
+std::aaaaaaaa<int> d;
+// CHECK: std::aaaaaaaa<int> d;
Added: clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/move.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/move.cpp?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/move.cpp (added)
+++ clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/move.cpp Wed Jul 3 08:21:24 2013
@@ -0,0 +1,63 @@
+// Without inline namespace:
+//
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: cpp11-migrate -replace-auto_ptr %t.cpp -- -I %S/Inputs std=c++11
+// RUN: FileCheck -input-file=%t.cpp %s
+//
+// With inline namespace:
+//
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: cpp11-migrate -replace-auto_ptr %t.cpp -- -I %S/Inputs std=c++11 \
+// RUN: -DUSE_INLINE_NAMESPACE=1
+// RUN: FileCheck -input-file=%t.cpp %s
+
+#include "memory_stub.h"
+
+void takes_ownership_fn(std::auto_ptr<int> x);
+// CHECK: void takes_ownership_fn(std::unique_ptr<int> x);
+
+std::auto_ptr<int> get_by_value();
+// CHECK: std::unique_ptr<int> get_by_value();
+
+class Wrapper {
+public:
+ std::auto_ptr<int> &get_wrapped();
+
+private:
+ std::auto_ptr<int> wrapped;
+};
+
+void f() {
+ std::auto_ptr<int> a, b, c;
+ // CHECK: std::unique_ptr<int> a, b, c;
+ Wrapper wrapper_a, wrapper_b;
+
+ a = b;
+ // CHECK: a = std::move(b);
+
+ wrapper_a.get_wrapped() = wrapper_b.get_wrapped();
+ // CHECK: wrapper_a.get_wrapped() = std::move(wrapper_b.get_wrapped());
+
+ // Test that 'std::move()' is inserted when call to the
+ // copy-constructor are made.
+ takes_ownership_fn(c);
+ // CHECK: takes_ownership_fn(std::move(c));
+ takes_ownership_fn(wrapper_a.get_wrapped());
+ // CHECK: takes_ownership_fn(std::move(wrapper_a.get_wrapped()));
+
+ std::auto_ptr<int> d[] = { std::auto_ptr<int>(new int(1)),
+ std::auto_ptr<int>(new int(2)) };
+ std::auto_ptr<int> e = d[0];
+ // CHECK: std::unique_ptr<int> d[] = { std::unique_ptr<int>(new int(1)),
+ // CHECK-NEXT: std::unique_ptr<int>(new int(2)) };
+ // CHECK-NEXT: std::unique_ptr<int> e = std::move(d[0]);
+
+ // Test that std::move() is not used when assigning an rvalue
+ std::auto_ptr<int> f;
+ f = std::auto_ptr<int>(new int(0));
+ // CHECK: std::unique_ptr<int> f;
+ // CHECK-NEXT: f = std::unique_ptr<int>(new int(0));
+
+ std::auto_ptr<int> g = get_by_value();
+ // CHECK: std::unique_ptr<int> g = get_by_value();
+}
Added: clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/template_fail.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/template_fail.cpp?rev=185535&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/template_fail.cpp (added)
+++ clang-tools-extra/trunk/test/cpp11-migrate/ReplaceAutoPtr/template_fail.cpp Wed Jul 3 08:21:24 2013
@@ -0,0 +1,31 @@
+// XFAIL: *
+//
+// Without inline namespace:
+//
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: cpp11-migrate -replace-auto_ptr %t.cpp -- -I %S/Inputs std=c++11
+// RUN: FileCheck -input-file=%t.cpp %s
+//
+// With inline namespace:
+//
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: cpp11-migrate -replace-auto_ptr %t.cpp -- -I %S/Inputs std=c++11 \
+// RUN: -DUSE_INLINE_NAMESPACE=1
+// RUN: FileCheck -input-file=%t.cpp %s
+
+#include "memory_stub.h"
+
+// Fail to modify when the template is never instantiated.
+//
+// This might not be an issue. If it's never used it doesn't really matter if
+// it's changed or not. If it's a header and one of the source use it, then it
+// will still be changed.
+template <typename X>
+void f() {
+ std::auto_ptr<X> p;
+ // CHECK: std::unique_ptr<X> p;
+}
+
+// Alias template could be replaced if a matcher existed.
+template <typename T> using aaaaaaaa = auto_ptr<T>;
+// CHECK: template <typename T> using aaaaaaaa = unique_ptr<T>;
More information about the cfe-commits
mailing list