This is an archive of the discontinued LLVM Phabricator instance.

Differential D39658

[clang-diff] Treat QualType / TypeLoc as a node
Needs ReviewPublic

Authored by johannes on Nov 5 2017, 11:44 AM.

Details

Reviewers
arphaman

Diff Detail

Event Timeline

johannes created this revision.Nov 5 2017, 11:44 AM
Harbormaster completed remote builds in B11853: Diff 121651.Nov 5 2017, 11:44 AM
Herald added a subscriber: klimek. · View Herald TranscriptNov 5 2017, 11:44 AM

Revision Contents

Diff 121651

lib/Tooling/ASTDiff/ASTDiff.cpp

Show First 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
static bool isSpecializedNodeExcluded(const Decl *D) { return D->isImplicit(); } static bool isSpecializedNodeExcluded(const Decl *D) { return D->isImplicit(); }
static bool isSpecializedNodeExcluded(const Stmt *S) { return false; } static bool isSpecializedNodeExcluded(const Stmt *S) { return false; }
static bool isSpecializedNodeExcluded(CXXCtorInitializer *I) { static bool isSpecializedNodeExcluded(CXXCtorInitializer *I) {
return !I->isWritten(); return !I->isWritten();
} }
static bool isSpecializedNodeExcluded(const TemplateArgumentLoc *S) { static bool isSpecializedNodeExcluded(const TemplateArgumentLoc *S) {
return false; return false;
} }
static bool isNodeExcluded(ASTUnit &AST, QualType QT) { return false; }
static bool isNodeExcluded(ASTUnit &AST, TemplateName *Template) { static bool isNodeExcluded(ASTUnit &AST, TemplateName *Template) {
return false; return false;
} }
template <class T> static bool isNodeExcluded(ASTUnit &AST, T *N) { template <class T> static bool isNodeExcluded(ASTUnit &AST, T *N) {
const SourceManager &SM = AST.getSourceManager(); const SourceManager &SM = AST.getSourceManager();
if (!N) if (!N)
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines if (S)
S = S->IgnoreImplicit(); S = S->IgnoreImplicit();
if (isNodeExcluded(Tree.AST, S)) if (isNodeExcluded(Tree.AST, S))
return true; return true;
auto SavedState = PreTraverse(*S); auto SavedState = PreTraverse(*S);
BaseType::TraverseStmt(S); BaseType::TraverseStmt(S);
PostTraverse(SavedState); PostTraverse(SavedState);
return true; return true;
} }
bool TraverseType(QualType T) { return true; } bool TraverseTypeLoc(TypeLoc TL) {
auto SavedState = PreTraverse(TL);
BaseType::TraverseTypeLoc(TL);
PostTraverse(SavedState);
return true;
}
bool TraverseType(QualType QT) {
if (isNodeExcluded(Tree.AST, QT))
return true;
auto SavedState = PreTraverse(QT);
BaseType::TraverseType(QT);
PostTraverse(SavedState);
return true;
}
bool TraverseConstructorInitializer(CXXCtorInitializer *Init) { bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
if (isNodeExcluded(Tree.AST, Init)) if (isNodeExcluded(Tree.AST, Init))
return true; return true;
auto SavedState = PreTraverse(*Init); auto SavedState = PreTraverse(*Init);
BaseType::TraverseConstructorInitializer(Init); BaseType::TraverseConstructorInitializer(Init);
PostTraverse(SavedState); PostTraverse(SavedState);
return true; return true;
} }
▲ Show 20 Lines • Show All 916 Lines • Show Last 20 Lines

test/Tooling/clang-diff-ast.cpp

