This is an archive of the discontinued LLVM Phabricator instance.

Differential D47459

[ASTImporter] Eliminated some unittest warnings.
ClosedPublic

Authored by balazske on May 29 2018, 1:59 AM.

Details

Reviewers
a.sidorin
Commits
rG1f6ad1466161: [ASTImporter] Eliminated some unittest warnings.
rC335959: [ASTImporter] Eliminated some unittest warnings.
rL335959: [ASTImporter] Eliminated some unittest warnings.
Summary

When running the ASTTests test, warnings produced by the compiler can be
distracting when looking for test errors. A part of the warnings is removed
by setting extra compiler options.

Diff Detail

Repository
rL LLVM

Event Timeline

balazske created this revision.May 29 2018, 1:59 AM
Harbormaster completed remote builds in B18668: Diff 148857.May 29 2018, 1:59 AM
Herald added a reviewer: a.sidorin. · View Herald TranscriptMay 29 2018, 1:59 AM
Herald added a reviewer: a.sidorin. · View Herald Transcript
Herald added subscribers: cfe-commits, martong. · View Herald Transcript
a.sidorin requested changes to this revision.May 29 2018, 3:00 AM

Hello Balázs!

Thank you for addressing this problem, it is really cool. However, it will be much better if we don't suppress warnings but fix them. Could you modify the tests instead?

This revision now requires changes to proceed.May 29 2018, 3:00 AM
balazske added a comment.May 29 2018, 5:26 AM

Original idea was to not modify the test code to keep it as simple as possible. If you like it better I will change the test code.

balazske updated this revision to Diff 149079.May 30 2018, 3:44 AM

[ASTImporter] Fixed test code in ASTImporter tests.

Test code is fixed instead of turn off the warnings.
For this to work change of match expressions was needed.

Harbormaster completed remote builds in B18726: Diff 149079.May 30 2018, 3:44 AM
martong added a reviewer: balazske.May 30 2018, 5:13 AM
martong removed a reviewer: balazske.
a_sidorin added a subscriber: a_sidorin.Jun 24 2018, 3:42 PM

Hello Balázs,

The patch is mostly LG now, thank you!

