void PassByValueCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus)
return;
Finder->addMatcher(
cxxConstructorDecl(
forEachConstructorInitializer(
cxxCtorInitializer(
// Clang builds a CXXConstructExpr only whin it knows which
// constructor will be called. In dependent contexts a
// ParenListExpr is generated instead of a CXXConstructExpr,
// filtering out templates automatically for us.
withInitializer(cxxConstructExpr(
has(ignoringParenImpCasts(declRefExpr(to(
parmVarDecl(
hasType(qualType(
// Match only const-ref or a non-const value
// parameters. Rvalues and const-values
// shouldn't be modified.
anyOf(constRefType(), nonConstValueType()))))
.bind("Param"))))),
hasDeclaration(cxxConstructorDecl(
isCopyConstructor(), unless(isDeleted()),
hasDeclContext(
cxxRecordDecl(isMoveConstructible())))))))
.bind("Initializer")))
.bind("Ctor"),
this);
}
void MakeSmartPtrCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
if (!isLanguageVersionSupported(getLangOpts()))
return;
// Calling make_smart_ptr from within a member function of a type with a
// private or protected constructor would be ill-formed.
auto CanCallCtor = unless(has(ignoringImpCasts(
cxxConstructExpr(hasDeclaration(decl(unless(isPublic())))))));
Finder->addMatcher(
cxxBindTemporaryExpr(has(ignoringParenImpCasts(
cxxConstructExpr(
hasType(getSmartPointerTypeMatcher()), argumentCountIs(1),
hasArgument(0,
cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType(
equalsBoundNode(PointerType))))),
CanCallCtor)
.bind(NewExpression)),
unless(isInTemplateInstantiation()))
.bind(ConstructorCall)))),
this);
Finder->addMatcher(
cxxMemberCallExpr(
thisPointerType(getSmartPointerTypeMatcher()),
callee(cxxMethodDecl(hasName("reset"))),
hasArgument(0, cxxNewExpr(CanCallCtor).bind(NewExpression)),
unless(isInTemplateInstantiation()))
.bind(ResetCall),
this);
}
MakeSharedCheck::SmartPtrTypeMatcher
MakeSharedCheck::getSmartPointerTypeMatcher() const {
return qualType(hasDeclaration(classTemplateSpecializationDecl(
matchesName("::std::shared_ptr"), templateArgumentCountIs(1),
hasTemplateArgument(
0, templateArgument(refersToType(qualType().bind(PointerType)))))));
}
void ReplaceAutoPtrCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus)
return;
auto AutoPtrDecl = recordDecl(hasName("auto_ptr"), isFromStdNamespace());
auto AutoPtrType = qualType(hasDeclaration(AutoPtrDecl));
// std::auto_ptr<int> a;
// ^~~~~~~~~~~~~
//
// typedef std::auto_ptr<int> int_ptr_t;
// ^~~~~~~~~~~~~
//
// std::auto_ptr<int> fn(std::auto_ptr<int>);
// ^~~~~~~~~~~~~ ^~~~~~~~~~~~~
Finder->addMatcher(typeLoc(loc(qualType(AutoPtrType,
// Skip elaboratedType() as the named
// type will match soon thereafter.
unless(elaboratedType()))))
.bind(AutoPtrTokenId),
this);
// using std::auto_ptr;
// ^~~~~~~~~~~~~~~~~~~
Finder->addMatcher(usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(allOf(
hasName("auto_ptr"), isFromStdNamespace()))))
.bind(AutoPtrTokenId),
this);
// Find ownership transfers via copy construction and assignment.
// AutoPtrOwnershipTransferId is bound to the the part that has to be wrapped
// into std::move().
// std::auto_ptr<int> i, j;
// i = j;
// ~~~~^
auto MovableArgumentMatcher =
expr(isLValue(), hasType(AutoPtrType)).bind(AutoPtrOwnershipTransferId);
Finder->addMatcher(
cxxOperatorCallExpr(hasOverloadedOperatorName("="),
callee(cxxMethodDecl(ofClass(AutoPtrDecl))),
hasArgument(1, MovableArgumentMatcher)),
this);
Finder->addMatcher(cxxConstructExpr(hasType(AutoPtrType), argumentCountIs(1),
hasArgument(0, MovableArgumentMatcher)),
this);
}
void AssignOperatorSignatureCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (getLangOpts().CPlusPlus) {
const auto HasGoodReturnType = methodDecl(returns(lValueReferenceType(
pointee(unless(isConstQualified()),
hasDeclaration(equalsBoundNode("class"))))));
const auto IsSelf = qualType(anyOf(
hasDeclaration(equalsBoundNode("class")),
referenceType(pointee(hasDeclaration(equalsBoundNode("class"))))));
const auto IsSelfAssign =
methodDecl(unless(anyOf(isDeleted(), isPrivate(), isImplicit())),
hasName("operator="), ofClass(recordDecl().bind("class")),
hasParameter(0, parmVarDecl(hasType(IsSelf))))
.bind("method");
Finder->addMatcher(
methodDecl(IsSelfAssign, unless(HasGoodReturnType)).bind("ReturnType"),
this);
const auto BadSelf = referenceType(
anyOf(lValueReferenceType(pointee(unless(isConstQualified()))),
rValueReferenceType(pointee(isConstQualified()))));
Finder->addMatcher(
methodDecl(IsSelfAssign, hasParameter(0, parmVarDecl(hasType(BadSelf))))
.bind("ArgumentType"),
this);
Finder->addMatcher(methodDecl(IsSelfAssign, isConst()).bind("Const"), this);
}
}
void ForwardingReferenceOverloadCheck::registerMatchers(MatchFinder *Finder) {
// Forwarding references require C++11 or later.
if (!getLangOpts().CPlusPlus11)
return;
auto ForwardingRefParm =
parmVarDecl(
hasType(qualType(rValueReferenceType(),
references(templateTypeParmType(hasDeclaration(
templateTypeParmDecl().bind("type-parm-decl")))),
unless(references(isConstQualified())))))
.bind("parm-var");
DeclarationMatcher findOverload =
cxxConstructorDecl(
hasParameter(0, ForwardingRefParm),
unless(hasAnyParameter(
// No warning: enable_if as constructor parameter.
parmVarDecl(hasType(isEnableIf())))),
unless(hasParent(functionTemplateDecl(has(templateTypeParmDecl(
// No warning: enable_if as type parameter.
hasDefaultArgument(isEnableIf())))))))
.bind("ctor");
Finder->addMatcher(findOverload, this);
}
void UniqueptrDeleteReleaseCheck::registerMatchers(MatchFinder *Finder) {
auto IsSusbstituted = qualType(anyOf(
substTemplateTypeParmType(), hasDescendant(substTemplateTypeParmType())));
auto UniquePtrWithDefaultDelete = classTemplateSpecializationDecl(
hasName("std::unique_ptr"),
hasTemplateArgument(1, refersToType(qualType(hasDeclaration(cxxRecordDecl(
hasName("std::default_delete")))))));
Finder->addMatcher(
cxxDeleteExpr(has(ignoringParenImpCasts(cxxMemberCallExpr(
on(expr(hasType(UniquePtrWithDefaultDelete),
unless(hasType(IsSusbstituted)))
.bind("uptr")),
callee(cxxMethodDecl(hasName("release")))))))
.bind("delete"),
this);
}
void NonConstReferences::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
parmVarDecl(
unless(isInstantiated()),
hasType(references(
qualType(unless(isConstQualified())).bind("referenced_type"))),
unless(hasType(rValueReferenceType())))
.bind("param"),
this);
}
void DeprecatedIosBaseAliasesCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus)
return;
auto IoStateDecl = typedefDecl(hasAnyName(DeprecatedTypes)).bind("TypeDecl");
auto IoStateType =
qualType(hasDeclaration(IoStateDecl), unless(elaboratedType()));
Finder->addMatcher(typeLoc(loc(IoStateType)).bind("TypeLoc"), this);
}
void StringReferenceMemberCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) {
// Look for const references to std::string or ::string.
auto String = anyOf(recordDecl(hasName("::std::basic_string")),
recordDecl(hasName("::string")));
auto ConstString = qualType(isConstQualified(), hasDeclaration(String));
// Ignore members in template instantiations.
Finder->addMatcher(fieldDecl(hasType(references(ConstString)),
unless(isInstantiated())).bind("member"),
this);
}
void UnconventionalAssignOperatorCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus)
return;
const auto HasGoodReturnType = cxxMethodDecl(returns(lValueReferenceType(
pointee(unless(isConstQualified()),
anyOf(autoType(), hasDeclaration(equalsBoundNode("class")))))));
const auto IsSelf = qualType(
anyOf(hasDeclaration(equalsBoundNode("class")),
referenceType(pointee(hasDeclaration(equalsBoundNode("class"))))));
const auto IsAssign =
cxxMethodDecl(unless(anyOf(isDeleted(), isPrivate(), isImplicit())),
hasName("operator="), ofClass(recordDecl().bind("class")))
.bind("method");
const auto IsSelfAssign =
cxxMethodDecl(IsAssign, hasParameter(0, parmVarDecl(hasType(IsSelf))))
.bind("method");
Finder->addMatcher(
cxxMethodDecl(IsAssign, unless(HasGoodReturnType)).bind("ReturnType"),
this);
const auto BadSelf = referenceType(
anyOf(lValueReferenceType(pointee(unless(isConstQualified()))),
rValueReferenceType(pointee(isConstQualified()))));
Finder->addMatcher(
cxxMethodDecl(IsSelfAssign,
hasParameter(0, parmVarDecl(hasType(BadSelf))))
.bind("ArgumentType"),
this);
Finder->addMatcher(
cxxMethodDecl(IsSelfAssign, anyOf(isConst(), isVirtual())).bind("cv"),
this);
const auto IsBadReturnStatement = returnStmt(unless(has(ignoringParenImpCasts(
anyOf(unaryOperator(hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())),
cxxOperatorCallExpr(argumentCountIs(1),
callee(unresolvedLookupExpr()),
hasArgument(0, cxxThisExpr())))))));
const auto IsGoodAssign = cxxMethodDecl(IsAssign, HasGoodReturnType);
Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))
.bind("returnStmt"),
this);
}
void ExceptionBaseclassCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
Finder->addMatcher(
cxxThrowExpr(allOf(has(expr(unless(hasType(qualType(hasCanonicalType(
hasDeclaration(cxxRecordDecl(isSameOrDerivedFrom(
hasName("std::exception")))))))))),
has(expr(unless(cxxUnresolvedConstructExpr()))),
eachOf(has(expr(hasType(namedDecl().bind("decl")))),
anything())))
.bind("bad_throw"),
this);
}
void UseBoolLiteralsCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
Finder->addMatcher(
implicitCastExpr(
has(ignoringParenImpCasts(integerLiteral().bind("literal"))),
hasImplicitDestinationType(qualType(booleanType())),
unless(isInTemplateInstantiation()),
anyOf(hasParent(explicitCastExpr().bind("cast")), anything())),
this);
Finder->addMatcher(
conditionalOperator(
hasParent(implicitCastExpr(
hasImplicitDestinationType(qualType(booleanType())),
unless(isInTemplateInstantiation()))),
eachOf(hasTrueExpression(
ignoringParenImpCasts(integerLiteral().bind("literal"))),
hasFalseExpression(
ignoringParenImpCasts(integerLiteral().bind("literal"))))),
this);
}
GenRet ArgSymbol::codegen() {
GenInfo* info = gGenInfo;
FILE* outfile = info->cfile;
GenRet ret;
if( outfile ) {
QualifiedType qt = qualType();
ret.c = '&';
ret.c += cname;
ret.isLVPtr = GEN_PTR;
if (qt.isRef() && !qt.isRefType())
ret.chplType = getOrMakeRefTypeDuringCodegen(typeInfo());
else if (qt.isWideRef() && !qt.isWideRefType()) {
Type* refType = getOrMakeRefTypeDuringCodegen(typeInfo());
ret.chplType = getOrMakeWideTypeDuringCodegen(refType);
}
/*
// BHARSH TODO: Is this still necessary?
if (q.isRef() && !q.isRefType()) {
ret.c = cname;
ret.isLVPtr = GEN_PTR;
} else if(q.isWideRef() && !q.isWideRefType()) {
ret.c = cname;
ret.isLVPtr = GEN_WIDE_PTR;
} else {
ret.c = '&';
ret.c += cname;
ret.isLVPtr = GEN_PTR;
}
*/
} else {
#ifdef HAVE_LLVM
ret = info->lvt->getValue(cname);
#endif
}
// BHARSH TODO: Is this still necessary?
//if( requiresCPtr() ) {
// // Don't try to use chplType.
// ret.chplType = NULL;
// ret = codegenLocalDeref(ret);
//}
//ret.chplType = this->type;
return ret;
}
void AvoidConstParamsInDecls::registerMatchers(MatchFinder *Finder) {
const auto ConstParamDecl =
parmVarDecl(hasType(qualType(isConstQualified()))).bind("param");
Finder->addMatcher(
functionDecl(unless(isDefinition()),
// Lambdas are always their own definition, but they
// generate a non-definition FunctionDecl too. Ignore those.
// Class template instantiations have a non-definition
// CXXMethodDecl for methods that aren't used in this
// translation unit. Ignore those, as the template will have
// already been checked.
unless(cxxMethodDecl(ofClass(cxxRecordDecl(anyOf(
isLambda(), ast_matchers::isTemplateInstantiation()))))),
has(typeLoc(forEach(ConstParamDecl))))
.bind("func"),
this);
}
void StringIntegerAssignmentCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
Finder->addMatcher(
cxxOperatorCallExpr(
anyOf(hasOverloadedOperatorName("="),
hasOverloadedOperatorName("+=")),
callee(cxxMethodDecl(ofClass(classTemplateSpecializationDecl(
hasName("::std::basic_string"),
hasTemplateArgument(0, refersToType(qualType().bind("type"))))))),
hasArgument(1,
ignoringImpCasts(expr(hasType(isInteger()),
unless(hasType(isAnyCharacter())))
.bind("expr"))),
unless(isInTemplateInstantiation())),
this);
}
void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++11; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus11)
return;
Finder->addMatcher(
cxxConstructorDecl(
unless(isImplicit()),
allOf(isMoveConstructor(),
hasAnyConstructorInitializer(
cxxCtorInitializer(
withInitializer(cxxConstructExpr(hasDeclaration(
cxxConstructorDecl(isCopyConstructor())
.bind("ctor")))))
.bind("move-init")))),
this);
auto NonConstValueMovableAndExpensiveToCopy =
qualType(allOf(unless(pointerType()), unless(isConstQualified()),
hasDeclaration(cxxRecordDecl(hasMethod(cxxConstructorDecl(
isMoveConstructor(), unless(isDeleted()))))),
matchers::isExpensiveToCopy()));
// This checker is also used to implement cert-oop11-cpp, but when using that
// form of the checker, we do not want to diagnose movable parameters.
if (!UseCERTSemantics) {
Finder->addMatcher(
cxxConstructorDecl(
allOf(
unless(isMoveConstructor()),
hasAnyConstructorInitializer(withInitializer(cxxConstructExpr(
hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
hasArgument(
0,
declRefExpr(
to(parmVarDecl(
hasType(
NonConstValueMovableAndExpensiveToCopy))
.bind("movable-param")))
.bind("init-arg")))))))
.bind("ctor-decl"),
this);
}
}
void UseToStringCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
Finder->addMatcher(
callExpr(
hasDeclaration(functionDecl(
returns(hasDeclaration(classTemplateSpecializationDecl(
hasName("std::basic_string"),
hasTemplateArgument(0,
templateArgument().bind("char_type"))))),
hasName("boost::lexical_cast"),
hasParameter(0, hasType(qualType(has(substTemplateTypeParmType(
isStrictlyInteger()))))))),
argumentCountIs(1), unless(isInTemplateInstantiation()))
.bind("to_string"),
this);
}
void InefficientStringConcatenationCheck::registerMatchers(
MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
const auto BasicStringType =
hasType(qualType(hasUnqualifiedDesugaredType(recordType(
hasDeclaration(cxxRecordDecl(hasName("::std::basic_string")))))));
const auto BasicStringPlusOperator = cxxOperatorCallExpr(
hasOverloadedOperatorName("+"),
hasAnyArgument(ignoringImpCasts(declRefExpr(BasicStringType))));
const auto PlusOperator =
cxxOperatorCallExpr(
hasOverloadedOperatorName("+"),
hasAnyArgument(ignoringImpCasts(declRefExpr(BasicStringType))),
hasDescendant(BasicStringPlusOperator))
.bind("plusOperator");
const auto AssignOperator = cxxOperatorCallExpr(
hasOverloadedOperatorName("="),
hasArgument(0, declRefExpr(BasicStringType,
hasDeclaration(decl().bind("lhsStrT")))
.bind("lhsStr")),
hasArgument(1, stmt(hasDescendant(declRefExpr(
hasDeclaration(decl(equalsBoundNode("lhsStrT"))))))),
hasDescendant(BasicStringPlusOperator));
if (StrictMode) {
Finder->addMatcher(cxxOperatorCallExpr(anyOf(AssignOperator, PlusOperator)),
this);
} else {
Finder->addMatcher(
cxxOperatorCallExpr(anyOf(AssignOperator, PlusOperator),
hasAncestor(stmt(anyOf(cxxForRangeStmt(),
whileStmt(), forStmt())))),
this);
}
}
void ContainerSizeEmptyCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus)
return;
const auto ValidContainer = cxxRecordDecl(isSameOrDerivedFrom(
namedDecl(
has(cxxMethodDecl(
isConst(), parameterCountIs(0), isPublic(), hasName("size"),
returns(qualType(isInteger(), unless(booleanType()))))
.bind("size")),
has(cxxMethodDecl(isConst(), parameterCountIs(0), isPublic(),
hasName("empty"), returns(booleanType()))
.bind("empty")))
.bind("container")));
const auto WrongUse = anyOf(
hasParent(binaryOperator(
matchers::isComparisonOperator(),
hasEitherOperand(ignoringImpCasts(anyOf(
integerLiteral(equals(1)), integerLiteral(equals(0))))))
.bind("SizeBinaryOp")),
hasParent(implicitCastExpr(
hasImplicitDestinationType(booleanType()),
anyOf(
hasParent(unaryOperator(hasOperatorName("!")).bind("NegOnSize")),
anything()))),
hasParent(explicitCastExpr(hasDestinationType(booleanType()))));
Finder->addMatcher(
cxxMemberCallExpr(on(expr(anyOf(hasType(ValidContainer),
hasType(pointsTo(ValidContainer)),
hasType(references(ValidContainer))))
.bind("STLObject")),
callee(cxxMethodDecl(hasName("size"))), WrongUse)
.bind("SizeCallExpr"),
this);
}
/// \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
TypeLocMatcher makeAutoPtrTypeLocMatcher() {
// Skip elaboratedType() as the named type will match soon thereafter.
return typeLoc(loc(qualType(AutoPtrType, unless(elaboratedType()))))
.bind(AutoPtrTokenId);
}
namespace modernize {
static const char AutoPtrTokenId[] = "AutoPrTokenId";
static const char AutoPtrOwnershipTransferId[] = "AutoPtrOwnershipTransferId";
/// \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; }
/// Matches declarations whose declaration context is the C++ standard library
/// namespace 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;
/// \code
///
/// 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"));
}
/// \brief Matcher that finds auto_ptr declarations.
static DeclarationMatcher AutoPtrDecl =
recordDecl(hasName("auto_ptr"), isFromStdNamespace());
/// \brief Matches types declared as auto_ptr.
static TypeMatcher AutoPtrType = qualType(hasDeclaration(AutoPtrDecl));
/// \brief 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);
/// \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
TypeLocMatcher makeAutoPtrTypeLocMatcher() {
// Skip elaboratedType() as the named type will match soon thereafter.
return typeLoc(loc(qualType(AutoPtrType, unless(elaboratedType()))))
.bind(AutoPtrTokenId);
}
/// \brief Creates a matcher that finds the using declarations referring to
/// \c std::auto_ptr.
///
/// \code
/// using std::auto_ptr;
/// ^~~~~~~~~~~~~~~~~~~
/// \endcode
DeclarationMatcher makeAutoPtrUsingDeclMatcher() {
return usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(
allOf(hasName("auto_ptr"), isFromStdNamespace()))))
.bind(AutoPtrTokenId);
}
/// \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
StatementMatcher makeTransferOwnershipExprMatcher() {
return anyOf(
cxxOperatorCallExpr(allOf(hasOverloadedOperatorName("="),
callee(cxxMethodDecl(ofClass(AutoPtrDecl))),
hasArgument(1, MovableArgumentMatcher))),
cxxConstructExpr(allOf(hasType(AutoPtrType), argumentCountIs(1),
hasArgument(0, MovableArgumentMatcher))));
}
/// \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.
static SourceLocation locateFromTypeLoc(const TypeLoc *AutoPtrTypeLoc,
const SourceManager &SM) {
auto TL = AutoPtrTypeLoc->getAs<TemplateSpecializationTypeLoc>();
if (TL.isNull())
return SourceLocation();
return TL.getTemplateNameLoc();
}
/// \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.
static SourceLocation locateFromUsingDecl(const UsingDecl *UsingAutoPtrDecl,
const SourceManager &SM) {
return UsingAutoPtrDecl->getNameInfo().getBeginLoc();
}
/// \brief Verifies that the token at \p TokenStart is 'auto_ptr'.
static bool checkTokenIsAutoPtr(SourceLocation TokenStart,
const SourceManager &SM,
const LangOptions &LO) {
SmallVector<char, 8> Buffer;
bool Invalid = false;
StringRef Res = Lexer::getSpelling(TokenStart, Buffer, SM, LO, &Invalid);
return (!Invalid && Res == "auto_ptr");
}
ReplaceAutoPtrCheck::ReplaceAutoPtrCheck(StringRef Name,
ClangTidyContext *Context)
: ClangTidyCheck(Name, Context),
IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
Options.get("IncludeStyle", "llvm"))) {}
void ReplaceAutoPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IncludeStyle",
utils::IncludeSorter::toString(IncludeStyle));
}
void ReplaceAutoPtrCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (getLangOpts().CPlusPlus) {
Finder->addMatcher(makeAutoPtrTypeLocMatcher(), this);
Finder->addMatcher(makeAutoPtrUsingDeclMatcher(), this);
Finder->addMatcher(makeTransferOwnershipExprMatcher(), this);
}
}
void ReplaceAutoPtrCheck::registerPPCallbacks(CompilerInstance &Compiler) {
// Only register the preprocessor callbacks for C++; the functionality
// currently does not provide any benefit to other languages, despite being
// benign.
if (getLangOpts().CPlusPlus) {
Inserter.reset(new utils::IncludeInserter(
Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle));
Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
}
}
void ReplaceAutoPtrCheck::check(const MatchFinder::MatchResult &Result) {
SourceManager &SM = *Result.SourceManager;
if (const auto *E =
Result.Nodes.getNodeAs<Expr>(AutoPtrOwnershipTransferId)) {
CharSourceRange Range = Lexer::makeFileCharRange(
CharSourceRange::getTokenRange(E->getSourceRange()), SM, LangOptions());
if (Range.isInvalid())
return;
auto Diag = diag(Range.getBegin(), "use std::move to transfer ownership")
<< FixItHint::CreateInsertion(Range.getBegin(), "std::move(")
<< FixItHint::CreateInsertion(Range.getEnd(), ")");
auto Insertion =
Inserter->CreateIncludeInsertion(SM.getMainFileID(), "utility",
/*IsAngled=*/true);
if (Insertion.hasValue())
Diag << Insertion.getValue();
return;
}
SourceLocation IdentifierLoc;
if (const auto *TL = Result.Nodes.getNodeAs<TypeLoc>(AutoPtrTokenId)) {
IdentifierLoc = locateFromTypeLoc(TL, SM);
} else if (const auto *D =
Result.Nodes.getNodeAs<UsingDecl>(AutoPtrTokenId)) {
IdentifierLoc = locateFromUsingDecl(D, SM);
} else {
llvm_unreachable("Bad Callback. No node provided.");
}
if (IdentifierLoc.isMacroID())
IdentifierLoc = SM.getSpellingLoc(IdentifierLoc);
// Ensure that only the 'auto_ptr' token is replaced and not the template
// aliases.
if (!checkTokenIsAutoPtr(IdentifierLoc, SM, LangOptions()))
return;
SourceLocation EndLoc =
IdentifierLoc.getLocWithOffset(strlen("auto_ptr") - 1);
diag(IdentifierLoc, "auto_ptr is deprecated, use unique_ptr instead")
<< FixItHint::CreateReplacement(SourceRange(IdentifierLoc, EndLoc),
"unique_ptr");
}
} // namespace modernize
void CanRunScriptChecker::registerMatchers(MatchFinder *AstMatcher) {
auto Refcounted = qualType(hasDeclaration(cxxRecordDecl(isRefCounted())));
auto InvalidArg =
// We want to find any expression,
ignoreTrivials(expr(
// which has a refcounted pointer type,
anyOf(
hasType(Refcounted),
hasType(pointsTo(Refcounted)),
hasType(references(Refcounted))
),
// and which is not this,
unless(cxxThisExpr()),
// and which is not a method call on a smart ptr,
unless(cxxMemberCallExpr(on(hasType(isSmartPtrToRefCounted())))),
// and which is not calling operator* on a smart ptr.
unless(
allOf(
cxxOperatorCallExpr(hasOverloadedOperatorName("*")),
callExpr(allOf(
hasAnyArgument(hasType(isSmartPtrToRefCounted())),
argumentCountIs(1)
))
)
),
// and which is not a parameter of the parent function,
unless(declRefExpr(to(parmVarDecl()))),
// and which is not a MOZ_KnownLive wrapped value.
unless(callExpr(callee(functionDecl(hasName("MOZ_KnownLive"))))),
expr().bind("invalidArg")));
auto OptionalInvalidExplicitArg = anyOf(
// We want to find any argument which is invalid.
hasAnyArgument(InvalidArg),
// This makes this matcher optional.
anything());
// Please note that the hasCanRunScriptAnnotation() matchers are not present
// directly in the cxxMemberCallExpr, callExpr and constructExpr matchers
// because we check that the corresponding functions can run script later in
// the checker code.
AstMatcher->addMatcher(
expr(
anyOf(
// We want to match a method call expression,
cxxMemberCallExpr(
// which optionally has an invalid arg,
OptionalInvalidExplicitArg,
// or which optionally has an invalid implicit this argument,
anyOf(
// which derefs into an invalid arg,
on(cxxOperatorCallExpr(
anyOf(hasAnyArgument(InvalidArg), anything()))),
// or is an invalid arg.
on(InvalidArg),
anything()),
expr().bind("callExpr")),
// or a regular call expression,
callExpr(
// which optionally has an invalid arg.
OptionalInvalidExplicitArg, expr().bind("callExpr")),
// or a construct expression,
cxxConstructExpr(
// which optionally has an invalid arg.
OptionalInvalidExplicitArg, expr().bind("constructExpr"))),
anyOf(
// We want to match the parent function.
forFunction(functionDecl().bind("nonCanRunScriptParentFunction")),
// ... optionally.
anything())),
this);
}
void VarSymbol::codegenDefC(bool global, bool isHeader) {
GenInfo* info = gGenInfo;
if (this->hasFlag(FLAG_EXTERN))
return;
if (type == dtVoid)
return;
AggregateType* ct = toAggregateType(type);
QualifiedType qt = qualType();
if (qt.isRef() && !qt.isRefType()) {
Type* refType = getOrMakeRefTypeDuringCodegen(type);
ct = toAggregateType(refType);
}
if (qt.isWideRef() && !qt.isWideRefType()) {
Type* refType = getOrMakeRefTypeDuringCodegen(type);
Type* wideType = getOrMakeWideTypeDuringCodegen(refType);
ct = toAggregateType(wideType);
}
Type* useType = type;
if (ct) useType = ct;
std::string typestr = (this->hasFlag(FLAG_SUPER_CLASS) ?
std::string(toAggregateType(useType)->classStructName(true)) :
useType->codegen().c);
//
// a variable can be codegen'd as static if it is global and neither
// exported nor external.
//
std::string str;
if(fIncrementalCompilation) {
bool addExtern = global && isHeader;
str = (addExtern ? "extern " : "") + typestr + " " + cname;
} else {
bool isStatic = global && !hasFlag(FLAG_EXPORT) && !hasFlag(FLAG_EXTERN);
str = (isStatic ? "static " : "") + typestr + " " + cname;
}
if (ct) {
if (ct->isClass()) {
if (isFnSymbol(defPoint->parentSymbol)) {
str += " = NULL";
}
} else if (ct->symbol->hasFlag(FLAG_WIDE_REF) ||
ct->symbol->hasFlag(FLAG_WIDE_CLASS)) {
if (isFnSymbol(defPoint->parentSymbol)) {
if (widePointersStruct) {
//
// CHPL_LOCALEID_T_INIT is #defined in the chpl-locale-model.h
// file in the runtime, for the selected locale model.
//
str += " = {CHPL_LOCALEID_T_INIT, NULL}";
} else {
str += " = ((wide_ptr_t) NULL)";
}
}
}
}
if (fGenIDS)
str = idCommentTemp(this) + str;
if (printCppLineno && !isHeader && !isTypeSymbol(defPoint->parentSymbol))
str = zlineToString(this) + str;
info->cLocalDecls.push_back(str);
}
GenRet VarSymbol::codegenVarSymbol(bool lhsInSetReference) {
GenInfo* info = gGenInfo;
FILE* outfile = info->cfile;
GenRet ret;
ret.chplType = typeInfo();
if( outfile ) {
// dtString immediates don't actually codegen as immediates, we just use
// them for param string functionality.
if (immediate && ret.chplType != dtString) {
ret.isLVPtr = GEN_VAL;
if (immediate->const_kind == CONST_KIND_STRING) {
ret.c += '"';
ret.c += immediate->v_string;
ret.c += '"';
} else if (immediate->const_kind == NUM_KIND_BOOL) {
std::string bstring = (immediate->bool_value())?"true":"false";
const char* castString = "(";
switch (immediate->num_index) {
case BOOL_SIZE_1:
case BOOL_SIZE_SYS:
case BOOL_SIZE_8:
castString = "UINT8(";
break;
case BOOL_SIZE_16:
castString = "UINT16(";
break;
case BOOL_SIZE_32:
castString = "UINT32(";
break;
case BOOL_SIZE_64:
castString = "UINT64(";
break;
default:
INT_FATAL("Unexpected immediate->num_index: %d\n", immediate->num_index);
}
ret.c = castString + bstring + ")";
} else if (immediate->const_kind == NUM_KIND_INT) {
int64_t iconst = immediate->int_value();
if (iconst == (1ll<<63)) {
ret.c = "-INT64(9223372036854775807) - INT64(1)";
} else if (iconst <= -2147483648ll || iconst >= 2147483647ll) {
ret.c = "INT64(" + int64_to_string(iconst) + ")";
} else {
const char* castString = "(";
switch (immediate->num_index) {
case INT_SIZE_8:
castString = "INT8(";
break;
case INT_SIZE_16:
castString = "INT16(";
break;
case INT_SIZE_32:
castString = "INT32(";
break;
case INT_SIZE_64:
castString = "INT64(";
break;
default:
INT_FATAL("Unexpected immediate->num_index: %d\n", immediate->num_index);
}
ret.c = castString + int64_to_string(iconst) + ")";
}
} else if (immediate->const_kind == NUM_KIND_UINT) {
uint64_t uconst = immediate->uint_value();
if( uconst <= (uint64_t) INT32_MAX ) {
const char* castString = "(";
switch (immediate->num_index) {
case INT_SIZE_8:
castString = "UINT8(";
break;
case INT_SIZE_16:
castString = "UINT16(";
break;
case INT_SIZE_32:
castString = "UINT32(";
break;
case INT_SIZE_64:
castString = "UINT64(";
break;
default:
INT_FATAL("Unexpected immediate->num_index: %d\n", immediate->num_index);
}
ret.c = castString + uint64_to_string(uconst) + ")";
} else {
ret.c = "UINT64(" + uint64_to_string(uconst) + ")";
}
} else {
ret.c = cname; // in C, all floating point literals are (double)
}
} else {
// not immediate
// is it a constant extern? If it is, it might be for example
// an enum or #define'd value, in which case taking the address
// of it is simply nonsense. Therefore, we code generate
// extern const symbols as GEN_VAL (ie not an lvalue).
if( hasFlag(FLAG_CONST) && hasFlag(FLAG_EXTERN) ) {
ret.isLVPtr = GEN_VAL;
ret.c = cname;
} else {
QualifiedType qt = qualType();
if (lhsInSetReference) {
ret.c = '&';
ret.c += cname;
ret.isLVPtr = GEN_PTR;
if (qt.isRef() && !qt.isRefType())
ret.chplType = getOrMakeRefTypeDuringCodegen(typeInfo());
else if (qt.isWideRef() && !qt.isWideRefType()) {
Type* refType = getOrMakeRefTypeDuringCodegen(typeInfo());
ret.chplType = getOrMakeWideTypeDuringCodegen(refType);
}
} else {
if (qt.isRef() && !qt.isRefType()) {
ret.c = cname;
ret.isLVPtr = GEN_PTR;
} else if(qt.isWideRef() && !qt.isWideRefType()) {
ret.c = cname;
ret.isLVPtr = GEN_WIDE_PTR;
} else {
ret.c = '&';
ret.c += cname;
ret.isLVPtr = GEN_PTR;
}
}
}
// Print string contents in a comment if developer mode
// and savec is set.
if (developer &&
0 != strcmp(saveCDir, "") &&
immediate &&
ret.chplType == dtString &&
immediate->const_kind == CONST_KIND_STRING) {
if (strstr(immediate->v_string, "/*") ||
strstr(immediate->v_string, "*/")) {
// Don't emit comment b/c string contained comment character.
} else {
ret.c += " /* \"";
ret.c += immediate->v_string;
ret.c += "\" */";
}
}
}
return ret;
} else {
#ifdef HAVE_LLVM
// for LLVM
// Handle extern type variables.
if( hasFlag(FLAG_EXTERN) && isType() ) {
// code generate the type.
GenRet got = typeInfo();
return got;
}
// for nil, generate a void pointer of chplType dtNil
// to allow LLVM pointer cast
// e.g. T = ( (locale) (nil) );
//
// We would just compare against dtNil, but in some cases
// the code generator needs to assign e.g.
// _ret:dtNil = nil
if( typeInfo() == dtNil && 0 == strcmp(cname, "nil") ) {
GenRet voidPtr;
voidPtr.val = llvm::Constant::getNullValue(info->builder->getInt8PtrTy());
voidPtr.chplType = dtNil;
return voidPtr;
}
if (typeInfo() == dtBool){
// since "true" and "false" are read into the LVT during ReadMacrosAction
// they will generate an LLVM value of type i32 instead of i8
if (0 == strcmp(cname, "false")){
GenRet boolVal = new_UIntSymbol(0, INT_SIZE_8)->codegen();
return boolVal;
}
if (0 == strcmp(cname, "true")){
GenRet boolVal = new_UIntSymbol(1, INT_SIZE_8)->codegen();
return boolVal;
}
}
if(!isImmediate()) {
// check LVT for value
GenRet got = info->lvt->getValue(cname);
got.chplType = typeInfo();
if( got.val ) {
return got;
}
}
if(isImmediate()) {
ret.isLVPtr = GEN_VAL;
if(immediate->const_kind == CONST_KIND_STRING) {
if(llvm::Value *value = info->module->getNamedGlobal(name)) {
ret.val = value;
ret.isLVPtr = GEN_PTR;
return ret;
}
llvm::Value *constString = codegenImmediateLLVM(immediate);
llvm::GlobalVariable *globalValue =
llvm::cast<llvm::GlobalVariable>(
info->module->getOrInsertGlobal
(name, info->builder->getInt8PtrTy()));
globalValue->setConstant(true);
globalValue->setInitializer(llvm::cast<llvm::Constant>(
info->builder->CreateConstInBoundsGEP2_32(
#if HAVE_LLVM_VER >= 37
NULL,
#endif
constString, 0, 0)));
ret.val = globalValue;
ret.isLVPtr = GEN_PTR;
} else {
ret.val = codegenImmediateLLVM(immediate);
}
return ret;
}
if(std::string(cname) == "0") {
// Chapel compiler should not make these.
INT_FATAL(" zero value BOO ");
return ret;
} else if (std::string(cname) == "NULL") {
GenRet voidPtr;
voidPtr.val = llvm::Constant::getNullValue(info->builder->getInt8PtrTy());
voidPtr.chplType = typeInfo();
return voidPtr;
}
#endif
}
INT_FATAL("Could not code generate %s - "
"perhaps it is a complex macro?", cname);
return ret;
}
static TypeMatcher nonConstValueType() {
return qualType(unless(anyOf(referenceType(), isConstQualified())));
}