// RUN: clang-diff -ast-dump %s -- -std=c++11 | FileCheck %s // RUN: clang-diff -ast-dump %s -- -std=c++11 | FileCheck %s
// CHECK: {{^}}TranslationUnitDecl(0) // CHECK: {{^}}TranslationUnitDecl(0)
// CHECK: {{^}} NamespaceDecl(1) // CHECK: {{^}} NamespaceDecl(1)
namespace test { namespace test {
// CHECK: {{^}} FunctionDecl(2) // CHECK: {{^}} FunctionDecl(2)
// CHECK: CompoundStmt(3)
void f() { void f() {
// CHECK: DeclStmt(4) // CHECK: CompoundStmt(5)
// CHECK: VarDecl(5) // CHECK: DeclStmt(6)
// CHECK: IntegerLiteral(6) // CHECK-NEXT: VarDecl
// CHECK-NEXT: TypeLoc
// CHECK-NEXT: QualType
// CHECK-NEXT: IntegerLiteral
auto i = 1; auto i = 1;
// CHECK: FloatingLiteral(9) // CHECK: FloatingLiteral(15)
auto r = 1.5; auto r = 1.5;
// CHECK: CXXBoolLiteralExpr(12) // CHECK: TypeLoc(18)
auto b = true; // CHECK-NEXT: CXXBoolLiteralExpr
// CHECK: CallExpr(13) bool b = true;
// CHECK: CallExpr(20)
// CHECK-NOT: ImplicitCastExpr // CHECK-NOT: ImplicitCastExpr
// CHECK: DeclRefExpr(14) // CHECK-NEXT: DeclRefExpr
f(); f();
// CHECK: UnaryOperator(15) // CHECK: UnaryOperator(22)
++i; ++i;
// CHECK: BinaryOperator(17) // CHECK: BinaryOperator(24)
i = i; i = i;
} }
} // end namespace test } // end namespace test
// CHECK: UsingDirectiveDecl(20) // CHECK: UsingDirectiveDecl(27)
using namespace test; using namespace test;
// CHECK: TypedefDecl(21) // CHECK: TypedefDecl(28)
typedef unsigned nat; typedef unsigned nat;
// CHECK: TypeAliasDecl(22) // CHECK: TypeAliasDecl(30)
using real = double; using real = double;
class Base { class Base {
}; };
// CHECK: CXXRecordDecl(23) // CHECK: CXXRecordDecl(33)
class X : Base { class X : Base {
int m; int m;
// CHECK: CXXMethodDecl(26) // CHECK: CXXMethodDecl(37)
// CHECK: ParmVarDecl(27) // CHECK: ParmVarDecl(41)
const char *foo(int i) { const char *foo(int i) {
if (i == 0) if (i == 0)
// CHECK: StringLiteral(34) // CHECK: StringLiteral(49)
return "foo"; return "foo";
// CHECK-NOT: ImplicitCastExpr // CHECK-NOT: ImplicitCastExpr
return 0; return 0;
} }
// CHECK: AccessSpecDecl(37) // CHECK: AccessSpecDecl(52)
public: public:
int not_initialized; int not_initialized;
// CHECK: CXXConstructorDecl(39) // CHECK: CXXConstructorDecl(55)
// CHECK-NEXT: ParmVarDecl(40) // CHECK-NEXT: TypeLoc
// CHECK-NEXT: ParmVarDecl(41) // CHECK-NEXT: TypeLoc
// CHECK-NEXT: CXXCtorInitializer(42) // CHECK-NEXT: ParmVarDecl
// CHECK-NEXT: CXXConstructExpr(43) // CHECK-NEXT: TypeLoc
// CHECK-NEXT: CXXCtorInitializer(44) // CHECK-NEXT: ParmVarDecl
// CHECK-NEXT: IntegerLiteral(45) // CHECK-NEXT: TypeLoc
// CHECK-NEXT: CXXCtorInitializer
// CHECK-NEXT: TypeLoc
// CHECK-NEXT: CXXConstructExpr
// CHECK-NEXT: CXXCtorInitializer
// CHECK-NEXT: IntegerLiteral
X(char s, int) : Base(), m(0) { X(char s, int) : Base(), m(0) {
// CHECK-NEXT: CompoundStmt(46) // CHECK-NEXT: CompoundStmt(67)
// CHECK: MemberExpr(49) // CHECK: MemberExpr(71)
int x = m; int x = m;
} }
// CHECK: CXXConstructorDecl(51) // CHECK: CXXConstructorDecl(73)
// CHECK: CXXCtorInitializer(53) // CHECK: CXXCtorInitializer(78)
X(char s) : X(s, 4) {} X(char s) : X(s, 4) {}
}; };
#define M (void)1 #define M (void)1
#define F(a, b) (void)a, b #define F(a, b) (void)a, b
void macros() { void macros() {
// CHECK: Macro(60) // CHECK: Macro(90)
M; M;
// two expressions, therefore it occurs twice // two expressions, therefore it occurs twice
// CHECK-NEXT: Macro(61) // CHECK-NEXT: Macro(91)
// CHECK-NEXT: Macro(62) // CHECK-NEXT: Macro(92)
F(1, 2); F(1, 2);
} }
#ifndef GUARD #ifndef GUARD
#define GUARD #define GUARD
// CHECK-NEXT: NamespaceDecl(63) // CHECK-NEXT: NamespaceDecl(93)
namespace world { namespace world {
// nodes from other files are excluded, there should be no output here // nodes from other files are excluded, there should be no output here
#include "clang-diff-ast.cpp" #include "clang-diff-ast.cpp"
} }
// CHECK-NEXT: FunctionDecl(64) // CHECK-NEXT: FunctionDecl(94)
void sentinel(); void sentinel();
#endif #endif
// CHECK-NEXT: ClassTemplateDecl(65) // CHECK: ClassTemplateDecl(97)
// CHECK-NEXT: TemplateTypeParmDecl(66) // CHECK-NEXT: TemplateTypeParmDecl
// CHECK-NEXT: CXXRecordDecl(67) // CHECK-NEXT: QualType
// CHECK-NEXT: CXXRecordDecl
template <class T> class C { template <class T> class C {
// CHECK-NEXT: FieldDecl(68) // CHECK-NEXT: FieldDecl
// CHECK-NEXT: TypeLoc
T t; T t;
}; };
// CHECK-NEXT: CXXRecordDecl(69) // CHECK-NEXT: CXXRecordDecl
// CHECK-NEXT: TemplateName(70) // CHECK-NEXT: TypeLoc
// CHECK-NEXT: TemplateArgument(71) // CHECK-NEXT: TemplateName
// CHECK-NEXT: TemplateArgument
class I : C<int> {}; class I : C<int> {};

test/Tooling/clang-diff-basic.cpp

// RUN: clang-diff -dump-matches %S/Inputs/clang-diff-basic-src.cpp %s -- -std=c++11 | FileCheck %s // RUN: clang-diff -dump-matches %S/Inputs/clang-diff-basic-src.cpp %s -s=200 -- -std=c++11 | FileCheck %s
// CHECK: Match TranslationUnitDecl(0) to TranslationUnitDecl(0) // CHECK: Match TranslationUnitDecl(0) to TranslationUnitDecl(0)
// CHECK: Match NamespaceDecl(1) to NamespaceDecl(1) // CHECK: Match NamespaceDecl(1) to NamespaceDecl(1)
namespace dst { namespace dst {
// CHECK-NOT: Match NamespaceDecl(1) to NamespaceDecl(2) // CHECK-NOT: Match NamespaceDecl(1) to NamespaceDecl(2)
namespace inner { namespace inner {
void foo() { void foo() {
// CHECK: Match IntegerLiteral(6) to IntegerLiteral(7) // CHECK: Match IntegerLiteral(9) to IntegerLiteral(10)
int x = 322; int x = 322;
} }
} }
// CHECK: Match DeclRefExpr(10) to DeclRefExpr(11) // CHECK: Match DeclRefExpr(15) to DeclRefExpr(16)
void main() { inner::foo(); } void main() { inner::foo(); }
// CHECK: Match StringLiteral(13) to StringLiteral(13) // CHECK: Match StringLiteral(20) to StringLiteral(20)
const char *b = "f" "o" "o"; const char *b = "f" "o" "o";
// unsigned is canonicalized to unsigned int // unsigned is canonicalized to unsigned int
// CHECK: Match TypedefDecl(14) to TypedefDecl(14) // CHECK: Match TypedefDecl
typedef unsigned nat; typedef unsigned nat;
// CHECK: Match VarDecl(15) // CHECK: Match VarDecl
// CHECK: Update VarDecl(15) // CHECK-NEXT: Update VarDecl
// CHECK: Match BinaryOperator(17) // CHECK-NEXT: Match TypeLoc
// CHECK-NEXT: Update TypeLoc
// CHECK-NEXT: Match BinaryOperator
double prod = 1 * 2 * 10; double prod = 1 * 2 * 10;
// CHECK: Update DeclRefExpr(25) // CHECK: Update DeclRefExpr
int squared = prod * prod; int squared = prod * prod;
class X { class X {
const char *foo(int i) { const char *foo(int i) {
// CHECK: Insert IfStmt(29) into CompoundStmt(28) // CHECK: Insert IfStmt(43) into CompoundStmt(42)
if (i == 0) if (i == 0)
return "Bar"; return "Bar";
// CHECK: Move IfStmt(35) into IfStmt // CHECK: Move IfStmt(49) into IfStmt
else if (i == -1) else if (i == -1)
return "foo"; return "foo";
return 0; return 0;
} }
X(){} X(){}
}; };
} }
// CHECK: Move CompoundStmt(48) into CompoundStmt(47) // CHECK: Move CompoundStmt(66) into CompoundStmt(65)
void m() { { int x = 0 + 0 + 0; } } void m() { { int x = 0 + 0 + 0; } }
// CHECK: Update and Move IntegerLiteral(59) into BinaryOperator(57) at 1 // CHECK: Update and Move IntegerLiteral(79) into BinaryOperator(77) at 1
int um = 1 + 7; int um = 1 + 7;
namespace { namespace {
// match with parents of different type // match with parents of different type
// CHECK: Match FunctionDecl(70) to FunctionDecl(69) // CHECK: Match FunctionDecl(85) to FunctionDecl(81)
void f1() {{ (void) __func__;;; }} void f1() {{ (void) __func__;;; }}
} }
// macros are always compared by their full textual value // macros are always compared by their full textual value
#define M1 return 1 + 1 #define M1 return 1 + 1
#define M2 return 2 * 2 #define M2 return 2 * 2
#define F(a, b) return a + b; #define F(a, b) return a + b;
int f2() { int f2() {
// CHECK: Match Macro(72) to Macro(71) // CHECK: Match Macro(100) to Macro(96)
M1; M1;
// CHECK: Update Macro(73) // CHECK: Update Macro(101)
M2; M2;
// CHECK: Match Macro(74) // CHECK: Match Macro(102)
F(1, /*b=*/1); F(1, /*b=*/1);
} }
// CHECK: Match TemplateTypeParmDecl(77) // CHECK: Match TemplateTypeParmDecl(105)
template <class Type, class U = int> template <class Type, class U = int>
U visit(Type &t) { U visit(Type &t) {
int x = t; int x = t;
return U(); return U();
} }
void tmp() { void tmp() {
long x; long x;
// CHECK: Match TemplateArgument(93) // CHECK: Match TemplateArgument(133)
// CHECK: Update TypeLoc
visit<long>(x); visit<long>(x);
} }
// CHECK: Delete AccessSpecDecl(39) // CHECK: Delete AccessSpecDecl
// CHECK: Delete CXXMethodDecl(42) // CHECK: Delete CXXMethodDecl

test/Tooling/clang-diff-bottomup.cpp

// RUN: %clang_cc1 -E %s > %t.src.cpp // RUN: %clang_cc1 -E %s > %t.src.cpp
// RUN: %clang_cc1 -E %s > %t.dst.cpp -DDEST // RUN: %clang_cc1 -E %s > %t.dst.cpp -DDEST
// RUN: clang-diff -dump-matches -s=0 -stop-diff-after=bottomup %t.src.cpp %t.dst.cpp -- | FileCheck %s // RUN: clang-diff -dump-matches -s=0 -stop-diff-after=bottomup %t.src.cpp %t.dst.cpp -- | FileCheck %s
// //
// Test the bottom-up matching, with maxsize set to 0, so that the optimal matching will never be applied. // Test the bottom-up matching, with maxsize set to 0, so that the optimal matching will never be applied.
#ifndef DEST #ifndef DEST
void f1() { ; {{;}} } void f1(int) { ; {{;}} }
void f2() { ;; {{;}} } void f2(int) { ;; {{;}} }
#else #else
// Jaccard similarity threshold is 0.5. // Jaccard similarity threshold is 0.5.
void f1() { void f1() {
// CompoundStmt: 3 matched descendants, subtree sizes 4 and 5 // CompoundStmt: 3 matched descendants, subtree sizes 4 and 5
// Jaccard similarity = 3 / (4 + 5 - 3) = 3 / 6 >= 0.5 // Jaccard similarity = 3 / (4 + 5 - 3) = 3 / 6 >= 0.5
// CHECK: Match FunctionDecl(1) to FunctionDecl(1) // CHECK: Match CompoundStmt(6) to CompoundStmt(4)
// CHECK: Match CompoundStmt(2) to CompoundStmt(2) // CHECK-NEXT: Move CompoundStmt
// CHECK: Match CompoundStmt(4) to CompoundStmt(3) // CHECK-NEXT: Match CompoundStmt
// CHECK: Match CompoundStmt(5) to CompoundStmt(4) // CHECK-NEXT: Match CompoundStmt
// CHECK: Match NullStmt(6) to NullStmt(5) // CHECK-NEXT: Match NullStmt
{{;}} ;; {{;}} ;;
} }
void f2() { void f2() {
// CompoundStmt: 3 matched descendants, subtree sizes 4 and 5 // CompoundStmt: 3 matched descendants, subtree sizes 4 and 5
// Jaccard similarity = 3 / (5 + 6 - 3) = 3 / 8 < 0.5 // Jaccard similarity = 3 / (5 + 6 - 3) = 3 / 8 < 0.5
// CHECK-NOT: Match FunctionDecl(9) // CHECK-NOT: Match CompoundStmt(16)
// CHECK-NOT: Match CompoundStmt(10) // CHECK: Match CompoundStmt(19) to CompoundStmt(14)
// CHECK: Match CompoundStmt(11) to CompoundStmt(10) // CHECK-NEXT: Move CompoundStmt
// CHECK: Match CompoundStmt(12) to CompoundStmt(11) // CHECK-NEXT: Match CompoundStmt
// CHECK: Match NullStmt(13) to NullStmt(12) // CHECK-NEXT: Match NullStmt
// CHECK-NOT: Match NullStmt(13) // CHECK-NOT: Match NullStmt({{.*}})
{{;}} ;;; {{;}} ;;;
} }
#endif #endif

test/Tooling/clang-diff-heuristics.cpp

Show All 14 Lines
#else #else
// same parents, same value // same parents, same value
// CHECK: Match FunctionDecl(1) to FunctionDecl(1) // CHECK: Match FunctionDecl(1) to FunctionDecl(1)
// CHECK: Match CompoundStmt // CHECK: Match CompoundStmt
void f1() {} void f1() {}
// same parents, same identifier // same parents, same identifier
// CHECK: Match FunctionDecl(4) to FunctionDecl(3) // CHECK: Match FunctionDecl(6) to FunctionDecl(5)
// CHECK: Match CompoundStmt // CHECK: Match CompoundStmt
void f2() {} void f2() {}
// same parents, same identifier // same parents, same identifier
// CHECK: Match CXXConstructorDecl(9) to CXXConstructorDecl(6) // CHECK: Match CXXConstructorDecl(14) to CXXConstructorDecl(10)
class C3 { C3(int); }; class C3 { C3(int); };
#endif #endif

test/Tooling/clang-diff-html.test

RUN: clang-diff -html %S/Inputs/clang-diff-basic-src.cpp %S/clang-diff-basic.cpp -- -std=c++11 | FileCheck %s RUN: clang-diff -html %S/Inputs/clang-diff-basic-src.cpp %S/clang-diff-basic.cpp -s=200 -- -std=c++11 | FileCheck %s
CHECK: <pre><div id='L' class='code'><span id='L0' tid='R0' title='TranslationUnitDecl CHECK: <pre><div id='L' class='code'><span id='L0' tid='R0' title='TranslationUnitDecl
CHECK-NEXT: 0 -> 0' class='u'> CHECK-NEXT: 0 -> 0' class='u'>
match, update match, update
CHECK: <span id='L[[L:[0-9]+]]' tid='R[[R:[0-9]+]]' title='NamespaceDecl CHECK: <span id='L[[L:[0-9]+]]' tid='R[[R:[0-9]+]]' title='NamespaceDecl
CHECK-NEXT: [[L]] -> [[R]]' class='u'>namespace src { CHECK-NEXT: [[L]] -> [[R]]' class='u'>namespace src {
match, move match, move
CHECK: <span id='L[[L:[0-9]+]]' tid='R[[R:[0-9]+]]' title='FunctionDecl CHECK: <span id='L[[L:[0-9]+]]' tid='R[[R:[0-9]+]]' title='FunctionDecl
CHECK-NEXT: [[L]] -> [[R]]' class='m'>void foo() CHECK-NEXT: [[L]] -> [[R]]' class='m'>{{.*}} title='TypeLoc
CHECK-NEXT: TypeLoc
CHECK-NEXT: void</span> foo()
match match
CHECK: <span id='L[[L:[0-9]+]]' tid='R[[R:[0-9]+]]' title='FunctionDecl CHECK: <span id='L[[L:[0-9]+]]' tid='R[[R:[0-9]+]]' title='FunctionDecl
CHECK-NEXT: [[L]] -> [[R]]'>void main() CHECK-NEXT: TypeLoc
CHECK-NEXT: TypeLoc
CHECK-NEXT: void</span> main()
deletion deletion
CHECK: <span id='L[[L:[0-9]+]]' tid='R-1' title='IntegerLiteral CHECK: <span id='L[[L:[0-9]+]]' tid='R-1' title='IntegerLiteral
CHECK-NEXT: [[L]] -> -1' class='d'>4</span> CHECK-NEXT: [[L]] -> -1' class='d'>4</span>
update + move update + move
CHECK: class='u m'>2</span> CHECK: class='u m'>2</span>
insertion insertion
CHECK: <span id='R[[R:[0-9]+]]' tid='L-1' title='StringLiteral CHECK: <span id='R[[R:[0-9]+]]' tid='L-1' title='StringLiteral
CHECK-NEXT: -1 -> [[R]]' class='i'>&quot;Bar&quot;</span> CHECK-NEXT: -1 -> [[R]]' class='i'>&quot;Bar&quot;</span>
comments comments
CHECK: // CHECK: Delete AccessSpecDecl CHECK: // CHECK: Delete AccessSpecDecl

test/Tooling/clang-diff-json.cpp

Show All 10 Lines
}; };
// CHECK: "children": [ // CHECK: "children": [
// CHECK-NEXT: { // CHECK-NEXT: {
// CHECK-NEXT: "begin": // CHECK-NEXT: "begin":
// CHECK-NEXT: "children": [] // CHECK-NEXT: "children": []
// CHECK-NEXT: "end": // CHECK-NEXT: "end":
// CHECK-NEXT: "id": // CHECK-NEXT: "id":
// CHECK-NEXT: "type": "CharacterLiteral" // CHECK-NEXT: "type": "TypeLoc"
// CHECK-NEXT: } // CHECK: }
// CHECK: ] // CHECK: ]
// CHECK: "type": "VarDecl" // CHECK: "type": "VarDecl"
char nl = '\n'; char nl = '\n';