unittests/AST/ASTImporterTest.cpp
495 ↗(On Diff #149079)

Redundant space after cast.

541 ↗(On Diff #149079)

Commented code should be removed.

802 ↗(On Diff #149079)

Sometimes we turn to usehasDescendant(), sometimes we add a cast matcher. Can we make it consistent?

balazske updated this revision to Diff 152632.Jun 25 2018, 1:15 AM

[ASTImporter] Fixed test code in ASTImporter tests.

Reformatted some test code, changed to use isDescendant.

Harbormaster completed remote builds in B19655: Diff 152632.Jun 25 2018, 1:15 AM
balazske marked 2 inline comments as done.Jun 25 2018, 1:17 AM

Some of the source code was reformatted for more consistency. At least a part of the code is now better formatted.

a.sidorin accepted this revision.Jun 26 2018, 2:56 AM

Thank you!

When committing, please change the commit message (the current review description is out-of-date) and mention the reformatting done.

This revision is now accepted and ready to land.Jun 26 2018, 2:56 AM
balazske updated this revision to Diff 153015.Jun 27 2018, 1:15 AM

Rebase to newest master.

Harbormaster completed remote builds in B19750: Diff 153015.Jun 27 2018, 1:15 AM
Closed by commit rL335959: [ASTImporter] Eliminated some unittest warnings. (authored by martong). · Explain WhyJun 29 2018, 3:30 AM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptJun 29 2018, 3:30 AM

Revision Contents

PathSize
cfe/
trunk/
unittests/
AST/
741 lines

Diff 153462

cfe/trunk/unittests/AST/ASTImporterTest.cpp

Show First 20 Lines • Show All 466 Lines • ▼ Show 20 LinesTEST_P(CanonicalRedeclChain, ShouldBeSameForAllDeclInTheChain) {
EXPECT_THAT(RedeclsD0, ::testing::ContainerEq(RedeclsD1)); EXPECT_THAT(RedeclsD0, ::testing::ContainerEq(RedeclsD1));
EXPECT_THAT(RedeclsD1, ::testing::ContainerEq(RedeclsD2)); EXPECT_THAT(RedeclsD1, ::testing::ContainerEq(RedeclsD2));
} }
TEST_P(ImportExpr, ImportStringLiteral) { TEST_P(ImportExpr, ImportStringLiteral) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport() { \"foo\"; }", testImport(
"void declToImport() { (void)\"foo\"; }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody( stringLiteral(hasType(asString("const char [4]"))))));
compoundStmt( testImport(
has( "void declToImport() { (void)L\"foo\"; }",
stringLiteral(
hasType(
asString("const char [4]"))))))));
testImport("void declToImport() { L\"foo\"; }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody( stringLiteral(hasType(asString("const wchar_t [4]"))))));
compoundStmt( testImport(
has( "void declToImport() { (void) \"foo\" \"bar\"; }",
stringLiteral(
hasType(
asString("const wchar_t [4]"))))))));
testImport("void declToImport() { \"foo\" \"bar\"; }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody( stringLiteral(hasType(asString("const char [7]"))))));
compoundStmt(
has(
stringLiteral(
hasType(
asString("const char [7]"))))))));
} }
TEST_P(ImportExpr, ImportGNUNullExpr) { TEST_P(ImportExpr, ImportGNUNullExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport() { __null; }", testImport(
"void declToImport() { (void)__null; }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl( functionDecl(hasDescendant(gnuNullExpr(hasType(isInteger())))));
hasBody(
compoundStmt(
has(
gnuNullExpr(
hasType(isInteger())))))));
} }
TEST_P(ImportExpr, ImportCXXNullPtrLiteralExpr) { TEST_P(ImportExpr, ImportCXXNullPtrLiteralExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport() { nullptr; }", testImport(
"void declToImport() { (void)nullptr; }",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
functionDecl( functionDecl(hasDescendant(cxxNullPtrLiteralExpr())));
hasBody(
compoundStmt(
has(
cxxNullPtrLiteralExpr())))));
} }
TEST_P(ImportExpr, ImportFloatinglLiteralExpr) { TEST_P(ImportExpr, ImportFloatinglLiteralExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport() { 1.0; }", testImport(
"void declToImport() { (void)1.0; }",
Lang_C, "", Lang_C, Verifier, Lang_C, "", Lang_C, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody( floatLiteral(equals(1.0), hasType(asString("double"))))));
compoundStmt( testImport(
has( "void declToImport() { (void)1.0e-5f; }",
floatLiteral(
equals(1.0),
hasType(asString("double"))))))));
testImport("void declToImport() { 1.0e-5f; }",
Lang_C, "", Lang_C, Verifier, Lang_C, "", Lang_C, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody( floatLiteral(equals(1.0e-5f), hasType(asString("float"))))));
compoundStmt(
has(
floatLiteral(
equals(1.0e-5f),
hasType(asString("float"))))))));
} }
TEST_P(ImportExpr, ImportCompoundLiteralExpr) { TEST_P(ImportExpr, ImportCompoundLiteralExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport() {" testImport(
"void declToImport() {"
" struct s { int x; long y; unsigned z; }; " " struct s { int x; long y; unsigned z; }; "
" (struct s){ 42, 0L, 1U }; }", " (void)(struct s){ 42, 0L, 1U }; }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody(
compoundStmt(
has(
compoundLiteralExpr( compoundLiteralExpr(
hasType(asString("struct s")), hasType(asString("struct s")),
has(initListExpr( has(initListExpr(
hasType(asString("struct s")), hasType(asString("struct s")),
has(integerLiteral( has(integerLiteral(
equals(42), hasType(asString("int")))), equals(42), hasType(asString("int")))),
has(integerLiteral( has(integerLiteral(
equals(0), hasType(asString("long")))), equals(0), hasType(asString("long")))),
has(integerLiteral( has(integerLiteral(
equals(1), equals(1), hasType(asString("unsigned int"))))))))));
hasType(asString("unsigned int"))))
))))))));
} }
TEST_P(ImportExpr, ImportCXXThisExpr) { TEST_P(ImportExpr, ImportCXXThisExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("class declToImport { void f() { this; } };", testImport(
"class declToImport { void f() { (void)this; } };",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
cxxRecordDecl( cxxRecordDecl(
hasMethod( hasMethod(
hasBody( hasDescendant(
compoundStmt(
has(
cxxThisExpr( cxxThisExpr(
hasType( hasType(
asString("class declToImport *"))))))))); asString("class declToImport *")))))));
} }
TEST_P(ImportExpr, ImportAtomicExpr) { TEST_P(ImportExpr, ImportAtomicExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }", testImport(
"void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }",
Lang_C, "", Lang_C, Verifier, Lang_C, "", Lang_C, Verifier,
functionDecl(hasBody(compoundStmt(has(atomicExpr( functionDecl(hasDescendant(
atomicExpr(
has(ignoringParenImpCasts( has(ignoringParenImpCasts(
declRefExpr(hasDeclaration(varDecl(hasName("ptr"))), declRefExpr(hasDeclaration(varDecl(hasName("ptr"))),
hasType(asString("int *"))))), hasType(asString("int *"))))),
has(integerLiteral(equals(1), hasType(asString("int")))))))))); has(integerLiteral(equals(1), hasType(asString("int"))))))));
} }
TEST_P(ImportExpr, ImportLabelDeclAndAddrLabelExpr) { TEST_P(ImportExpr, ImportLabelDeclAndAddrLabelExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"void declToImport() { loop: goto loop; &&loop; }", Lang_C, "", Lang_C, "void declToImport() { loop: goto loop; (void)&&loop; }",
Verifier, Lang_C, "", Lang_C, Verifier,
functionDecl(hasBody(compoundStmt( functionDecl(
has(labelStmt(hasDeclaration(labelDecl(hasName("loop"))))), hasDescendant(
has(addrLabelExpr(hasDeclaration(labelDecl(hasName("loop"))))))))); labelStmt(hasDeclaration(labelDecl(hasName("loop"))))),
hasDescendant(
addrLabelExpr(hasDeclaration(labelDecl(hasName("loop")))))));
} }
AST_MATCHER_P(TemplateDecl, hasTemplateDecl, AST_MATCHER_P(TemplateDecl, hasTemplateDecl,
internal::Matcher<NamedDecl>, InnerMatcher) { internal::Matcher<NamedDecl>, InnerMatcher) {
const NamedDecl *Template = Node.getTemplatedDecl(); const NamedDecl *Template = Node.getTemplatedDecl();
return Template && InnerMatcher.matches(*Template, Finder, Builder); return Template && InnerMatcher.matches(*Template, Finder, Builder);
} }
Show All 11 Lines testImport(
hasBody(compoundStmt(has(declStmt(hasSingleDecl( hasBody(compoundStmt(has(declStmt(hasSingleDecl(
varDecl(hasInitializer(parenListExpr(has(unaryOperator( varDecl(hasInitializer(parenListExpr(has(unaryOperator(
hasOperatorName("*"), hasOperatorName("*"),
hasUnaryOperand(cxxThisExpr()))))))))))))))))))))))); hasUnaryOperand(cxxThisExpr())))))))))))))))))))))));
} }
TEST_P(ImportExpr, ImportSwitch) { TEST_P(ImportExpr, ImportSwitch) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport() { int b; switch (b) { case 1: break; } }", testImport(
"void declToImport() { int b; switch (b) { case 1: break; } }",
Lang_C, "", Lang_C, Verifier, Lang_C, "", Lang_C, Verifier,
functionDecl(hasBody(compoundStmt( functionDecl(hasDescendant(
has(switchStmt(has(compoundStmt(has(caseStmt()))))))))); switchStmt(has(compoundStmt(has(caseStmt())))))));
} }
TEST_P(ImportExpr, ImportStmtExpr) { TEST_P(ImportExpr, ImportStmtExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
// NOTE: has() ignores implicit casts, using hasDescendant() to match it // NOTE: has() ignores implicit casts, using hasDescendant() to match it
testImport( testImport(
"void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }", "void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }",
Lang_C, "", Lang_C, Verifier, Lang_C, "", Lang_C, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody(
compoundStmt(
has(
declStmt(
hasSingleDecl(
varDecl( varDecl(
hasName("C"), hasName("C"),
hasType(asString("int")), hasType(asString("int")),
hasInitializer( hasInitializer(
stmtExpr( stmtExpr(
hasAnySubstatement( hasAnySubstatement(declStmt(hasSingleDecl(
declStmt(
hasSingleDecl(
varDecl( varDecl(
hasName("X"), hasName("X"),
hasType(asString("int")), hasType(asString("int")),
hasInitializer( hasInitializer(
integerLiteral(equals(4))))))), integerLiteral(equals(4))))))),
hasDescendant( hasDescendant(
implicitCastExpr() implicitCastExpr())))))));
)))))))))));
} }
TEST_P(ImportExpr, ImportConditionalOperator) { TEST_P(ImportExpr, ImportConditionalOperator) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"void declToImport() { true ? 1 : -5; }", "void declToImport() { (void)(true ? 1 : -5); }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody(
compoundStmt(
has(
conditionalOperator( conditionalOperator(
hasCondition(cxxBoolLiteral(equals(true))), hasCondition(cxxBoolLiteral(equals(true))),
hasTrueExpression(integerLiteral(equals(1))), hasTrueExpression(integerLiteral(equals(1))),
hasFalseExpression( hasFalseExpression(
unaryOperator(hasUnaryOperand(integerLiteral(equals(5)))) unaryOperator(hasUnaryOperand(integerLiteral(equals(5))))))
))))))); )));
} }
TEST_P(ImportExpr, ImportBinaryConditionalOperator) { TEST_P(ImportExpr, ImportBinaryConditionalOperator) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"void declToImport() { 1 ?: -5; }", Lang_CXX, "", Lang_CXX, Verifier, "void declToImport() { (void)(1 ?: -5); }",
functionDecl( Lang_CXX, "", Lang_CXX, Verifier,
hasBody( functionDecl(hasDescendant(
compoundStmt(
has(
binaryConditionalOperator( binaryConditionalOperator(
hasCondition( hasCondition(
implicitCastExpr( implicitCastExpr(
hasSourceExpression( hasSourceExpression(opaqueValueExpr(
opaqueValueExpr(
hasSourceExpression(integerLiteral(equals(1))))), hasSourceExpression(integerLiteral(equals(1))))),
hasType(booleanType()))), hasType(booleanType()))),
hasTrueExpression( hasTrueExpression(
opaqueValueExpr(hasSourceExpression( opaqueValueExpr(
integerLiteral(equals(1))))), hasSourceExpression(integerLiteral(equals(1))))),
hasFalseExpression( hasFalseExpression(
unaryOperator(hasOperatorName("-"), unaryOperator(
hasUnaryOperand(integerLiteral(equals(5))))) hasOperatorName("-"),
)))))); hasUnaryOperand(integerLiteral(equals(5)))))))));
} }
TEST_P(ImportExpr, ImportDesignatedInitExpr) { TEST_P(ImportExpr, ImportDesignatedInitExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport() {" testImport(
"void declToImport() {"
" struct point { double x; double y; };" " struct point { double x; double y; };"
" struct point ptarray[10] = " " struct point ptarray[10] = "
"{ [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }", "{ [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }",
Lang_C, "", Lang_C, Verifier, Lang_C, "", Lang_C, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody(
compoundStmt(
has(
declStmt(
hasSingleDecl(
varDecl(
hasInitializer(
initListExpr( initListExpr(
hasSyntacticForm( has(designatedInitExpr(
initListExpr(
has(
designatedInitExpr(
designatorCountIs(2), designatorCountIs(2),
has(floatLiteral( has(floatLiteral(equals(1.0))),
equals(1.0))), has(integerLiteral(equals(2))))),
has(integerLiteral( has(designatedInitExpr(
equals(2))))),
has(
designatedInitExpr(
designatorCountIs(2), designatorCountIs(2),
has(floatLiteral( has(floatLiteral(equals(2.0))),
equals(2.0))), has(integerLiteral(equals(2))))),
has(integerLiteral( has(designatedInitExpr(
equals(2))))),
has(
designatedInitExpr(
designatorCountIs(2), designatorCountIs(2),
has(floatLiteral( has(floatLiteral(equals(1.0))),
equals(1.0))), has(integerLiteral(equals(0)))))))));
has(integerLiteral(
equals(0)))))
))))))))))));
} }
TEST_P(ImportExpr, ImportPredefinedExpr) { TEST_P(ImportExpr, ImportPredefinedExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
// __func__ expands as StringLiteral("declToImport") // __func__ expands as StringLiteral("declToImport")
testImport("void declToImport() { __func__; }", testImport(
"void declToImport() { (void)__func__; }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody(
compoundStmt(
has(
predefinedExpr( predefinedExpr(
hasType( hasType(
asString("const char [13]")), asString("const char [13]")),
has( has(stringLiteral(hasType(
stringLiteral( asString("const char [13]"))))))));
hasType(
asString("const char [13]"))))))))));
} }
TEST_P(ImportExpr, ImportInitListExpr) { TEST_P(ImportExpr, ImportInitListExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"void declToImport() {" "void declToImport() {"
" struct point { double x; double y; };" " struct point { double x; double y; };"
" point ptarray[10] = { [2].y = 1.0, [2].x = 2.0," " point ptarray[10] = { [2].y = 1.0, [2].x = 2.0,"
" [0].x = 1.0 }; }", " [0].x = 1.0 }; }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody(
compoundStmt(
has(
declStmt(
hasSingleDecl(
varDecl(
hasInitializer(
initListExpr( initListExpr(
has( has(
cxxConstructExpr( cxxConstructExpr(
requiresZeroInitialization())), requiresZeroInitialization())),
has( has(
initListExpr( initListExpr(
hasType(asString("struct point")), hasType(asString("struct point")),
has(floatLiteral(equals(1.0))), has(floatLiteral(equals(1.0))),
has(implicitValueInitExpr( has(implicitValueInitExpr(
hasType(asString("double")))))), hasType(asString("double")))))),
has( has(
initListExpr( initListExpr(
hasType(asString("struct point")), hasType(asString("struct point")),
has(floatLiteral(equals(2.0))), has(floatLiteral(equals(2.0))),
has(floatLiteral(equals(1.0))))) has(floatLiteral(equals(1.0)))))))));
))))))))));
} }
const internal::VariadicDynCastAllOfMatcher<Expr, VAArgExpr> vaArgExpr; const internal::VariadicDynCastAllOfMatcher<Expr, VAArgExpr> vaArgExpr;
TEST_P(ImportExpr, ImportVAArgExpr) { TEST_P(ImportExpr, ImportVAArgExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport(__builtin_va_list list, ...) {" testImport(
"void declToImport(__builtin_va_list list, ...) {"
" (void)__builtin_va_arg(list, int); }", " (void)__builtin_va_arg(list, int); }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody( cStyleCastExpr(hasSourceExpression(vaArgExpr())))));
compoundStmt(
has(
cStyleCastExpr(
hasSourceExpression(
vaArgExpr())))))));
} }
TEST_P(ImportExpr, CXXTemporaryObjectExpr) { TEST_P(ImportExpr, CXXTemporaryObjectExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("struct C {};" testImport(
"struct C {};"
"void declToImport() { C c = C(); }", "void declToImport() { C c = C(); }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl(hasBody(compoundStmt(has( functionDecl(hasDescendant(
declStmt(has(varDecl(has(exprWithCleanups(has(cxxConstructExpr( exprWithCleanups(has(cxxConstructExpr(
has(materializeTemporaryExpr(has(implicitCastExpr( has(materializeTemporaryExpr(has(implicitCastExpr(
has(cxxTemporaryObjectExpr()))))))))))))))))); has(cxxTemporaryObjectExpr())))))))))));
} }
TEST_P(ImportType, ImportAtomicType) { TEST_P(ImportType, ImportAtomicType) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport() { typedef _Atomic(int) a_int; }", testImport(
"void declToImport() { typedef _Atomic(int) a_int; }",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
functionDecl( functionDecl(hasDescendant(typedefDecl(has(atomicType())))));
hasBody(
compoundStmt(
has(
declStmt(
has(
typedefDecl(
has(atomicType())))))))));
} }
TEST_P(ImportDecl, ImportFunctionTemplateDecl) { TEST_P(ImportDecl, ImportFunctionTemplateDecl) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template <typename T> void declToImport() { };", Lang_CXX, "", testImport(
Lang_CXX, Verifier, functionTemplateDecl()); "template <typename T> void declToImport() { };",
Lang_CXX, "", Lang_CXX, Verifier,
functionTemplateDecl());
} }
const internal::VariadicDynCastAllOfMatcher<Expr, CXXDependentScopeMemberExpr> const internal::VariadicDynCastAllOfMatcher<Expr, CXXDependentScopeMemberExpr>
cxxDependentScopeMemberExpr; cxxDependentScopeMemberExpr;
TEST_P(ImportExpr, ImportCXXDependentScopeMemberExpr) { TEST_P(ImportExpr, ImportCXXDependentScopeMemberExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template <typename T> struct C { T t; };" testImport(
"template <typename T> struct C { T t; };"
"template <typename T> void declToImport() {" "template <typename T> void declToImport() {"
" C<T> d;" " C<T> d;"
" d.t;" " (void)d.t;"
"}" "}"
"void instantiate() { declToImport<int>(); }", "void instantiate() { declToImport<int>(); }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionTemplateDecl(has(functionDecl( functionTemplateDecl(hasDescendant(
has(compoundStmt(has(cxxDependentScopeMemberExpr()))))))); cStyleCastExpr(has(cxxDependentScopeMemberExpr())))));
testImport("template <typename T> struct C { T t; };" testImport(
"template <typename T> struct C { T t; };"
"template <typename T> void declToImport() {" "template <typename T> void declToImport() {"
" C<T> d;" " C<T> d;"
" (&d)->t;" " (void)(&d)->t;"
"}" "}"
"void instantiate() { declToImport<int>(); }", "void instantiate() { declToImport<int>(); }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionTemplateDecl(has(functionDecl( functionTemplateDecl(hasDescendant(
has(compoundStmt(has(cxxDependentScopeMemberExpr()))))))); cStyleCastExpr(has(cxxDependentScopeMemberExpr())))));
} }
TEST_P(ImportType, ImportTypeAliasTemplate) { TEST_P(ImportType, ImportTypeAliasTemplate) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"template <int K>" "template <int K>"
"struct dummy { static const int i = K; };" "struct dummy { static const int i = K; };"
"template <int K> using dummy2 = dummy<K>;" "template <int K> using dummy2 = dummy<K>;"
"int declToImport() { return dummy2<3>::i; }", "int declToImport() { return dummy2<3>::i; }",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
functionDecl( functionDecl(
hasBody(compoundStmt( hasDescendant(implicitCastExpr(has(declRefExpr()))),
has(returnStmt(has(implicitCastExpr(has(declRefExpr()))))))),
unless(hasAncestor(translationUnitDecl(has(typeAliasDecl())))))); unless(hasAncestor(translationUnitDecl(has(typeAliasDecl()))))));
} }
const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateSpecializationDecl> const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateSpecializationDecl>
varTemplateSpecializationDecl; varTemplateSpecializationDecl;
TEST_P(ImportDecl, ImportVarTemplate) { TEST_P(ImportDecl, ImportVarTemplate) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"template <typename T>" "template <typename T>"
"T pi = T(3.1415926535897932385L);" "T pi = T(3.1415926535897932385L);"
"void declToImport() { pi<int>; }", "void declToImport() { (void)pi<int>; }",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX14, "", Lang_CXX14, Verifier,
functionDecl( functionDecl(
hasBody(has(declRefExpr(to(varTemplateSpecializationDecl())))), hasDescendant(declRefExpr(to(varTemplateSpecializationDecl()))),
unless(hasAncestor(translationUnitDecl(has(varDecl( unless(hasAncestor(translationUnitDecl(has(varDecl(
hasName("pi"), unless(varTemplateSpecializationDecl())))))))); hasName("pi"), unless(varTemplateSpecializationDecl()))))))));
} }
TEST_P(ImportType, ImportPackExpansion) { TEST_P(ImportType, ImportPackExpansion) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template <typename... Args>" testImport(
"template <typename... Args>"
"struct dummy {" "struct dummy {"
" dummy(Args... args) {}" " dummy(Args... args) {}"
" static const int i = 4;" " static const int i = 4;"
"};" "};"
"int declToImport() { return dummy<int>::i; }", "int declToImport() { return dummy<int>::i; }",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
functionDecl( functionDecl(hasDescendant(
hasBody( returnStmt(has(implicitCastExpr(has(declRefExpr())))))));
compoundStmt(
has(
returnStmt(
has(
implicitCastExpr(
has(
declRefExpr())))))))));
} }
const internal::VariadicDynCastAllOfMatcher<Type, const internal::VariadicDynCastAllOfMatcher<Type,
DependentTemplateSpecializationType> DependentTemplateSpecializationType>
dependentTemplateSpecializationType; dependentTemplateSpecializationType;
TEST_P(ImportType, ImportDependentTemplateSpecialization) { TEST_P(ImportType, ImportDependentTemplateSpecialization) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template<typename T>" testImport(
"template<typename T>"
"struct A;" "struct A;"
"template<typename T>" "template<typename T>"
"struct declToImport {" "struct declToImport {"
" typename A<T>::template B<T> a;" " typename A<T>::template B<T> a;"
"};", "};",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
classTemplateDecl(has(cxxRecordDecl(has( classTemplateDecl(has(cxxRecordDecl(has(
fieldDecl(hasType(dependentTemplateSpecializationType()))))))); fieldDecl(hasType(dependentTemplateSpecializationType())))))));
} }
const internal::VariadicDynCastAllOfMatcher<Stmt, SizeOfPackExpr> const internal::VariadicDynCastAllOfMatcher<Stmt, SizeOfPackExpr>
sizeOfPackExpr; sizeOfPackExpr;
TEST_P(ImportExpr, ImportSizeOfPackExpr) { TEST_P(ImportExpr, ImportSizeOfPackExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template <typename... Ts>" testImport(
"template <typename... Ts>"
"void declToImport() {" "void declToImport() {"
" const int i = sizeof...(Ts);" " const int i = sizeof...(Ts);"
"};" "};"
"void g() { declToImport<int>(); }", "void g() { declToImport<int>(); }",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
functionTemplateDecl(has(functionDecl( functionTemplateDecl(hasDescendant(sizeOfPackExpr())));
hasBody(compoundStmt(has(declStmt(has(varDecl(hasInitializer(
implicitCastExpr(has(sizeOfPackExpr())))))))))))));
testImport( testImport(
"template <typename... Ts>" "template <typename... Ts>"
"using X = int[sizeof...(Ts)];" "using X = int[sizeof...(Ts)];"
"template <typename... Us>" "template <typename... Us>"
"struct Y {" "struct Y {"
" X<Us..., int, double, int, Us...> f;" " X<Us..., int, double, int, Us...> f;"
"};" "};"
"Y<float, int> declToImport;", "Y<float, int> declToImport;",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
varDecl(hasType(classTemplateSpecializationDecl(has(fieldDecl(hasType( varDecl(hasType(classTemplateSpecializationDecl(has(fieldDecl(hasType(
hasUnqualifiedDesugaredType(constantArrayType(hasSize(7)))))))))); hasUnqualifiedDesugaredType(constantArrayType(hasSize(7))))))))));
} }
/// \brief Matches __builtin_types_compatible_p: /// \brief Matches __builtin_types_compatible_p:
/// GNU extension to check equivalent types /// GNU extension to check equivalent types
/// Given /// Given
/// \code /// \code
/// __builtin_types_compatible_p(int, int) /// __builtin_types_compatible_p(int, int)
/// \endcode /// \endcode
// will generate TypeTraitExpr <...> 'int' // will generate TypeTraitExpr <...> 'int'
const internal::VariadicDynCastAllOfMatcher<Stmt, TypeTraitExpr> typeTraitExpr; const internal::VariadicDynCastAllOfMatcher<Stmt, TypeTraitExpr> typeTraitExpr;
TEST_P(ImportExpr, ImportTypeTraitExpr) { TEST_P(ImportExpr, ImportTypeTraitExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("void declToImport() { " testImport(
" __builtin_types_compatible_p(int, int);" "void declToImport() { "
" (void)__builtin_types_compatible_p(int, int);"
"}", "}",
Lang_C, "", Lang_C, Verifier, Lang_C, "", Lang_C, Verifier,
functionDecl( functionDecl(hasDescendant(typeTraitExpr(hasType(asString("int"))))));
hasBody(
compoundStmt(
has(
typeTraitExpr(hasType(asString("int"))))))));
} }
const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTypeidExpr> cxxTypeidExpr; const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTypeidExpr> cxxTypeidExpr;
TEST_P(ImportExpr, ImportCXXTypeidExpr) { TEST_P(ImportExpr, ImportCXXTypeidExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"namespace std { class type_info {}; }" "namespace std { class type_info {}; }"
"void declToImport() {" "void declToImport() {"
" int x;" " int x;"
" auto a = typeid(int); auto b = typeid(x);" " auto a = typeid(int); auto b = typeid(x);"
"}", "}",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
functionDecl( functionDecl(
hasDescendant(varDecl( hasDescendant(varDecl(
hasName("a"), hasInitializer(hasDescendant(cxxTypeidExpr())))), hasName("a"), hasInitializer(hasDescendant(cxxTypeidExpr())))),
hasDescendant(varDecl( hasDescendant(varDecl(
hasName("b"), hasInitializer(hasDescendant(cxxTypeidExpr())))))); hasName("b"), hasInitializer(hasDescendant(cxxTypeidExpr()))))));
} }
TEST_P(ImportExpr, ImportTypeTraitExprValDep) { TEST_P(ImportExpr, ImportTypeTraitExprValDep) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template<typename T> struct declToImport {" testImport(
" void m() { __is_pod(T); }" "template<typename T> struct declToImport {"
" void m() { (void)__is_pod(T); }"
"};" "};"
"void f() { declToImport<int>().m(); }", "void f() { declToImport<int>().m(); }",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
classTemplateDecl( classTemplateDecl(has(cxxRecordDecl(has(
has( functionDecl(hasDescendant(
cxxRecordDecl( typeTraitExpr(hasType(booleanType())))))))));
has(
functionDecl(
hasBody(
compoundStmt(
has(
typeTraitExpr(
hasType(booleanType())
))))))))));
} }
const internal::VariadicDynCastAllOfMatcher<Expr, CXXPseudoDestructorExpr> const internal::VariadicDynCastAllOfMatcher<Expr, CXXPseudoDestructorExpr>
cxxPseudoDestructorExpr; cxxPseudoDestructorExpr;
TEST_P(ImportExpr, ImportCXXPseudoDestructorExpr) { TEST_P(ImportExpr, ImportCXXPseudoDestructorExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("typedef int T;" testImport(
"typedef int T;"
"void declToImport(int *p) {" "void declToImport(int *p) {"
" T t;" " T t;"
" p->T::~T();" " p->T::~T();"
"}", "}",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl(has(compoundStmt(has( functionDecl(hasDescendant(
callExpr(has(cxxPseudoDestructorExpr()))))))); callExpr(has(cxxPseudoDestructorExpr())))));
} }
TEST_P(ImportDecl, ImportUsingDecl) { TEST_P(ImportDecl, ImportUsingDecl) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("namespace foo { int bar; }" testImport(
"namespace foo { int bar; }"
"void declToImport() { using foo::bar; }", "void declToImport() { using foo::bar; }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionDecl( functionDecl(hasDescendant(usingDecl())));
has(
compoundStmt(
has(
declStmt(
has(
usingDecl())))))));
} }
/// \brief Matches shadow declarations introduced into a scope by a /// \brief Matches shadow declarations introduced into a scope by a
/// (resolved) using declaration. /// (resolved) using declaration.
/// ///
/// Given /// Given
/// \code /// \code
/// namespace n { int f; } /// namespace n { int f; }
/// namespace declToImport { using n::f; } /// namespace declToImport { using n::f; }
/// \endcode /// \endcode
/// usingShadowDecl() /// usingShadowDecl()
/// matches \code f \endcode /// matches \code f \endcode
const internal::VariadicDynCastAllOfMatcher<Decl, const internal::VariadicDynCastAllOfMatcher<Decl,
UsingShadowDecl> usingShadowDecl; UsingShadowDecl> usingShadowDecl;
TEST_P(ImportDecl, ImportUsingShadowDecl) { TEST_P(ImportDecl, ImportUsingShadowDecl) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("namespace foo { int bar; }" testImport(
"namespace foo { int bar; }"
"namespace declToImport { using foo::bar; }", "namespace declToImport { using foo::bar; }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
namespaceDecl(has(usingShadowDecl()))); namespaceDecl(has(usingShadowDecl())));
} }
TEST_P(ImportExpr, ImportUnresolvedLookupExpr) { TEST_P(ImportExpr, ImportUnresolvedLookupExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template<typename T> int foo();" testImport(
"template<typename T> int foo();"
"template <typename T> void declToImport() {" "template <typename T> void declToImport() {"
" ::foo<T>;" " (void)::foo<T>;"
" ::template foo<T>;" " (void)::template foo<T>;"
"}" "}"
"void instantiate() { declToImport<int>(); }", "void instantiate() { declToImport<int>(); }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionTemplateDecl(has(functionDecl( functionTemplateDecl(hasDescendant(unresolvedLookupExpr())));
has(compoundStmt(has(unresolvedLookupExpr())))))));
} }
TEST_P(ImportExpr, ImportCXXUnresolvedConstructExpr) { TEST_P(ImportExpr, ImportCXXUnresolvedConstructExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template <typename T> struct C { T t; };" testImport(
"template <typename T> struct C { T t; };"
"template <typename T> void declToImport() {" "template <typename T> void declToImport() {"
" C<T> d;" " C<T> d;"
" d.t = T();" " d.t = T();"
"}" "}"
"void instantiate() { declToImport<int>(); }", "void instantiate() { declToImport<int>(); }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionTemplateDecl(has(functionDecl(has(compoundStmt(has( functionTemplateDecl(hasDescendant(
binaryOperator(has(cxxUnresolvedConstructExpr()))))))))); binaryOperator(has(cxxUnresolvedConstructExpr())))));
testImport("template <typename T> struct C { T t; };" testImport(
"template <typename T> struct C { T t; };"
"template <typename T> void declToImport() {" "template <typename T> void declToImport() {"
" C<T> d;" " C<T> d;"
" (&d)->t = T();" " (&d)->t = T();"
"}" "}"
"void instantiate() { declToImport<int>(); }", "void instantiate() { declToImport<int>(); }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionTemplateDecl(has(functionDecl(has(compoundStmt(has( functionTemplateDecl(hasDescendant(
binaryOperator(has(cxxUnresolvedConstructExpr()))))))))); binaryOperator(has(cxxUnresolvedConstructExpr())))));
} }
/// Check that function "declToImport()" (which is the templated function /// Check that function "declToImport()" (which is the templated function
/// for corresponding FunctionTemplateDecl) is not added into DeclContext. /// for corresponding FunctionTemplateDecl) is not added into DeclContext.
/// Same for class template declarations. /// Same for class template declarations.
TEST_P(ImportDecl, ImportTemplatedDeclForTemplate) { TEST_P(ImportDecl, ImportTemplatedDeclForTemplate) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template <typename T> void declToImport() { T a = 1; }" testImport(
"template <typename T> void declToImport() { T a = 1; }"
"void instantiate() { declToImport<int>(); }", "void instantiate() { declToImport<int>(); }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
functionTemplateDecl(hasAncestor(translationUnitDecl( functionTemplateDecl(hasAncestor(translationUnitDecl(
unless(has(functionDecl(hasName("declToImport")))))))); unless(has(functionDecl(hasName("declToImport"))))))));
testImport("template <typename T> struct declToImport { T t; };" testImport(
"template <typename T> struct declToImport { T t; };"
"void instantiate() { declToImport<int>(); }", "void instantiate() { declToImport<int>(); }",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
classTemplateDecl(hasAncestor(translationUnitDecl( classTemplateDecl(hasAncestor(translationUnitDecl(
unless(has(cxxRecordDecl(hasName("declToImport")))))))); unless(has(cxxRecordDecl(hasName("declToImport"))))))));
} }
TEST_P(ImportDecl, ImportClassTemplatePartialSpecialization) { TEST_P(ImportDecl, ImportClassTemplatePartialSpecialization) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
auto Code = auto Code =
R"s( R"s(
struct declToImport { struct declToImport {
template <typename T0> struct X; template <typename T0> struct X;
template <typename T0> struct X<T0 *> {}; template <typename T0> struct X<T0 *> {};
}; };
)s"; )s";
testImport(Code, Lang_CXX, "", Lang_CXX, Verifier, testImport(Code, Lang_CXX, "", Lang_CXX, Verifier,
recordDecl(has(classTemplateDecl()), recordDecl(has(classTemplateDecl()),
has(classTemplateSpecializationDecl()))); has(classTemplateSpecializationDecl())));
} }
TEST_P(ImportExpr, CXXOperatorCallExpr) { TEST_P(ImportExpr, CXXOperatorCallExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("class declToImport {" testImport(
"class declToImport {"
" void f() { *this = declToImport(); }" " void f() { *this = declToImport(); }"
"};", "};",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
cxxRecordDecl(has(cxxMethodDecl(hasBody(compoundStmt( cxxRecordDecl(has(cxxMethodDecl(hasDescendant(
has(exprWithCleanups(has(cxxOperatorCallExpr()))))))))); cxxOperatorCallExpr())))));
} }
TEST_P(ImportExpr, DependentSizedArrayType) { TEST_P(ImportExpr, DependentSizedArrayType) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template<typename T, int Size> class declToImport {" testImport(
"template<typename T, int Size> class declToImport {"
" T data[Size];" " T data[Size];"
"};", "};",
Lang_CXX, "", Lang_CXX, Verifier, Lang_CXX, "", Lang_CXX, Verifier,
classTemplateDecl(has(cxxRecordDecl( classTemplateDecl(has(cxxRecordDecl(
has(fieldDecl(hasType(dependentSizedArrayType()))))))); has(fieldDecl(hasType(dependentSizedArrayType())))))));
} }
TEST_P(ASTImporterTestBase, ImportOfTemplatedDeclOfClassTemplateDecl) { TEST_P(ASTImporterTestBase, ImportOfTemplatedDeclOfClassTemplateDecl) {
Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX); Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX);
auto From = auto From =
FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, classTemplateDecl()); FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, classTemplateDecl());
ASSERT_TRUE(From); ASSERT_TRUE(From);
auto To = cast<ClassTemplateDecl>(Import(From, Lang_CXX)); auto To = cast<ClassTemplateDecl>(Import(From, Lang_CXX));
▲ Show 20 Lines • Show All 1,017 Lines • ▼ Show 20 Linesconst internal::VariadicDynCastAllOfMatcher<Expr, DependentScopeDeclRefExpr>
dependentScopeDeclRefExpr; dependentScopeDeclRefExpr;
TEST_P(ImportExpr, DependentScopeDeclRefExpr) { TEST_P(ImportExpr, DependentScopeDeclRefExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template <typename T> struct S { static T foo; };" testImport("template <typename T> struct S { static T foo; };"
"template <typename T> void declToImport() {" "template <typename T> void declToImport() {"
" (void) S<T>::foo;" " (void) S<T>::foo;"
"}" "}"
"void instantiate() { declToImport<int>(); }", "void instantiate() { declToImport<int>(); }"
"template <typename T> T S<T>::foo;",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
functionTemplateDecl(has(functionDecl(has(compoundStmt( functionTemplateDecl(has(functionDecl(has(compoundStmt(
has(cStyleCastExpr(has(dependentScopeDeclRefExpr()))))))))); has(cStyleCastExpr(has(dependentScopeDeclRefExpr())))))))));
testImport("template <typename T> struct S {" testImport("template <typename T> struct S {"
"template<typename S> static void foo(){};" "template<typename S> static void foo(){};"
"};" "};"
"template <typename T> void declToImport() {" "template <typename T> void declToImport() {"
▲ Show 20 Lines • Show All 418 Lines • Show Last 20 Lines