test/Tooling/clang-diff-opt.cpp

Show All 14 Lines
void f3() { {;} {{;;;;;;}} } void f3() { {;} {{;;;;;;}} }
#else #else
void f1() { void f1() {
// Jaccard similarity = 3 / (5 + 4 - 3) = 3 / 6 >= 0.5 // Jaccard similarity = 3 / (5 + 4 - 3) = 3 / 6 >= 0.5
// The optimal matching algorithm should move the ; into the outer block // The optimal matching algorithm should move the ; into the outer block
// CHECK: Match CompoundStmt(2) to CompoundStmt(2) // CHECK: Match CompoundStmt(4) to CompoundStmt(4)
// CHECK-NOT: Match CompoundStmt(3) // CHECK-NOT: Match CompoundStmt(3)
// CHECK-NEXT: Match NullStmt(4) to NullStmt(3) // CHECK-NEXT: Match NullStmt(6) to NullStmt(5)
; {{;}} ; {{;}}
} }
void f2() { void f2() {
// Jaccard similarity = 7 / (10 + 10 - 7) >= 0.5 // Jaccard similarity = 7 / (10 + 10 - 7) >= 0.5
// As none of the subtrees is bigger than 10 nodes, the optimal algorithm // As none of the subtrees is bigger than 10 nodes, the optimal algorithm
// will be run. // will be run.
// CHECK: Match NullStmt(11) to NullStmt(9) // CHECK: Match NullStmt(15) to NullStmt(13)
;; {{;;;;;}} ;; {{;;;;;}}
} }
void f3() { void f3() {
// Jaccard similarity = 8 / (11 + 11 - 8) >= 0.5 // Jaccard similarity = 8 / (11 + 11 - 8) >= 0.5
// As the subtrees are bigger than 10 nodes, the optimal algorithm will not // As the subtrees are bigger than 10 nodes, the optimal algorithm will not
// be run. // be run.
// CHECK: Delete NullStmt(22) // CHECK: Delete NullStmt(28)
;; {{;;;;;;}} ;; {{;;;;;;}}
} }
#endif #endif

test/Tooling/clang-diff-topdown.cpp

// RUN: %clang_cc1 -E %s > %t.src.cpp // RUN: %clang_cc1 -E %s > %t.src.cpp
// RUN: %clang_cc1 -E %s > %t.dst.cpp -DDEST // RUN: %clang_cc1 -E %s > %t.dst.cpp -DDEST
// RUN: clang-diff -dump-matches -stop-diff-after=topdown %t.src.cpp %t.dst.cpp -- -std=c++11 | FileCheck %s // RUN: clang-diff -dump-matches -stop-diff-after=topdown %t.src.cpp %t.dst.cpp -- -std=c++11 | FileCheck %s
// //
// Test the top-down matching of identical subtrees only. // Test the top-down matching of identical subtrees only.
#ifndef DEST #ifndef DEST
void f1() void f1()
{ {
// Match some subtree of height greater than 2. // Match some subtree of height greater than 2.
// CHECK: Match CompoundStmt(3) to CompoundStmt(3) // CHECK: Match CompoundStmt(5) to CompoundStmt(5)
// CHECK: Match CompoundStmt(4) to CompoundStmt(4) // CHECK-NEXT: Move CompoundStmt
// CHECK: Match NullStmt(5) to NullStmt(5) // CHECK-NEXT: Match CompoundStmt
// CHECK-NEXT: Match NullStmt({{.*}}) to NullStmt({{.*}})
{{;}} {{;}}
// Don't match subtrees that are smaller. // Don't match subtrees that are smaller.
// CHECK-NOT: Match CompoundStmt(6) // CHECK-NOT: Match CompoundStmt(6)
// CHECK-NOT: Match NullStmt(7) // CHECK-NOT: Match NullStmt(7)
{;} {;}
// Greedy approach - use the first matching subtree when there are multiple // Greedy approach - use the first matching subtree when there are multiple
// identical subtrees. // identical subtrees.
// CHECK: Match CompoundStmt(8) to CompoundStmt(8) // CHECK: Match CompoundStmt(10) to CompoundStmt(10)
// CHECK: Match CompoundStmt(9) to CompoundStmt(9) // CHECK-NEXT: Move CompoundStmt
// CHECK: Match NullStmt(10) to NullStmt(10) // CHECK-NEXT: Match CompoundStmt({{.*}}) to CompoundStmt({{.*}})
// CHECK-NEXT: Match NullStmt({{.*}}) to NullStmt({{.*}})
{{;;}} {{;;}}
} }
int x; int x;
namespace src { namespace src {
int x; int x;
int x1 = x + 1; int x1 = x + 1;
int x2 = ::x + 1; int x2 = ::x + 1;
} }
#else #else
void f1() { void f1() {
{{;}} {{;}}
{;} {;}
{{;;}} {{;;}}
// CHECK-NOT: Match {{.*}} to CompoundStmt(11) // CHECK-NOT: Match {{.*}} to CompoundStmt(15)
// CHECK-NOT: Match {{.*}} to CompoundStmt(12) // CHECK-NOT: Match {{.*}} to CompoundStmt(16)
// CHECK-NOT: Match {{.*}} to NullStmt(13) // CHECK-NOT: Match {{.*}} to NullStmt(17)
{{;;}} {{;;}}
// CHECK-NOT: Match {{.*}} to NullStmt(14) // CHECK-NOT: Match {{.*}} to NullStmt(18)
; ;
} }
int x; int x;
namespace dst { namespace dst {
int x; int x;
// CHECK: Match DeclRefExpr(17) to DeclRefExpr(22) // CHECK: Match DeclRefExpr(22) to DeclRefExpr(27)
int x1 = x + 1; int x1 = x + 1;
// CHECK: Match DeclRefExpr(21) to DeclRefExpr(26) // CHECK: Match DeclRefExpr
int x2 = ::x + 1; int x2 = ::x + 1;
} }
#endif #endif