ASTMatcher


1   /*******************************************************************************
2    * Copyright (c) 2000, 2007 IBM Corporation and others.
3    * All rights reserved. This program and the accompanying materials
4    * are made available under the terms of the Eclipse Public License v1.0
5    * which accompanies this distribution, and is available at
6    * http://www.eclipse.org/legal/epl-v10.html
7    *
8    * Contributors:
9    *     IBM Corporation - initial API and implementation
10   *******************************************************************************/
11  package org.eclipse.jdt.core.dom;
12  
13  import java.util.Iterator  ;
14  import java.util.List  ;
15  
16  /**
17   * Concrete superclass and default implementation of an AST subtree matcher.
18   * <p>
19   * For example, to compute whether two ASTs subtrees are structurally 
20   * isomorphic, use <code>n1.subtreeMatch(new ASTMatcher(), n2)</code> where 
21   * <code>n1</code> and <code>n2</code> are the AST root nodes of the subtrees.
22   * </p>
23   * <p>
24   * For each different concrete AST node type <i>T</i> there is a
25   * <code>public boolean match(<i>T</i> node, Object other)</code> method
26   * that matches the given node against another object (typically another
27   * AST node, although this is not essential). The default implementations
28   * provided by this class tests whether the other object is a node of the
29   * same type with structurally isomorphic child subtrees. For nodes with 
30   * list-valued properties, the child nodes within the list are compared in
31   * order. For nodes with multiple properties, the child nodes are compared
32   * in the order that most closely corresponds to the lexical reading order
33   * of the source program. For instance, for a type declaration node, the 
34   * child ordering is: name, superclass, superinterfaces, and body 
35   * declarations.
36   * </p>
37   * <p>
38   * Subclasses may override (extend or reimplement) some or all of the 
39   * <code>match</code> methods in order to define more specialized subtree
40   * matchers.
41   * </p>
42   * 
43   * @see org.eclipse.jdt.core.dom.ASTNode#subtreeMatch(ASTMatcher, Object)
44   * @since 2.0
45   */
46  public class ASTMatcher {
47      
48      /**
49       * Indicates whether doc tags should be matched.
50       * @since 3.0
51       */
52      private boolean matchDocTags;
53      
54      /**
55       * Creates a new AST matcher instance.
56       * <p>
57       * For backwards compatibility, the matcher ignores tag
58       * elements below doc comments by default. Use 
59       * {@link #ASTMatcher(boolean) ASTMatcher(true)}
60       * for a matcher that compares doc tags by default.
61       * </p>
62       */
63      public ASTMatcher() {
64          this(false);
65      }
66  
67      /**
68       * Creates a new AST matcher instance.
69       * 
70       * @param matchDocTags <code>true</code> if doc comment tags are
71       * to be compared by default, and <code>false</code> otherwise
72       * @see #match(Javadoc,Object)
73       * @since 3.0
74       */
75      public ASTMatcher(boolean matchDocTags) {
76          this.matchDocTags = matchDocTags;
77      }
78  
79      /**
80       * Returns whether the given lists of AST nodes match pair wise according
81       * to <code>ASTNode.subtreeMatch</code>.
82       * <p>
83       * Note that this is a convenience method, useful for writing recursive
84       * subtree matchers.
85       * </p>
86       * 
87       * @param list1 the first list of AST nodes
88       *    (element type: <code>ASTNode</code>)
89       * @param list2 the second list of AST nodes
90       *    (element type: <code>ASTNode</code>)
91       * @return <code>true</code> if the lists have the same number of elements
92       *    and match pair-wise according to <code>ASTNode.subtreeMatch</code> 
93       * @see ASTNode#subtreeMatch(ASTMatcher matcher, Object other)
94       */
95      public final boolean safeSubtreeListMatch(List   list1, List   list2) {
96          int size1 = list1.size();
97          int size2 = list2.size();
98          if (size1 != size2) {
99              return false;
100         }
101         for (Iterator   it1 = list1.iterator(), it2 = list2.iterator(); it1.hasNext();) {
102             ASTNode n1 = (ASTNode) it1.next();
103             ASTNode n2 = (ASTNode) it2.next();
104             if (!n1.subtreeMatch(this, n2)) {
105                 return false;
106             }
107         }
108         return true;
109     }
110 
111     /**
112      * Returns whether the given nodes match according to
113      * <code>AST.subtreeMatch</code>. Returns <code>false</code> if one or
114      * the other of the nodes are <code>null</code>. Returns <code>true</code>
115      * if both nodes are <code>null</code>.
116      * <p>
117      * Note that this is a convenience method, useful for writing recursive
118      * subtree matchers.
119      * </p>
120      * 
121      * @param node1 the first AST node, or <code>null</code>; must be an
122      *    instance of <code>ASTNode</code>
123      * @param node2 the second AST node, or <code>null</code>; must be an
124      *    instance of <code>ASTNode</code>
125      * @return <code>true</code> if the nodes match according
126      *    to <code>AST.subtreeMatch</code> or both are <code>null</code>, and 
127      *    <code>false</code> otherwise
128      * @see ASTNode#subtreeMatch(ASTMatcher, Object)
129      */
130     public final boolean safeSubtreeMatch(Object   node1, Object   node2) {
131         if (node1 == null && node2 == null) {
132             return true;
133         }
134         if (node1 == null || node2 == null) {
135             return false;
136         }
137         // N.B. call subtreeMatch even node1==node2!=null
138         return ((ASTNode) node1).subtreeMatch(this, node2);
139     }
140 
141     /**
142      * Returns whether the given objects are equal according to
143      * <code>equals</code>. Returns <code>false</code> if either
144      * node is <code>null</code>.
145      * 
146      * @param o1 the first object, or <code>null</code>
147      * @param o2 the second object, or <code>null</code>
148      * @return <code>true</code> if the nodes are equal according to
149      *    <code>equals</code> or both <code>null</code>, and 
150      *    <code>false</code> otherwise
151      */
152     public static boolean safeEquals(Object   o1, Object   o2) {
153         if (o1 == o2) {
154             return true;
155         }
156         if (o1 == null || o2 == null) {
157             return false;
158         }
159         return o1.equals(o2);
160     }
161 
162     /**
163      * Returns whether the given node and the other object match.
164      * <p>
165      * The default implementation provided by this class tests whether the
166      * other object is a node of the same type with structurally isomorphic
167      * child subtrees. Subclasses may override this method as needed.
168      * </p>
169      * 
170      * @param node the node
171      * @param other the other object, or <code>null</code>
172      * @return <code>true</code> if the subtree matches, or 
173      *   <code>false</code> if they do not match or the other object has a
174      *   different node type or is <code>null</code>
175      * @since 3.1
176      */
177     public boolean match(AnnotationTypeDeclaration node, Object   other) {
178         if (!(other instanceof AnnotationTypeDeclaration)) {
179             return false;
180         }
181         AnnotationTypeDeclaration o = (AnnotationTypeDeclaration) other;
182         // node type added in JLS3 - ignore old JLS2-style modifiers
183         return (safeSubtreeMatch(node.getJavadoc(), o.getJavadoc())
184                 && safeSubtreeListMatch(node.modifiers(), o.modifiers())
185                 && safeSubtreeMatch(node.getName(), o.getName())
186                 && safeSubtreeListMatch(node.bodyDeclarations(), o.bodyDeclarations()));
187     }
188 
189     /**
190      * Returns whether the given node and the other object match.
191      * <p>
192      * The default implementation provided by this class tests whether the
193      * other object is a node of the same type with structurally isomorphic
194      * child subtrees. Subclasses may override this method as needed.
195      * </p>
196      * 
197      * @param node the node
198      * @param other the other object, or <code>null</code>
199      * @return <code>true</code> if the subtree matches, or 
200      *   <code>false</code> if they do not match or the other object has a
201      *   different node type or is <code>null</code>
202      * @since 3.1
203      */
204     public boolean match(AnnotationTypeMemberDeclaration node, Object   other) {
205         if (!(other instanceof AnnotationTypeMemberDeclaration)) {
206             return false;
207         }
208         AnnotationTypeMemberDeclaration o = (AnnotationTypeMemberDeclaration) other;
209         // node type added in JLS3 - ignore old JLS2-style modifiers
210         return (safeSubtreeMatch(node.getJavadoc(), o.getJavadoc())
211                 && safeSubtreeListMatch(node.modifiers(), o.modifiers())
212                 && safeSubtreeMatch(node.getType(), o.getType())
213                 && safeSubtreeMatch(node.getName(), o.getName())
214                 && safeSubtreeMatch(node.getDefault(), o.getDefault()));
215     }
216 
217     /**
218      * Returns whether the given node and the other object match.
219      * <p>
220      * The default implementation provided by this class tests whether the
221      * other object is a node of the same type with structurally isomorphic
222      * child subtrees. Subclasses may override this method as needed.
223      * </p>
224      * 
225      * @param node the node
226      * @param other the other object, or <code>null</code>
227      * @return <code>true</code> if the subtree matches, or 
228      *   <code>false</code> if they do not match or the other object has a
229      *   different node type or is <code>null</code>
230      */
231     public boolean match(AnonymousClassDeclaration node, Object   other) {
232         if (!(other instanceof AnonymousClassDeclaration)) {
233             return false;
234         }
235         AnonymousClassDeclaration o = (AnonymousClassDeclaration) other;
236         return safeSubtreeListMatch(node.bodyDeclarations(), o.bodyDeclarations());
237     }
238 
239     /**
240      * Returns whether the given node and the other object match.
241      * <p>
242      * The default implementation provided by this class tests whether the
243      * other object is a node of the same type with structurally isomorphic
244      * child subtrees. Subclasses may override this method as needed.
245      * </p>
246      * 
247      * @param node the node
248      * @param other the other object, or <code>null</code>
249      * @return <code>true</code> if the subtree matches, or 
250      *   <code>false</code> if they do not match or the other object has a
251      *   different node type or is <code>null</code>
252      */
253     public boolean match(ArrayAccess node, Object   other) {
254         if (!(other instanceof ArrayAccess)) {
255             return false;
256         }
257         ArrayAccess o = (ArrayAccess) other;
258         return (
259             safeSubtreeMatch(node.getArray(), o.getArray())
260                 && safeSubtreeMatch(node.getIndex(), o.getIndex()));
261     }
262 
263     /**
264      * Returns whether the given node and the other object object match.
265      * <p>
266      * The default implementation provided by this class tests whether the
267      * other object is a node of the same type with structurally isomorphic
268      * child subtrees. Subclasses may override this method as needed.
269      * </p>
270      * 
271      * @param node the node
272      * @param other the other object, or <code>null</code>
273      * @return <code>true</code> if the subtree matches, or 
274      *   <code>false</code> if they do not match or the other object has a
275      *   different node type or is <code>null</code>
276      */
277     public boolean match(ArrayCreation node, Object   other) {
278         if (!(other instanceof ArrayCreation)) {
279             return false;
280         }
281         ArrayCreation o = (ArrayCreation) other;
282         return (
283             safeSubtreeMatch(node.getType(), o.getType())
284                 && safeSubtreeListMatch(node.dimensions(), o.dimensions())
285                 && safeSubtreeMatch(node.getInitializer(), o.getInitializer()));
286     }
287 
288     /**
289      * Returns whether the given node and the other object match.
290      * <p>
291      * The default implementation provided by this class tests whether the
292      * other object is a node of the same type with structurally isomorphic
293      * child subtrees. Subclasses may override this method as needed.
294      * </p>
295      * 
296      * @param node the node
297      * @param other the other object, or <code>null</code>
298      * @return <code>true</code> if the subtree matches, or 
299      *   <code>false</code> if they do not match or the other object has a
300      *   different node type or is <code>null</code>
301      */
302     public boolean match(ArrayInitializer node, Object   other) {
303         if (!(other instanceof ArrayInitializer)) {
304             return false;
305         }
306         ArrayInitializer o = (ArrayInitializer) other;
307         return safeSubtreeListMatch(node.expressions(), o.expressions());
308     }
309 
310     /**
311      * Returns whether the given node and the other object match.
312      * <p>
313      * The default implementation provided by this class tests whether the
314      * other object is a node of the same type with structurally isomorphic
315      * child subtrees. Subclasses may override this method as needed.
316      * </p>
317      * 
318      * @param node the node
319      * @param other the other object, or <code>null</code>
320      * @return <code>true</code> if the subtree matches, or 
321      *   <code>false</code> if they do not match or the other object has a
322      *   different node type or is <code>null</code>
323      */
324     public boolean match(ArrayType node, Object   other) {
325         if (!(other instanceof ArrayType)) {
326             return false;
327         }
328         ArrayType o = (ArrayType) other;
329         return safeSubtreeMatch(node.getComponentType(), o.getComponentType());
330     }
331 
332     /**
333      * Returns whether the given node and the other object match.
334      * <p>
335      * The default implementation provided by this class tests whether the
336      * other object is a node of the same type with structurally isomorphic
337      * child subtrees. Subclasses may override this method as needed.
338      * </p>
339      * 
340      * @param node the node
341      * @param other the other object, or <code>null</code>
342      * @return <code>true</code> if the subtree matches, or 
343      *   <code>false</code> if they do not match or the other object has a
344      *   different node type or is <code>null</code>
345      */
346     public boolean match(AssertStatement node, Object   other) {
347         if (!(other instanceof AssertStatement)) {
348             return false;
349         }
350         AssertStatement o = (AssertStatement) other;
351         return (
352             safeSubtreeMatch(node.getExpression(), o.getExpression())
353                 && safeSubtreeMatch(node.getMessage(), o.getMessage()));
354     }
355 
356     /**
357      * Returns whether the given node and the other object match.
358      * <p>
359      * The default implementation provided by this class tests whether the
360      * other object is a node of the same type with structurally isomorphic
361      * child subtrees. Subclasses may override this method as needed.
362      * </p>
363      * 
364      * @param node the node
365      * @param other the other object, or <code>null</code>
366      * @return <code>true</code> if the subtree matches, or 
367      *   <code>false</code> if they do not match or the other object has a
368      *   different node type or is <code>null</code>
369      */
370     public boolean match(Assignment node, Object   other) {
371         if (!(other instanceof Assignment)) {
372             return false;
373         }
374         Assignment o = (Assignment) other;
375         return (
376             node.getOperator().equals(o.getOperator())
377                 && safeSubtreeMatch(node.getLeftHandSide(), o.getLeftHandSide())
378                 && safeSubtreeMatch(node.getRightHandSide(), o.getRightHandSide()));
379     }
380 
381     /**
382      * Returns whether the given node and the other object match.
383      * <p>
384      * The default implementation provided by this class tests whether the
385      * other object is a node of the same type with structurally isomorphic
386      * child subtrees. Subclasses may override this method as needed.
387      * </p>
388      * 
389      * @param node the node
390      * @param other the other object, or <code>null</code>
391      * @return <code>true</code> if the subtree matches, or 
392      *   <code>false</code> if they do not match or the other object has a
393      *   different node type or is <code>null</code>
394      */
395     public boolean match(Block node, Object   other) {
396         if (!(other instanceof Block)) {
397             return false;
398         }
399         Block o = (Block) other;
400         return safeSubtreeListMatch(node.statements(), o.statements());
401     }
402 
403     /**
404      * Returns whether the given node and the other object match.
405      * <p>
406      * The default implementation provided by this class tests whether the
407      * other object is a node of the same type. Subclasses may override
408      * this method as needed.
409      * </p>
410      * <p>Note: {@link LineComment} and {@link BlockComment} nodes are
411      * not considered part of main structure of the AST. This method will
412      * only be called if a client goes out of their way to visit this
413      * kind of node explicitly.
414      * </p>
415      * 
416      * @param node the node
417      * @param other the other object, or <code>null</code>
418      * @return <code>true</code> if the subtree matches, or 
419      *   <code>false</code> if they do not match or the other object has a
420      *   different node type or is <code>null</code>
421      * @since 3.0
422      */
423     public boolean match(BlockComment node, Object   other) {
424         if (!(other instanceof BlockComment)) {
425             return false;
426         }
427         return true;
428     }
429 
430     /**
431      * Returns whether the given node and the other object match.
432      * <p>
433      * The default implementation provided by this class tests whether the
434      * other object is a node of the same type with structurally isomorphic
435      * child subtrees. Subclasses may override this method as needed.
436      * </p>
437      * 
438      * @param node the node
439      * @param other the other object, or <code>null</code>
440      * @return <code>true</code> if the subtree matches, or 
441      *   <code>false</code> if they do not match or the other object has a
442      *   different node type or is <code>null</code>
443      */
444     public boolean match(BooleanLiteral node, Object   other) {
445         if (!(other instanceof BooleanLiteral)) {
446             return false;
447         }
448         BooleanLiteral o = (BooleanLiteral) other;
449         return node.booleanValue() == o.booleanValue();
450     }
451 
452     /**
453      * Returns whether the given node and the other object match.
454      * <p>
455      * The default implementation provided by this class tests whether the
456      * other object is a node of the same type with structurally isomorphic
457      * child subtrees. Subclasses may override this method as needed.
458      * </p>
459      * 
460      * @param node the node
461      * @param other the other object, or <code>null</code>
462      * @return <code>true</code> if the subtree matches, or 
463      *   <code>false</code> if they do not match or the other object has a
464      *   different node type or is <code>null</code>
465      */
466     public boolean match(BreakStatement node, Object   other) {
467         if (!(other instanceof BreakStatement)) {
468             return false;
469         }
470         BreakStatement o = (BreakStatement) other;
471         return safeSubtreeMatch(node.getLabel(), o.getLabel());
472     }
473 
474     /**
475      * Returns whether the given node and the other object match.
476      * <p>
477      * The default implementation provided by this class tests whether the
478      * other object is a node of the same type with structurally isomorphic
479      * child subtrees. Subclasses may override this method as needed.
480      * </p>
481      * 
482      * @param node the node
483      * @param other the other object, or <code>null</code>
484      * @return <code>true</code> if the subtree matches, or 
485      *   <code>false</code> if they do not match or the other object has a
486      *   different node type or is <code>null</code>
487      */
488     public boolean match(CastExpression node, Object   other) {
489         if (!(other instanceof CastExpression)) {
490             return false;
491         }
492         CastExpression o = (CastExpression) other;
493         return (
494             safeSubtreeMatch(node.getType(), o.getType())
495                 && safeSubtreeMatch(node.getExpression(), o.getExpression()));
496     }
497 
498     /**
499      * Returns whether the given node and the other object match.
500      * <p>
501      * The default implementation provided by this class tests whether the
502      * other object is a node of the same type with structurally isomorphic
503      * child subtrees. Subclasses may override this method as needed.
504      * </p>
505      * 
506      * @param node the node
507      * @param other the other object, or <code>null</code>
508      * @return <code>true</code> if the subtree matches, or 
509      *   <code>false</code> if they do not match or the other object has a
510      *   different node type or is <code>null</code>
511      */
512     public boolean match(CatchClause node, Object   other) {
513         if (!(other instanceof CatchClause)) {
514             return false;
515         }
516         CatchClause o = (CatchClause) other;
517         return (
518             safeSubtreeMatch(node.getException(), o.getException())
519                 && safeSubtreeMatch(node.getBody(), o.getBody()));
520     }
521 
522     /**
523      * Returns whether the given node and the other object match.
524      * <p>
525      * The default implementation provided by this class tests whether the
526      * other object is a node of the same type with structurally isomorphic
527      * child subtrees. Subclasses may override this method as needed.
528      * </p>
529      * 
530      * @param node the node
531      * @param other the other object, or <code>null</code>
532      * @return <code>true</code> if the subtree matches, or 
533      *   <code>false</code> if they do not match or the other object has a
534      *   different node type or is <code>null</code>
535      */
536     public boolean match(CharacterLiteral node, Object   other) {
537         if (!(other instanceof CharacterLiteral)) {
538             return false;
539         }
540         CharacterLiteral o = (CharacterLiteral) other;
541         return safeEquals(node.getEscapedValue(), o.getEscapedValue());
542     }
543 
544     /**
545      * Returns whether the given node and the other object match.
546      * <p>
547      * The default implementation provided by this class tests whether the
548      * other object is a node of the same type with structurally isomorphic
549      * child subtrees. Subclasses may override this method as needed.
550      * </p>
551      * 
552      * @param node the node
553      * @param other the other object, or <code>null</code>
554      * @return <code>true</code> if the subtree matches, or 
555      *   <code>false</code> if they do not match or the other object has a
556      *   different node type or is <code>null</code>
557      */
558     public boolean match(ClassInstanceCreation node, Object   other) {
559         if (!(other instanceof ClassInstanceCreation)) {
560             return false;
561         }
562         ClassInstanceCreation o = (ClassInstanceCreation) other;
563         int level = node.getAST().apiLevel;
564         if (level == AST.JLS2_INTERNAL) {
565             if (!safeSubtreeMatch(node.internalGetName(), o.internalGetName())) {
566                 return false;
567             }
568         }
569         if (level >= AST.JLS3) {
570             if (!safeSubtreeListMatch(node.typeArguments(), o.typeArguments())) {
571                 return false;
572             }
573             if (!safeSubtreeMatch(node.getType(), o.getType())) {
574                 return false;
575             }
576         }
577         return 
578             safeSubtreeMatch(node.getExpression(), o.getExpression())
579                 && safeSubtreeListMatch(node.arguments(), o.arguments())
580                 && safeSubtreeMatch(
581                     node.getAnonymousClassDeclaration(),
582                     o.getAnonymousClassDeclaration());
583     }
584 
585     /**
586      * Returns whether the given node and the other object match.
587      * <p>
588      * The default implementation provided by this class tests whether the
589      * other object is a node of the same type with structurally isomorphic
590      * child subtrees. Subclasses may override this method as needed.
591      * </p>
592      * 
593      * @param node the node
594      * @param other the other object, or <code>null</code>
595      * @return <code>true</code> if the subtree matches, or 
596      *   <code>false</code> if they do not match or the other object has a
597      *   different node type or is <code>null</code>
598      */
599     public boolean match(CompilationUnit node, Object   other) {
600         if (!(other instanceof CompilationUnit)) {
601             return false;
602         }
603         CompilationUnit o = (CompilationUnit) other;
604         return (
605             safeSubtreeMatch(node.getPackage(), o.getPackage())
606                 && safeSubtreeListMatch(node.imports(), o.imports())
607                 && safeSubtreeListMatch(node.types(), o.types()));
608     }
609 
610     /**
611      * Returns whether the given node and the other object match.
612      * <p>
613      * The default implementation provided by this class tests whether the
614      * other object is a node of the same type with structurally isomorphic
615      * child subtrees. Subclasses may override this method as needed.
616      * </p>
617      * 
618      * @param node the node
619      * @param other the other object, or <code>null</code>
620      * @return <code>true</code> if the subtree matches, or 
621      *   <code>false</code> if they do not match or the other object has a
622      *   different node type or is <code>null</code>
623      */
624     public boolean match(ConditionalExpression node, Object   other) {
625         if (!(other instanceof ConditionalExpression)) {
626             return false;
627         }
628         ConditionalExpression o = (ConditionalExpression) other;
629         return (
630             safeSubtreeMatch(node.getExpression(), o.getExpression())
631                 && safeSubtreeMatch(node.getThenExpression(), o.getThenExpression())
632                 && safeSubtreeMatch(node.getElseExpression(), o.getElseExpression()));
633     }
634 
635     /**
636      * Returns whether the given node and the other object match.
637      * <p>
638      * The default implementation provided by this class tests whether the
639      * other object is a node of the same type with structurally isomorphic
640      * child subtrees. Subclasses may override this method as needed.
641      * </p>
642      * 
643      * @param node the node
644      * @param other the other object, or <code>null</code>
645      * @return <code>true</code> if the subtree matches, or 
646      *   <code>false</code> if they do not match or the other object has a
647      *   different node type or is <code>null</code>
648      */
649     public boolean match(ConstructorInvocation node, Object   other) {
650         if (!(other instanceof ConstructorInvocation)) {
651             return false;
652         }
653         ConstructorInvocation o = (ConstructorInvocation) other;
654         if (node.getAST().apiLevel >= AST.JLS3) {
655             if (!safeSubtreeListMatch(node.typeArguments(), o.typeArguments())) {
656                 return false;
657             }
658         }
659         return safeSubtreeListMatch(node.arguments(), o.arguments());
660     }
661 
662     /**
663      * Returns whether the given node and the other object match.
664      * <p>
665      * The default implementation provided by this class tests whether the
666      * other object is a node of the same type with structurally isomorphic
667      * child subtrees. Subclasses may override this method as needed.
668      * </p>
669      * 
670      * @param node the node
671      * @param other the other object, or <code>null</code>
672      * @return <code>true</code> if the subtree matches, or 
673      *   <code>false</code> if they do not match or the other object has a
674      *   different node type or is <code>null</code>
675      */
676     public boolean match(ContinueStatement node, Object   other) {
677         if (!(other instanceof ContinueStatement)) {
678             return false;
679         }
680         ContinueStatement o = (ContinueStatement) other;
681         return safeSubtreeMatch(node.getLabel(), o.getLabel());
682     }
683 
684     /**
685      * Returns whether the given node and the other object match.
686      * <p>
687      * The default implementation provided by this class tests whether the
688      * other object is a node of the same type with structurally isomorphic
689      * child subtrees. Subclasses may override this method as needed.
690      * </p>
691      * 
692      * @param node the node
693      * @param other the other object, or <code>null</code>
694      * @return <code>true</code> if the subtree matches, or 
695      *   <code>false</code> if they do not match or the other object has a
696      *   different node type or is <code>null</code>
697      */
698     public boolean match(DoStatement node, Object   other) {
699         if (!(other instanceof DoStatement)) {
700             return false;
701         }
702         DoStatement o = (DoStatement) other;
703         return (
704             safeSubtreeMatch(node.getExpression(), o.getExpression())
705                 && safeSubtreeMatch(node.getBody(), o.getBody()));
706     }
707     
708     /**
709      * Returns whether the given node and the other object match.
710      * <p>
711      * The default implementation provided by this class tests whether the
712      * other object is a node of the same type with structurally isomorphic
713      * child subtrees. Subclasses may override this method as needed.
714      * </p>
715      * 
716      * @param node the node
717      * @param other the other object, or <code>null</code>
718      * @return <code>true</code> if the subtree matches, or 
719      *   <code>false</code> if they do not match or the other object has a
720      *   different node type or is <code>null</code>
721      */
722     public boolean match(EmptyStatement node, Object   other) {
723         if (!(other instanceof EmptyStatement)) {
724             return false;
725         }
726         return true;
727     }
728 
729     /**
730      * Returns whether the given node and the other object match.
731      * <p>
732      * The default implementation provided by this class tests whether the
733      * other object is a node of the same type with structurally isomorphic
734      * child subtrees. Subclasses may override this method as needed.
735      * </p>
736      * 
737      * @param node the node
738      * @param other the other object, or <code>null</code>
739      * @return <code>true</code> if the subtree matches, or 
740      *   <code>false</code> if they do not match or the other object has a
741      *   different node type or is <code>null</code>
742      * @since 3.1
743      */
744     public boolean match(EnhancedForStatement node, Object   other) {
745         if (!(other instanceof EnhancedForStatement)) {
746             return false;
747         }
748         EnhancedForStatement o = (EnhancedForStatement) other;
749         return (
750             safeSubtreeMatch(node.getParameter(), o.getParameter())
751                 && safeSubtreeMatch(node.getExpression(), o.getExpression())
752                 && safeSubtreeMatch(node.getBody(), o.getBody()));
753     }
754 
755     /**
756      * Returns whether the given node and the other object match.
757      * <p>
758      * The default implementation provided by this class tests whether the
759      * other object is a node of the same type with structurally isomorphic
760      * child subtrees. Subclasses may override this method as needed.
761      * </p>
762      * 
763      * @param node the node
764      * @param other the other object, or <code>null</code>
765      * @return <code>true</code> if the subtree matches, or 
766      *   <code>false</code> if they do not match or the other object has a
767      *   different node type or is <code>null</code>
768      * @since 3.1
769      */
770     public boolean match(EnumConstantDeclaration node, Object   other) {
771         if (!(other instanceof EnumConstantDeclaration)) {
772             return false;
773         }
774         EnumConstantDeclaration o = (EnumConstantDeclaration) other;
775         return (
776             safeSubtreeMatch(node.getJavadoc(), o.getJavadoc())
777                 && safeSubtreeListMatch(node.modifiers(), o.modifiers())
778                 && safeSubtreeMatch(node.getName(), o.getName())
779                 && safeSubtreeListMatch(node.arguments(), o.arguments())
780                 && safeSubtreeMatch(
781                     node.getAnonymousClassDeclaration(),
782                     o.getAnonymousClassDeclaration()));
783     }
784     
785     /**
786      * Returns whether the given node and the other object match.
787      * <p>
788      * The default implementation provided by this class tests whether the
789      * other object is a node of the same type with structurally isomorphic
790      * child subtrees. Subclasses may override this method as needed.
791      * </p>
792      * 
793      * @param node the node
794      * @param other the other object, or <code>null</code>
795      * @return <code>true</code> if the subtree matches, or 
796      *   <code>false</code> if they do not match or the other object has a
797      *   different node type or is <code>null</code>
798      * @since 3.1
799      */
800     public boolean match(EnumDeclaration node, Object   other) {
801         if (!(other instanceof EnumDeclaration)) {
802             return false;
803         }
804         EnumDeclaration o = (EnumDeclaration) other;
805         return (
806             safeSubtreeMatch(node.getJavadoc(), o.getJavadoc())
807                 && safeSubtreeListMatch(node.modifiers(), o.modifiers())
808                 && safeSubtreeMatch(node.getName(), o.getName())
809                 && safeSubtreeListMatch(node.superInterfaceTypes(), o.superInterfaceTypes())
810                 && safeSubtreeListMatch(node.enumConstants(), o.enumConstants())
811                 && safeSubtreeListMatch(
812                     node.bodyDeclarations(),
813                     o.bodyDeclarations()));
814     }
815     
816     /**
817      * Returns whether the given node and the other object match.
818      * <p>
819      * The default implementation provided by this class tests whether the
820      * other object is a node of the same type with structurally isomorphic
821      * child subtrees. Subclasses may override this method as needed.
822      * </p>
823      * 
824      * @param node the node
825      * @param other the other object, or <code>null</code>
826      * @return <code>true</code> if the subtree matches, or 
827      *   <code>false</code> if they do not match or the other object has a
828      *   different node type or is <code>null</code>
829      */
830     public boolean match(ExpressionStatement node, Object   other) {
831         if (!(other instanceof ExpressionStatement)) {
832             return false;
833         }
834         ExpressionStatement o = (ExpressionStatement) other;
835         return safeSubtreeMatch(node.getExpression(), o.getExpression());
836     }
837 
838     /**
839      * Returns whether the given node and the other object match.
840      * <p>
841      * The default implementation provided by this class tests whether the
842      * other object is a node of the same type with structurally isomorphic
843      * child subtrees. Subclasses may override this method as needed.
844      * </p>
845      * 
846      * @param node the node
847      * @param other the other object, or <code>null</code>
848      * @return <code>true</code> if the subtree matches, or 
849      *   <code>false</code> if they do not match or the other object has a
850      *   different node type or is <code>null</code>
851      */
852     public boolean match(FieldAccess node, Object   other) {
853         if (!(other instanceof FieldAccess)) {
854             return false;
855         }
856         FieldAccess o = (FieldAccess) other;
857         return (
858             safeSubtreeMatch(node.getExpression(), o.getExpression())
859                 && safeSubtreeMatch(node.getName(), o.getName()));
860     }
861 
862     /**
863      * Returns whether the given node and the other object match.
864      * <p>
865      * The default implementation provided by this class tests whether the
866      * other object is a node of the same type with structurally isomorphic
867      * child subtrees. Subclasses may override this method as needed.
868      * </p>
869      * 
870      * @param node the node
871      * @param other the other object, or <code>null</code>
872      * @return <code>true</code> if the subtree matches, or 
873      *   <code>false</code> if they do not match or the other object has a
874      *   different node type or is <code>null</code>
875      */
876     public boolean match(FieldDeclaration node, Object   other) {
877         if (!(other instanceof FieldDeclaration)) {
878             return false;
879         }
880         FieldDeclaration o = (FieldDeclaration) other;
881         int level = node.getAST().apiLevel;
882         if (level == AST.JLS2_INTERNAL) {
883             if (node.getModifiers() != o.getModifiers()) {
884                 return false;
885             }
886         }
887         if (level >= AST.JLS3) {
888             if (!safeSubtreeListMatch(node.modifiers(), o.modifiers())) {
889                 return false;
890             }
891         }
892         return 
893             safeSubtreeMatch(node.getJavadoc(), o.getJavadoc())
894             && safeSubtreeMatch(node.getType(), o.getType())
895             && safeSubtreeListMatch(node.fragments(), o.fragments());
896     }
897 
898     /**
899      * Returns whether the given node and the other object match.
900      * <p>
901      * The default implementation provided by this class tests whether the
902      * other object is a node of the same type with structurally isomorphic
903      * child subtrees. Subclasses may override this method as needed.
904      * </p>
905      * 
906      * @param node the node
907      * @param other the other object, or <code>null</code>
908      * @return <code>true</code> if the subtree matches, or 
909      *   <code>false</code> if they do not match or the other object has a
910      *   different node type or is <code>null</code>
911      */
912     public boolean match(ForStatement node, Object   other) {
913         if (!(other instanceof ForStatement)) {
914             return false;
915         }
916         ForStatement o = (ForStatement) other;
917         return (
918             safeSubtreeListMatch(node.initializers(), o.initializers())
919                 && safeSubtreeMatch(node.getExpression(), o.getExpression())
920                 && safeSubtreeListMatch(node.updaters(), o.updaters())
921                 && safeSubtreeMatch(node.getBody(), o.getBody()));
922     }
923 
924     /**
925      * Returns whether the given node and the other object match.
926      * <p>
927      * The default implementation provided by this class tests whether the
928      * other object is a node of the same type with structurally isomorphic
929      * child subtrees. Subclasses may override this method as needed.
930      * </p>
931      * 
932      * @param node the node
933      * @param other the other object, or <code>null</code>
934      * @return <code>true</code> if the subtree matches, or 
935      *   <code>false</code> if they do not match or the other object has a
936      *   different node type or is <code>null</code>
937      */
938     public boolean match(IfStatement node, Object   other) {
939         if (!(other instanceof IfStatement)) {
940             return false;
941         }
942         IfStatement o = (IfStatement) other;
943         return (
944             safeSubtreeMatch(node.getExpression(), o.getExpression())
945                 && safeSubtreeMatch(node.getThenStatement(), o.getThenStatement())
946                 && safeSubtreeMatch(node.getElseStatement(), o.getElseStatement()));
947     }
948 
949     /**
950      * Returns whether the given node and the other object match.
951      * <p>
952      * The default implementation provided by this class tests whether the
953      * other object is a node of the same type with structurally isomorphic
954      * child subtrees. Subclasses may override this method as needed.
955      * </p>
956      * 
957      * @param node the node
958      * @param other the other object, or <code>null</code>
959      * @return <code>true</code> if the subtree matches, or 
960      *   <code>false</code> if they do not match or the other object has a
961      *   different node type or is <code>null</code>
962      */
963     public boolean match(ImportDeclaration node, Object   other) {
964         if (!(other instanceof ImportDeclaration)) {
965             return false;
966         }
967         ImportDeclaration o = (ImportDeclaration) other;
968         if (node.getAST().apiLevel >= AST.JLS3) {
969             if (node.isStatic() != o.isStatic()) {
970                 return false;
971             }
972         }
973         return (
974             safeSubtreeMatch(node.getName(), o.getName())
975                 && node.isOnDemand() == o.isOnDemand());
976     }
977 
978     /**
979      * Returns whether the given node and the other object match.
980      * <p>
981      * The default implementation provided by this class tests whether the
982      * other object is a node of the same type with structurally isomorphic
983      * child subtrees. Subclasses may override this method as needed.
984      * </p>
985      * 
986      * @param node the node
987      * @param other the other object, or <code>null</code>
988      * @return <code>true</code> if the subtree matches, or 
989      *   <code>false</code> if they do not match or the other object has a
990      *   different node type or is <code>null</code>
991      */
992     public boolean match(InfixExpression node, Object   other) {
993         if (!(other instanceof InfixExpression)) {
994             return false;
995         }
996         InfixExpression o = (InfixExpression) other;
997         // be careful not to trigger lazy creation of extended operand lists
998         if (node.hasExtendedOperands() && o.hasExtendedOperands()) {
999             if (!safeSubtreeListMatch(node.extendedOperands(), o.extendedOperands())) {
1000                return false;
1001            }
1002        }
1003        if (node.hasExtendedOperands() != o.hasExtendedOperands()) {
1004            return false;
1005        }
1006        return (
1007            node.getOperator().equals(o.getOperator())
1008                && safeSubtreeMatch(node.getLeftOperand(), o.getLeftOperand())
1009                && safeSubtreeMatch(node.getRightOperand(), o.getRightOperand()));
1010    }
1011
1012    /**
1013     * Returns whether the given node and the other object match.
1014     * <p>
1015     * The default implementation provided by this class tests whether the
1016     * other object is a node of the same type with structurally isomorphic
1017     * child subtrees. Subclasses may override this method as needed.
1018     * </p>
1019     * 
1020     * @param node the node
1021     * @param other the other object, or <code>null</code>
1022     * @return <code>true</code> if the subtree matches, or 
1023     *   <code>false</code> if they do not match or the other object has a
1024     *   different node type or is <code>null</code>
1025     */
1026    public boolean match(InstanceofExpression node, Object   other) {
1027        if (!(other instanceof InstanceofExpression)) {
1028            return false;
1029        }
1030        InstanceofExpression o = (InstanceofExpression) other;
1031        return (
1032                safeSubtreeMatch(node.getLeftOperand(), o.getLeftOperand())
1033                && safeSubtreeMatch(node.getRightOperand(), o.getRightOperand()));
1034    }
1035
1036    /**
1037     * Returns whether the given node and the other object match.
1038     * <p>
1039     * The default implementation provided by this class tests whether the
1040     * other object is a node of the same type with structurally isomorphic
1041     * child subtrees. Subclasses may override this method as needed.
1042     * </p>
1043     * 
1044     * @param node the node
1045     * @param other the other object, or <code>null</code>
1046     * @return <code>true</code> if the subtree matches, or 
1047     *   <code>false</code> if they do not match or the other object has a
1048     *   different node type or is <code>null</code>
1049     */
1050    public boolean match(Initializer node, Object   other) {
1051        if (!(other instanceof Initializer)) {
1052            return false;
1053        }
1054        Initializer o = (Initializer) other;
1055        int level = node.getAST().apiLevel;
1056        if (level == AST.JLS2_INTERNAL) {
1057            if (node.getModifiers() != o.getModifiers()) {
1058                return false;
1059            }
1060        }
1061        if (level >= AST.JLS3) {
1062            if (!safeSubtreeListMatch(node.modifiers(), o.modifiers())) {
1063                return false;
1064            }
1065        }
1066        return (
1067                safeSubtreeMatch(node.getJavadoc(), o.getJavadoc())
1068                && safeSubtreeMatch(node.getBody(), o.getBody()));
1069    }
1070
1071    /**
1072     * Returns whether the given node and the other object match.
1073     * <p>
1074     * Unlike other node types, the behavior of the default
1075     * implementation is controlled by a constructor-supplied
1076     * parameter  {@link #ASTMatcher(boolean) ASTMatcher(boolean)} 
1077     * which is <code>false</code> if not specified. 
1078     * When this parameter is <code>true</code>, the implementation
1079     * tests whether the other object is also a <code>Javadoc</code>
1080     * with structurally isomorphic child subtrees; the comment string 
1081     * (<code>Javadoc.getComment()</code>) is ignored.
1082     * Conversely, when the parameter is <code>false</code>, the
1083     * implementation tests whether the other object is also a
1084     * <code>Javadoc</code> with exactly the same comment string; 
1085     * the tag elements ({@link Javadoc#tags() Javadoc.tags} are
1086     * ignored. Subclasses may reimplement.
1087     * </p>
1088     * 
1089     * @param node the node
1090     * @param other the other object, or <code>null</code>
1091     * @return <code>true</code> if the subtree matches, or 
1092     *   <code>false</code> if they do not match or the other object has a
1093     *   different node type or is <code>null</code>
1094     * @see #ASTMatcher()
1095     * @see #ASTMatcher(boolean)
1096     */
1097    public boolean match(Javadoc node, Object   other) {
1098        if (!(other instanceof Javadoc)) {
1099            return false;
1100        }
1101        Javadoc o = (Javadoc) other;
1102        if (this.matchDocTags) {
1103            return safeSubtreeListMatch(node.tags(), o.tags());
1104        } else {
1105            return compareDeprecatedComment(node, o);
1106        }
1107    }
1108
1109    /**
1110     * Return whether the deprecated comment strings of the given java doc are equals.
1111     * <p>
1112     * Note the only purpose of this method is to hide deprecated warnings.
1113     * @deprecated mark deprecated to hide deprecated usage
1114     */
1115    private boolean compareDeprecatedComment(Javadoc first, Javadoc second) {
1116        if (first.getAST().apiLevel == AST.JLS2_INTERNAL) {
1117            return safeEquals(first.getComment(), second.getComment());
1118        } else {
1119            return true;
1120        }
1121    }
1122
1123    /**
1124     * Returns whether the given node and the other object match.
1125     * <p>
1126     * The default implementation provided by this class tests whether the
1127     * other object is a node of the same type with structurally isomorphic
1128     * child subtrees. Subclasses may override this method as needed.
1129     * </p>
1130     * 
1131     * @param node the node
1132     * @param other the other object, or <code>null</code>
1133     * @return <code>true</code> if the subtree matches, or 
1134     *   <code>false</code> if they do not match or the other object has a
1135     *   different node type or is <code>null</code>
1136     */
1137    public boolean match(LabeledStatement node, Object   other) {
1138        if (!(other instanceof LabeledStatement)) {
1139            return false;
1140        }
1141        LabeledStatement o = (LabeledStatement) other;
1142        return (
1143            safeSubtreeMatch(node.getLabel(), o.getLabel())
1144                && safeSubtreeMatch(node.getBody(), o.getBody()));
1145    }
1146
1147    /**
1148     * Returns whether the given node and the other object match.
1149     * <p>
1150     * The default implementation provided by this class tests whether the
1151     * other object is a node of the same type. Subclasses may override
1152     * this method as needed.
1153     * </p>
1154     * <p>Note: {@link LineComment} and {@link BlockComment} nodes are
1155     * not considered part of main structure of the AST. This method will
1156     * only be called if a client goes out of their way to visit this
1157     * kind of node explicitly.
1158     * </p>
1159     * 
1160     * @param node the node
1161     * @param other the other object, or <code>null</code>
1162     * @return <code>true</code> if the subtree matches, or 
1163     *   <code>false</code> if they do not match or the other object has a
1164     *   different node type or is <code>null</code>
1165     * @since 3.0
1166     */
1167    public boolean match(LineComment node, Object   other) {
1168        if (!(other instanceof LineComment)) {
1169            return false;
1170        }
1171        return true;
1172    }
1173    
1174    /**
1175     * Returns whether the given node and the other object match.
1176     * <p>
1177     * The default implementation provided by this class tests whether the
1178     * other object is a node of the same type with structurally isomorphic
1179     * child subtrees. Subclasses may override this method as needed.
1180     * </p>
1181     * 
1182     * @param node the node
1183     * @param other the other object, or <code>null</code>
1184     * @return <code>true</code> if the subtree matches, or 
1185     *   <code>false</code> if they do not match or the other object has a
1186     *   different node type or is <code>null</code>
1187     * @since 3.1
1188     */
1189    public boolean match(MarkerAnnotation node, Object   other) {
1190        if (!(other instanceof MarkerAnnotation)) {
1191            return false;
1192        }
1193        MarkerAnnotation o = (MarkerAnnotation) other;
1194        return safeSubtreeMatch(node.getTypeName(), o.getTypeName());
1195    }
1196
1197    /**
1198     * Returns whether the given node and the other object match.
1199     * <p>
1200     * The default implementation provided by this class tests whether the
1201     * other object is a node of the same type with structurally isomorphic
1202     * child subtrees. Subclasses may override this method as needed.
1203     * </p>
1204     * 
1205     * @param node the node
1206     * @param other the other object, or <code>null</code>
1207     * @return <code>true</code> if the subtree matches, or 
1208     *   <code>false</code> if they do not match or the other object has a
1209     *   different node type or is <code>null</code>
1210     * @since 3.0
1211     */
1212    public boolean match(MemberRef node, Object   other) {
1213        if (!(other instanceof MemberRef)) {
1214            return false;
1215        }
1216        MemberRef o = (MemberRef) other;
1217        return (
1218                safeSubtreeMatch(node.getQualifier(), o.getQualifier())
1219                && safeSubtreeMatch(node.getName(), o.getName()));
1220    }
1221    
1222    /**
1223     * Returns whether the given node and the other object match.
1224     * <p>
1225     * The default implementation provided by this class tests whether the
1226     * other object is a node of the same type with structurally isomorphic
1227     * child subtrees. Subclasses may override this method as needed.
1228     * </p>
1229     * 
1230     * @param node the node
1231     * @param other the other object, or <code>null</code>
1232     * @return <code>true</code> if the subtree matches, or 
1233     *   <code>false</code> if they do not match or the other object has a
1234     *   different node type or is <code>null</code>
1235     * @since 3.1
1236     */
1237    public boolean match(MemberValuePair node, Object   other) {
1238        if (!(other instanceof MemberValuePair)) {
1239            return false;
1240        }
1241        MemberValuePair o = (MemberValuePair) other;
1242        return (safeSubtreeMatch(node.getName(), o.getName())
1243                && safeSubtreeMatch(node.getValue(), o.getValue()));
1244    }
1245
1246    /**
1247     * Returns whether the given node and the other object match.
1248     * <p>
1249     * The default implementation provided by this class tests whether the
1250     * other object is a node of the same type with structurally isomorphic
1251     * child subtrees. Subclasses may override this method as needed.
1252     * </p>
1253     * 
1254     * @param node the node
1255     * @param other the other object, or <code>null</code>
1256     * @return <code>true</code> if the subtree matches, or 
1257     *   <code>false</code> if they do not match or the other object has a
1258     *   different node type or is <code>null</code>
1259     * @since 3.0
1260     */
1261    public boolean match(MethodRef node, Object   other) {
1262        if (!(other instanceof MethodRef)) {
1263            return false;
1264        }
1265        MethodRef o = (MethodRef) other;
1266        return (
1267                safeSubtreeMatch(node.getQualifier(), o.getQualifier())
1268                && safeSubtreeMatch(node.getName(), o.getName())
1269                && safeSubtreeListMatch(node.parameters(), o.parameters()));
1270    }
1271
1272    /**
1273     * Returns whether the given node and the other object match.
1274     * <p>
1275     * The default implementation provided by this class tests whether the
1276     * other object is a node of the same type with structurally isomorphic
1277     * child subtrees. Subclasses may override this method as needed.
1278     * </p>
1279     * 
1280     * @param node the node
1281     * @param other the other object, or <code>null</code>
1282     * @return <code>true</code> if the subtree matches, or 
1283     *   <code>false</code> if they do not match or the other object has a
1284     *   different node type or is <code>null</code>
1285     * @since 3.0
1286     */
1287    public boolean match(MethodRefParameter node, Object   other) {
1288        if (!(other instanceof MethodRefParameter)) {
1289            return false;
1290        }
1291        MethodRefParameter o = (MethodRefParameter) other;
1292        int level = node.getAST().apiLevel;
1293        if (level >= AST.JLS3) {
1294            if (node.isVarargs() != o.isVarargs()) {
1295                return false;
1296            }
1297        }
1298        return (
1299                safeSubtreeMatch(node.getType(), o.getType())
1300                && safeSubtreeMatch(node.getName(), o.getName()));
1301    }
1302    
1303    /**
1304     * Returns whether the given node and the other object match.
1305     * <p>
1306     * The default implementation provided by this class tests whether the
1307     * other object is a node of the same type with structurally isomorphic
1308     * child subtrees. Subclasses may override this method as needed.
1309     * </p>
1310     * <p>
1311     * Note that extra array dimensions are compared since they are an
1312     * important part of the method declaration.
1313     * </p>
1314     * <p>
1315     * Note that the method return types are compared even for constructor
1316     * declarations.
1317     * </p>
1318     * 
1319     * @param node the node
1320     * @param other the other object, or <code>null</code>
1321     * @return <code>true</code> if the subtree matches, or 
1322     *   <code>false</code> if they do not match or the other object has a
1323     *   different node type or is <code>null</code>
1324     */
1325    public boolean match(MethodDeclaration node, Object   other) {
1326        if (!(other instanceof MethodDeclaration)) {
1327            return false;
1328        }
1329        MethodDeclaration o = (MethodDeclaration) other;
1330        int level = node.getAST().apiLevel;
1331        if (level == AST.JLS2_INTERNAL) {
1332            if (node.getModifiers() != o.getModifiers()) {
1333                return false;
1334            }
1335            if (!safeSubtreeMatch(node.internalGetReturnType(), o.internalGetReturnType())) {
1336                return false;
1337            }
1338        }
1339        if (level >= AST.JLS3) {
1340            if (!safeSubtreeListMatch(node.modifiers(), o.modifiers())) {
1341                return false;
1342            }
1343            if (!safeSubtreeMatch(node.getReturnType2(), o.getReturnType2())) {
1344                return false;
1345            }
1346            // n.b. compare type parameters even for constructors
1347            if (!safeSubtreeListMatch(node.typeParameters(), o.typeParameters())) {
1348                return false;
1349            }
1350        }
1351        return ((node.isConstructor() == o.isConstructor())
1352                && safeSubtreeMatch(node.getJavadoc(), o.getJavadoc())
1353                && safeSubtreeMatch(node.getName(), o.getName())
1354                // n.b. compare return type even for constructors
1355                && safeSubtreeListMatch(node.parameters(), o.parameters())
1356                && node.getExtraDimensions() == o.getExtraDimensions()
1357                && safeSubtreeListMatch(node.thrownExceptions(), o.thrownExceptions())
1358                && safeSubtreeMatch(node.getBody(), o.getBody()));
1359    }
1360
1361    /**
1362     * Returns whether the given node and the other object match.
1363     * <p>
1364     * The default implementation provided by this class tests whether the
1365     * other object is a node of the same type with structurally isomorphic
1366     * child subtrees. Subclasses may override this method as needed.
1367     * </p>
1368     * 
1369     * @param node the node
1370     * @param other the other object, or <code>null</code>
1371     * @return <code>true</code> if the subtree matches, or 
1372     *   <code>false</code> if they do not match or the other object has a
1373     *   different node type or is <code>null</code>
1374     */
1375    public boolean match(MethodInvocation node, Object   other) {
1376        if (!(other instanceof MethodInvocation)) {
1377            return false;
1378        }
1379        MethodInvocation o = (MethodInvocation) other;
1380        if (node.getAST().apiLevel >= AST.JLS3) {
1381            if (!safeSubtreeListMatch(node.typeArguments(), o.typeArguments())) {
1382                return false;
1383            }
1384        }
1385        return (
1386            safeSubtreeMatch(node.getExpression(), o.getExpression())
1387                && safeSubtreeMatch(node.getName(), o.getName())
1388                && safeSubtreeListMatch(node.arguments(), o.arguments()));
1389    }
1390
1391    /**
1392     * Returns whether the given node and the other object match.
1393     * <p>
1394     * The default implementation provided by this class tests whether the
1395     * other object is a node of the same type with structurally isomorphic
1396     * child subtrees. Subclasses may override this method as needed.
1397     * </p>
1398     * 
1399     * @param node the node
1400     * @param other the other object, or <code>null</code>
1401     * @return <code>true</code> if the subtree matches, or 
1402     *   <code>false</code> if they do not match or the other object has a
1403     *   different node type or is <code>null</code>
1404     * @since 3.1
1405     */
1406    public boolean match(Modifier node, Object   other) {
1407        if (!(other instanceof Modifier)) {
1408            return false;
1409        }
1410        Modifier o = (Modifier) other;
1411        return (node.getKeyword() == o.getKeyword());
1412    }
1413
1414    /**
1415     * Returns whether the given node and the other object match.
1416     * <p>
1417     * The default implementation provided by this class tests whether the
1418     * other object is a node of the same type with structurally isomorphic
1419     * child subtrees. Subclasses may override this method as needed.
1420     * </p>
1421     * 
1422     * @param node the node
1423     * @param other the other object, or <code>null</code>
1424     * @return <code>true</code> if the subtree matches, or 
1425     *   <code>false</code> if they do not match or the other object has a
1426     *   different node type or is <code>null</code>
1427     * @since 3.1
1428     */
1429    public boolean match(NormalAnnotation node, Object   other) {
1430        if (!(other instanceof NormalAnnotation)) {
1431            return false;
1432        }
1433        NormalAnnotation o = (NormalAnnotation) other;
1434        return (safeSubtreeMatch(node.getTypeName(), o.getTypeName())
1435                    && safeSubtreeListMatch(node.values(), o.values()));
1436    }
1437
1438    /**
1439     * Returns whether the given node and the other object match.
1440     * <p>
1441     * The default implementation provided by this class tests whether the
1442     * other object is a node of the same type with structurally isomorphic
1443     * child subtrees. Subclasses may override this method as needed.
1444     * </p>
1445     * 
1446     * @param node the node
1447     * @param other the other object, or <code>null</code>
1448     * @return <code>true</code> if the subtree matches, or 
1449     *   <code>false</code> if they do not match or the other object has a
1450     *   different node type or is <code>null</code>
1451     */
1452    public boolean match(NullLiteral node, Object   other) {
1453        if (!(other instanceof NullLiteral)) {
1454            return false;
1455        }
1456        return true;
1457    }
1458
1459    /**
1460     * Returns whether the given node and the other object match.
1461     * <p>
1462     * The default implementation provided by this class tests whether the
1463     * other object is a node of the same type with structurally isomorphic
1464     * child subtrees. Subclasses may override this method as needed.
1465     * </p>
1466     * 
1467     * @param node the node
1468     * @param other the other object, or <code>null</code>
1469     * @return <code>true</code> if the subtree matches, or 
1470     *   <code>false</code> if they do not match or the other object has a
1471     *   different node type or is <code>null</code>
1472     */
1473    public boolean match(NumberLiteral node, Object   other) {
1474        if (!(other instanceof NumberLiteral)) {
1475            return false;
1476        }
1477        NumberLiteral o = (NumberLiteral) other;
1478        return safeEquals(node.getToken(), o.getToken());
1479    }
1480
1481    /**
1482     * Returns whether the given node and the other object match.
1483     * <p>
1484     * The default implementation provided by this class tests whether the
1485     * other object is a node of the same type with structurally isomorphic
1486     * child subtrees. Subclasses may override this method as needed.
1487     * </p>
1488     * 
1489     * @param node the node
1490     * @param other the other object, or <code>null</code>
1491     * @return <code>true</code> if the subtree matches, or 
1492     *   <code>false</code> if they do not match or the other object has a
1493     *   different node type or is <code>null</code>
1494     */
1495    public boolean match(PackageDeclaration node, Object   other) {
1496        if (!(other instanceof PackageDeclaration)) {
1497            return false;
1498        }
1499        PackageDeclaration o = (PackageDeclaration) other;
1500        if (node.getAST().apiLevel >= AST.JLS3) {
1501            if (!safeSubtreeMatch(node.getJavadoc(), o.getJavadoc())) {
1502                return false;
1503            }
1504            if (!safeSubtreeListMatch(node.annotations(), o.annotations())) {
1505                return false;
1506            }
1507        }
1508        return safeSubtreeMatch(node.getName(), o.getName());
1509    }
1510
1511    /**
1512     * Returns whether the given node and the other object match.
1513     * <p>
1514     * The default implementation provided by this class tests whether the
1515     * other object is a node of the same type with structurally isomorphic
1516     * child subtrees. Subclasses may override this method as needed.
1517     * </p>
1518     * 
1519     * @param node the node
1520     * @param other the other object, or <code>null</code>
1521     * @return <code>true</code> if the subtree matches, or 
1522     *   <code>false</code> if they do not match or the other object has a
1523     *   different node type or is <code>null</code>
1524     * @since 3.1
1525     */
1526    public boolean match(ParameterizedType node, Object   other) {
1527        if (!(other instanceof ParameterizedType)) {
1528            return false;
1529        }
1530        ParameterizedType o = (ParameterizedType) other;
1531        return safeSubtreeMatch(node.getType(), o.getType())
1532                && safeSubtreeListMatch(node.typeArguments(), o.typeArguments());
1533    }
1534
1535    /**
1536     * Returns whether the given node and the other object match.
1537     * <p>
1538     * The default implementation provided by this class tests whether the
1539     * other object is a node of the same type with structurally isomorphic
1540     * child subtrees. Subclasses may override this method as needed.
1541     * </p>
1542     * 
1543     * @param node the node
1544     * @param other the other object, or <code>null</code>
1545     * @return <code>true</code> if the subtree matches, or 
1546     *   <code>false</code> if they do not match or the other object has a
1547     *   different node type or is <code>null</code>
1548     */
1549    public boolean match(ParenthesizedExpression node, Object   other) {
1550        if (!(other instanceof ParenthesizedExpression)) {
1551            return false;
1552        }
1553        ParenthesizedExpression o = (ParenthesizedExpression) other;
1554        return safeSubtreeMatch(node.getExpression(), o.getExpression());
1555    }
1556
1557    /**
1558     * Returns whether the given node and the other object match.
1559     * <p>
1560     * The default implementation provided by this class tests whether the
1561     * other object is a node of the same type with structurally isomorphic
1562     * child subtrees. Subclasses may override this method as needed.
1563     * </p>
1564     * 
1565     * @param node the node
1566     * @param other the other object, or <code>null</code>
1567     * @return <code>true</code> if the subtree matches, or 
1568     *   <code>false</code> if they do not match or the other object has a
1569     *   different node type or is <code>null</code>
1570     */
1571    public boolean match(PostfixExpression node, Object   other) {
1572        if (!(other instanceof PostfixExpression)) {
1573            return false;
1574        }
1575        PostfixExpression o = (PostfixExpression) other;
1576        return (
1577            node.getOperator().equals(o.getOperator())
1578                && safeSubtreeMatch(node.getOperand(), o.getOperand()));
1579    }
1580
1581    /**
1582     * Returns whether the given node and the other object match.
1583     * <p>
1584     * The default implementation provided by this class tests whether the
1585     * other object is a node of the same type with structurally isomorphic
1586     * child subtrees. Subclasses may override this method as needed.
1587     * </p>
1588     * 
1589     * @param node the node
1590     * @param other the other object, or <code>null</code>
1591     * @return <code>true</code> if the subtree matches, or 
1592     *   <code>false</code> if they do not match or the other object has a
1593     *   different node type or is <code>null</code>
1594     */
1595    public boolean match(PrefixExpression node, Object   other) {
1596        if (!(other instanceof PrefixExpression)) {
1597            return false;
1598        }
1599        PrefixExpression o = (PrefixExpression) other;
1600        return (
1601            node.getOperator().equals(o.getOperator())
1602                && safeSubtreeMatch(node.getOperand(), o.getOperand()));
1603    }
1604
1605    /**
1606     * Returns whether the given node and the other object match.
1607     * <p>
1608     * The default implementation provided by this class tests whether the
1609     * other object is a node of the same type with structurally isomorphic
1610     * child subtrees. Subclasses may override this method as needed.
1611     * </p>
1612     * 
1613     * @param node the node
1614     * @param other the other object, or <code>null</code>
1615     * @return <code>true</code> if the subtree matches, or 
1616     *   <code>false</code> if they do not match or the other object has a
1617     *   different node type or is <code>null</code>
1618     */
1619    public boolean match(PrimitiveType node, Object   other) {
1620        if (!(other instanceof PrimitiveType)) {
1621            return false;
1622        }
1623        PrimitiveType o = (PrimitiveType) other;
1624        return (node.getPrimitiveTypeCode() == o.getPrimitiveTypeCode());
1625    }
1626
1627    /**
1628     * Returns whether the given node and the other object match.
1629     * <p>
1630     * The default implementation provided by this class tests whether the
1631     * other object is a node of the same type with structurally isomorphic
1632     * child subtrees. Subclasses may override this method as needed.
1633     * </p>
1634     * 
1635     * @param node the node
1636     * @param other the other object, or <code>null</code>
1637     * @return <code>true</code> if the subtree matches, or 
1638     *   <code>false</code> if they do not match or the other object has a
1639     *   different node type or is <code>null</code>
1640     */
1641    public boolean match(QualifiedName node, Object   other) {
1642        if (!(other instanceof QualifiedName)) {
1643            return false;
1644        }
1645        QualifiedName o = (QualifiedName) other;
1646        return (
1647            safeSubtreeMatch(node.getQualifier(), o.getQualifier())
1648                && safeSubtreeMatch(node.getName(), o.getName()));
1649    }
1650
1651    /**
1652     * Returns whether the given node and the other object match.
1653     * <p>
1654     * The default implementation provided by this class tests whether the
1655     * other object is a node of the same type with structurally isomorphic
1656     * child subtrees. Subclasses may override this method as needed.
1657     * </p>
1658     * 
1659     * @param node the node
1660     * @param other the other object, or <code>null</code>
1661     * @return <code>true</code> if the subtree matches, or 
1662     *   <code>false</code> if they do not match or the other object has a
1663     *   different node type or is <code>null</code>
1664     * @since 3.1
1665     */
1666    public boolean match(QualifiedType node, Object   other) {
1667        if (!(other instanceof QualifiedType)) {
1668            return false;
1669        }
1670        QualifiedType o = (QualifiedType) other;
1671        return (
1672            safeSubtreeMatch(node.getQualifier(), o.getQualifier())
1673                && safeSubtreeMatch(node.getName(), o.getName()));
1674    }
1675
1676    /**
1677     * Returns whether the given node and the other object match.
1678     * <p>
1679     * The default implementation provided by this class tests whether the
1680     * other object is a node of the same type with structurally isomorphic
1681     * child subtrees. Subclasses may override this method as needed.
1682     * </p>
1683     * 
1684     * @param node the node
1685     * @param other the other object, or <code>null</code>
1686     * @return <code>true</code> if the subtree matches, or 
1687     *   <code>false</code> if they do not match or the other object has a
1688     *   different node type or is <code>null</code>
1689     */
1690    public boolean match(ReturnStatement node, Object   other) {
1691        if (!(other instanceof ReturnStatement)) {
1692            return false;
1693        }
1694        ReturnStatement o = (ReturnStatement) other;
1695        return safeSubtreeMatch(node.getExpression(), o.getExpression());
1696    }
1697
1698    /**
1699     * Returns whether the given node and the other object match.
1700     * <p>
1701     * The default implementation provided by this class tests whether the
1702     * other object is a node of the same type with structurally isomorphic
1703     * child subtrees. Subclasses may override this method as needed.
1704     * </p>
1705     * 
1706     * @param node the node
1707     * @param other the other object, or <code>null</code>
1708     * @return <code>true</code> if the subtree matches, or 
1709     *   <code>false</code> if they do not match or the other object has a
1710     *   different node type or is <code>null</code>
1711     */
1712    public boolean match(SimpleName node, Object   other) {
1713        if (!(other instanceof SimpleName)) {
1714            return false;
1715        }
1716        SimpleName o = (SimpleName) other;
1717        return node.getIdentifier().equals(o.getIdentifier());
1718    }
1719
1720    /**
1721     * Returns whether the given node and the other object match.
1722     * <p>
1723     * The default implementation provided by this class tests whether the
1724     * other object is a node of the same type with structurally isomorphic
1725     * child subtrees. Subclasses may override this method as needed.
1726     * </p>
1727     * 
1728     * @param node the node
1729     * @param other the other object, or <code>null</code>
1730     * @return <code>true</code> if the subtree matches, or 
1731     *   <code>false</code> if they do not match or the other object has a
1732     *   different node type or is <code>null</code>
1733     */
1734    public boolean match(SimpleType node, Object   other) {
1735        if (!(other instanceof SimpleType)) {
1736            return false;
1737        }
1738        SimpleType o = (SimpleType) other;
1739        return safeSubtreeMatch(node.getName(), o.getName());
1740    }
1741
1742    /**
1743     * Returns whether the given node and the other object match.
1744     * <p>
1745     * The default implementation provided by this class tests whether the
1746     * other object is a node of the same type with structurally isomorphic
1747     * child subtrees. Subclasses may override this method as needed.
1748     * </p>
1749     * 
1750     * @param node the node
1751     * @param other the other object, or <code>null</code>
1752     * @return <code>true</code> if the subtree matches, or 
1753     *   <code>false</code> if they do not match or the other object has a
1754     *   different node type or is <code>null</code>
1755     * @since 3.1
1756     */
1757    public boolean match(SingleMemberAnnotation node, Object   other) {
1758        if (!(other instanceof SingleMemberAnnotation)) {
1759            return false;
1760        }
1761        SingleMemberAnnotation o = (SingleMemberAnnotation) other;
1762        return (safeSubtreeMatch(node.getTypeName(), o.getTypeName())
1763                && safeSubtreeMatch(node.getValue(), o.getValue()));
1764    }
1765
1766    /**
1767     * Returns whether the given node and the other object match.
1768     * <p>
1769     * The default implementation provided by this class tests whether the
1770     * other object is a node of the same type with structurally isomorphic
1771     * child subtrees. Subclasses may override this method as needed.
1772     * </p>
1773     * <p>
1774     * Note that extra array dimensions and the variable arity flag 
1775     * are compared since they are both important parts of the declaration.
1776     * </p>
1777     * 
1778     * @param node the node
1779     * @param other the other object, or <code>null</code>
1780     * @return <code>true</code> if the subtree matches, or 
1781     *   <code>false</code> if they do not match or the other object has a
1782     *   different node type or is <code>null</code>
1783     */
1784    public boolean match(SingleVariableDeclaration node, Object   other) {
1785        if (!(other instanceof SingleVariableDeclaration)) {
1786            return false;
1787        }
1788        SingleVariableDeclaration o = (SingleVariableDeclaration) other;
1789        int level = node.getAST().apiLevel;
1790        if (level == AST.JLS2_INTERNAL) {
1791            if (node.getModifiers() != o.getModifiers()) {
1792                return false;
1793            }
1794        }
1795        if (level >= AST.JLS3) {
1796            if (!safeSubtreeListMatch(node.modifiers(), o.modifiers())) {
1797                return false;
1798            }
1799            if (node.isVarargs() != o.isVarargs()) {
1800                return false;
1801            }
1802        }
1803        return 
1804            safeSubtreeMatch(node.getType(), o.getType())
1805                && safeSubtreeMatch(node.getName(), o.getName())
1806                && node.getExtraDimensions() == o.getExtraDimensions()
1807                && safeSubtreeMatch(node.getInitializer(), o.getInitializer());
1808    }
1809
1810    /**
1811     * Returns whether the given node and the other object match.
1812     * <p>
1813     * The default implementation provided by this class tests whether the
1814     * other object is a node of the same type with structurally isomorphic
1815     * child subtrees. Subclasses may override this method as needed.
1816     * </p>
1817     * 
1818     * @param node the node
1819     * @param other the other object, or <code>null</code>
1820     * @return <code>true</code> if the subtree matches, or 
1821     *   <code>false</code> if they do not match or the other object has a
1822     *   different node type or is <code>null</code>
1823     */
1824    public boolean match(StringLiteral node, Object   other) {
1825        if (!(other instanceof StringLiteral)) {
1826            return false;
1827        }
1828        StringLiteral o = (StringLiteral) other;
1829        return safeEquals(node.getEscapedValue(), o.getEscapedValue());
1830    }
1831
1832    /**
1833     * Returns whether the given node and the other object match.
1834     * <p>
1835     * The default implementation provided by this class tests whether the
1836     * other object is a node of the same type with structurally isomorphic
1837     * child subtrees. Subclasses may override this method as needed.
1838     * </p>
1839     * 
1840     * @param node the node
1841     * @param other the other object, or <code>null</code>
1842     * @return <code>true</code> if the subtree matches, or 
1843     *   <code>false</code> if they do not match or the other object has a
1844     *   different node type or is <code>null</code>
1845     */
1846    public boolean match(SuperConstructorInvocation node, Object   other) {
1847        if (!(other instanceof SuperConstructorInvocation)) {
1848            return false;
1849        }
1850        SuperConstructorInvocation o = (SuperConstructorInvocation) other;
1851        if (node.getAST().apiLevel >= AST.JLS3) {
1852            if (!safeSubtreeListMatch(node.typeArguments(), o.typeArguments())) {
1853                return false;
1854            }
1855        }
1856        return (
1857            safeSubtreeMatch(node.getExpression(), o.getExpression())
1858                && safeSubtreeListMatch(node.arguments(), o.arguments()));
1859    }
1860
1861    /**
1862     * Returns whether the given node and the other object match.
1863     * <p>
1864     * The default implementation provided by this class tests whether the
1865     * other object is a node of the same type with structurally isomorphic
1866     * child subtrees. Subclasses may override this method as needed.
1867     * </p>
1868     * 
1869     * @param node the node
1870     * @param other the other object, or <code>null</code>
1871     * @return <code>true</code> if the subtree matches, or 
1872     *   <code>false</code> if they do not match or the other object has a
1873     *   different node type or is <code>null</code>
1874     */
1875    public boolean match(SuperFieldAccess node, Object   other) {
1876        if (!(other instanceof SuperFieldAccess)) {
1877            return false;
1878        }
1879        SuperFieldAccess o = (SuperFieldAccess) other;
1880        return (
1881            safeSubtreeMatch(node.getName(), o.getName())
1882                && safeSubtreeMatch(node.getQualifier(), o.getQualifier()));
1883    }
1884
1885    /**
1886     * Returns whether the given node and the other object match.
1887     * <p>
1888     * The default implementation provided by this class tests whether the
1889     * other object is a node of the same type with structurally isomorphic
1890     * child subtrees. Subclasses may override this method as needed.
1891     * </p>
1892     * 
1893     * @param node the node
1894     * @param other the other object, or <code>null</code>
1895     * @return <code>true</code> if the subtree matches, or 
1896     *   <code>false</code> if they do not match or the other object has a
1897     *   different node type or is <code>null</code>
1898     */
1899    public boolean match(SuperMethodInvocation node, Object   other) {
1900        if (!(other instanceof SuperMethodInvocation)) {
1901            return false;
1902        }
1903        SuperMethodInvocation o = (SuperMethodInvocation) other;
1904        if (node.getAST().apiLevel >= AST.JLS3) {
1905            if (!safeSubtreeListMatch(node.typeArguments(), o.typeArguments())) {
1906                return false;
1907            }
1908        }
1909        return (
1910            safeSubtreeMatch(node.getQualifier(), o.getQualifier())
1911                && safeSubtreeMatch(node.getName(), o.getName())
1912                && safeSubtreeListMatch(node.arguments(), o.arguments()));
1913    }
1914
1915    /**
1916     * Returns whether the given node and the other object match.
1917     * <p>
1918     * The default implementation provided by this class tests whether the
1919     * other object is a node of the same type with structurally isomorphic
1920     * child subtrees. Subclasses may override this method as needed.
1921     * </p>
1922     * 
1923     * @param node the node
1924     * @param other the other object, or <code>null</code>
1925     * @return <code>true</code> if the subtree matches, or 
1926     *   <code>false</code> if they do not match or the other object has a
1927     *   different node type or is <code>null</code>
1928     */
1929    public boolean match(SwitchCase node, Object   other) {
1930        if (!(other instanceof SwitchCase)) {
1931            return false;
1932        }
1933        SwitchCase o = (SwitchCase) other;
1934        return safeSubtreeMatch(node.getExpression(), o.getExpression());
1935    }
1936
1937    /**
1938     * Returns whether the given node and the other object match.
1939     * <p>
1940     * The default implementation provided by this class tests whether the
1941     * other object is a node of the same type with structurally isomorphic
1942     * child subtrees. Subclasses may override this method as needed.
1943     * </p>
1944     * 
1945     * @param node the node
1946     * @param other the other object, or <code>null</code>
1947     * @return <code>true</code> if the subtree matches, or 
1948     *   <code>false</code> if they do not match or the other object has a
1949     *   different node type or is <code>null</code>
1950     */
1951    public boolean match(SwitchStatement node, Object   other) {
1952        if (!(other instanceof SwitchStatement)) {
1953            return false;
1954        }
1955        SwitchStatement o = (SwitchStatement) other;
1956        return (
1957            safeSubtreeMatch(node.getExpression(), o.getExpression())
1958                && safeSubtreeListMatch(node.statements(), o.statements()));
1959    }
1960
1961    /**
1962     * Returns whether the given node and the other object match.
1963     * <p>
1964     * The default implementation provided by this class tests whether the
1965     * other object is a node of the same type with structurally isomorphic
1966     * child subtrees. Subclasses may override this method as needed.
1967     * </p>
1968     * 
1969     * @param node the node
1970     * @param other the other object, or <code>null</code>
1971     * @return <code>true</code> if the subtree matches, or 
1972     *   <code>false</code> if they do not match or the other object has a
1973     *   different node type or is <code>null</code>
1974     */
1975    public boolean match(SynchronizedStatement node, Object   other) {
1976        if (!(other instanceof SynchronizedStatement)) {
1977            return false;
1978        }
1979        SynchronizedStatement o = (SynchronizedStatement) other;
1980        return (
1981            safeSubtreeMatch(node.getExpression(), o.getExpression())
1982                && safeSubtreeMatch(node.getBody(), o.getBody()));
1983    }
1984
1985    /**
1986     * Returns whether the given node and the other object match.
1987     * <p>
1988     * The default implementation provided by this class tests whether the
1989     * other object is a node of the same type with structurally isomorphic
1990     * child subtrees. Subclasses may override this method as needed.
1991     * </p>
1992     * 
1993     * @param node the node
1994     * @param other the other object, or <code>null</code>
1995     * @return <code>true</code> if the subtree matches, or 
1996     *   <code>false</code> if they do not match or the other object has a
1997     *   different node type or is <code>null</code>
1998     * @since 3.0
1999     */
2000    public boolean match(TagElement node, Object   other) {
2001        if (!(other instanceof TagElement)) {
2002            return false;
2003        }
2004        TagElement o = (TagElement) other;
2005        return (
2006                safeEquals(node.getTagName(), o.getTagName())
2007                && safeSubtreeListMatch(node.fragments(), o.fragments()));
2008    }
2009
2010    /**
2011     * Returns whether the given node and the other object match.
2012     * <p>
2013     * The default implementation provided by this class tests whether the
2014     * other object is a node of the same type with structurally isomorphic
2015     * child subtrees. Subclasses may override this method as needed.
2016     * </p>
2017     * 
2018     * @param node the node
2019     * @param other the other object, or <code>null</code>
2020     * @return <code>true</code> if the subtree matches, or 
2021     *   <code>false</code> if they do not match or the other object has a
2022     *   different node type or is <code>null</code>
2023     * @since 3.0
2024     */
2025    public boolean match(TextElement node, Object   other) {
2026        if (!(other instanceof TextElement)) {
2027            return false;
2028        }
2029        TextElement o = (TextElement) other;
2030        return safeEquals(node.getText(), o.getText());
2031    }
2032
2033    /**
2034     * Returns whether the given node and the other object match.
2035     * <p>
2036     * The default implementation provided by this class tests whether the
2037     * other object is a node of the same type with structurally isomorphic
2038     * child subtrees. Subclasses may override this method as needed.
2039     * </p>
2040     * 
2041     * @param node the node
2042     * @param other the other object, or <code>null</code>
2043     * @return <code>true</code> if the subtree matches, or 
2044     *   <code>false</code> if they do not match or the other object has a
2045     *   different node type or is <code>null</code>
2046     */
2047    public boolean match(ThisExpression node, Object   other) {
2048        if (!(other instanceof ThisExpression)) {
2049            return false;
2050        }
2051        ThisExpression o = (ThisExpression) other;
2052        return safeSubtreeMatch(node.getQualifier(), o.getQualifier());
2053    }
2054
2055    /**
2056     * Returns whether the given node and the other object match.
2057     * <p>
2058     * The default implementation provided by this class tests whether the
2059     * other object is a node of the same type with structurally isomorphic
2060     * child subtrees. Subclasses may override this method as needed.
2061     * </p>
2062     * 
2063     * @param node the node
2064     * @param other the other object, or <code>null</code>
2065     * @return <code>true</code> if the subtree matches, or 
2066     *   <code>false</code> if they do not match or the other object has a
2067     *   different node type or is <code>null</code>
2068     */
2069    public boolean match(ThrowStatement node, Object   other) {
2070        if (!(other instanceof ThrowStatement)) {
2071            return false;
2072        }
2073        ThrowStatement o = (ThrowStatement) other;
2074        return safeSubtreeMatch(node.getExpression(), o.getExpression());
2075    }
2076
2077    /**
2078     * Returns whether the given node and the other object match.
2079     * <p>
2080     * The default implementation provided by this class tests whether the
2081     * other object is a node of the same type with structurally isomorphic
2082     * child subtrees. Subclasses may override this method as needed.
2083     * </p>
2084     * 
2085     * @param node the node
2086     * @param other the other object, or <code>null</code>
2087     * @return <code>true</code> if the subtree matches, or 
2088     *   <code>false</code> if they do not match or the other object has a
2089     *   different node type or is <code>null</code>
2090     */
2091    public boolean match(TryStatement node, Object   other) {
2092        if (!(other instanceof TryStatement)) {
2093            return false;
2094        }
2095        TryStatement o = (TryStatement) other;
2096        return (
2097            safeSubtreeMatch(node.getBody(), o.getBody())
2098                && safeSubtreeListMatch(node.catchClauses(), o.catchClauses())
2099                && safeSubtreeMatch(node.getFinally(), o.getFinally()));
2100    }
2101
2102    /**
2103     * Returns whether the given node and the other object match.
2104     * <p>
2105     * The default implementation provided by this class tests whether the
2106     * other object is a node of the same type with structurally isomorphic
2107     * child subtrees. Subclasses may override this method as needed.
2108     * </p>
2109     * 
2110     * @param node the node
2111     * @param other the other object, or <code>null</code>
2112     * @return <code>true</code> if the subtree matches, or 
2113     *   <code>false</code> if they do not match or the other object has a
2114     *   different node type or is <code>null</code>
2115     */
2116    public boolean match(TypeDeclaration node, Object   other) {
2117        if (!(other instanceof TypeDeclaration)) {
2118            return false;
2119        }
2120        TypeDeclaration o = (TypeDeclaration) other;
2121        int level = node.getAST().apiLevel;
2122        if (level == AST.JLS2_INTERNAL) {
2123            if (node.getModifiers() != o.getModifiers()) {
2124                return false;
2125            }
2126            if (!safeSubtreeMatch(node.internalGetSuperclass(), o.internalGetSuperclass())) {
2127                return false;
2128            }
2129            if (!safeSubtreeListMatch(node.internalSuperInterfaces(), o.internalSuperInterfaces())) {
2130                return false;
2131            }
2132        }
2133        if (level >= AST.JLS3) {
2134            if (!safeSubtreeListMatch(node.modifiers(), o.modifiers())) {
2135                return false;
2136            }
2137            if (!safeSubtreeListMatch(node.typeParameters(), o.typeParameters())) {
2138                return false;
2139            }
2140            if (!safeSubtreeMatch(node.getSuperclassType(), o.getSuperclassType())) {
2141                return false;
2142            }
2143            if (!safeSubtreeListMatch(node.superInterfaceTypes(), o.superInterfaceTypes())) {
2144                return false;
2145            }
2146        }
2147        return (
2148                (node.isInterface() == o.isInterface())
2149                && safeSubtreeMatch(node.getJavadoc(), o.getJavadoc())
2150                && safeSubtreeMatch(node.getName(), o.getName())
2151                && safeSubtreeListMatch(node.bodyDeclarations(), o.bodyDeclarations()));
2152    }
2153
2154    /**
2155     * Returns whether the given node and the other object match.
2156     * <p>
2157     * The default implementation provided by this class tests whether the
2158     * other object is a node of the same type with structurally isomorphic
2159     * child subtrees. Subclasses may override this method as needed.
2160     * </p>
2161     * 
2162     * @param node the node
2163     * @param other the other object, or <code>null</code>
2164     * @return <code>true</code> if the subtree matches, or 
2165     *   <code>false</code> if they do not match or the other object has a
2166     *   different node type or is <code>null</code>
2167     */
2168    public boolean match(TypeDeclarationStatement node, Object   other) {
2169        if (!(other instanceof TypeDeclarationStatement)) {
2170            return false;
2171        }
2172        TypeDeclarationStatement o = (TypeDeclarationStatement) other;
2173        return safeSubtreeMatch(node.getDeclaration(), o.getDeclaration());
2174    }
2175
2176    /**
2177     * Returns whether the given node and the other object match.
2178     * <p>
2179     * The default implementation provided by this class tests whether the
2180     * other object is a node of the same type with structurally isomorphic
2181     * child subtrees. Subclasses may override this method as needed.
2182     * </p>
2183     * 
2184     * @param node the node
2185     * @param other the other object, or <code>null</code>
2186     * @return <code>true</code> if the subtree matches, or 
2187     *   <code>false</code> if they do not match or the other object has a
2188     *   different node type or is <code>null</code>
2189     */
2190    public boolean match(TypeLiteral node, Object   other) {
2191        if (!(other instanceof TypeLiteral)) {
2192            return false;
2193        }
2194        TypeLiteral o = (TypeLiteral) other;
2195        return safeSubtreeMatch(node.getType(), o.getType());
2196    }
2197
2198    /**
2199     * Returns whether the given node and the other object match.
2200     * <p>
2201     * The default implementation provided by this class tests whether the
2202     * other object is a node of the same type with structurally isomorphic
2203     * child subtrees. Subclasses may override this method as needed.
2204     * </p>
2205     * 
2206     * @param node the node
2207     * @param other the other object, or <code>null</code>
2208     * @return <code>true</code> if the subtree matches, or 
2209     *   <code>false</code> if they do not match or the other object has a
2210     *   different node type or is <code>null</code>
2211     * @since 3.1
2212     */
2213    public boolean match(TypeParameter node, Object   other) {
2214        if (!(other instanceof TypeParameter)) {
2215            return false;
2216        }
2217        TypeParameter o = (TypeParameter) other;
2218        return safeSubtreeMatch(node.getName(), o.getName())
2219                && safeSubtreeListMatch(node.typeBounds(), o.typeBounds());
2220    }
2221
2222    /**
2223     * Returns whether the given node and the other object match.
2224     * <p>
2225     * The default implementation provided by this class tests whether the
2226     * other object is a node of the same type with structurally isomorphic
2227     * child subtrees. Subclasses may override this method as needed.
2228     * </p>
2229     * 
2230     * @param node the node
2231     * @param other the other object, or <code>null</code>
2232     * @return <code>true</code> if the subtree matches, or 
2233     *   <code>false</code> if they do not match or the other object has a
2234     *   different node type or is <code>null</code>
2235     */
2236    public boolean match(VariableDeclarationExpression node, Object   other) {
2237        if (!(other instanceof VariableDeclarationExpression)) {
2238            return false;
2239        }
2240        VariableDeclarationExpression o = (VariableDeclarationExpression) other;
2241        int level = node.getAST().apiLevel;
2242        if (level == AST.JLS2_INTERNAL) {
2243            if (node.getModifiers() != o.getModifiers()) {
2244                return false;
2245            }
2246        }
2247        if (level >= AST.JLS3) {
2248            if (!safeSubtreeListMatch(node.modifiers(), o.modifiers())) {
2249                return false;
2250            }
2251        }
2252        return safeSubtreeMatch(node.getType(), o.getType())
2253            && safeSubtreeListMatch(node.fragments(), o.fragments());
2254    }
2255
2256    /**
2257     * Returns whether the given node and the other object match.
2258     * <p>
2259     * The default implementation provided by this class tests whether the
2260     * other object is a node of the same type with structurally isomorphic
2261     * child subtrees. Subclasses may override this method as needed.
2262     * </p>
2263     * <p>
2264     * Note that extra array dimensions are compared since they are an
2265     * important part of the type of the variable.
2266     * </p>
2267     * 
2268     * @param node the node
2269     * @param other the other object, or <code>null</code>
2270     * @return <code>true</code> if the subtree matches, or 
2271     *   <code>false</code> if they do not match or the other object has a
2272     *   different node type or is <code>null</code>
2273     */
2274    public boolean match(VariableDeclarationFragment node, Object   other) {
2275        if (!(other instanceof VariableDeclarationFragment)) {
2276            return false;
2277        }
2278        VariableDeclarationFragment o = (VariableDeclarationFragment) other;
2279        return safeSubtreeMatch(node.getName(), o.getName())
2280            && node.getExtraDimensions() == o.getExtraDimensions()
2281            && safeSubtreeMatch(node.getInitializer(), o.getInitializer());
2282    }
2283
2284    /**
2285     * Returns whether the given node and the other object match.
2286     * <p>
2287     * The default implementation provided by this class tests whether the
2288     * other object is a node of the same type with structurally isomorphic
2289     * child subtrees. Subclasses may override this method as needed.
2290     * </p>
2291     * 
2292     * @param node the node
2293     * @param other the other object, or <code>null</code>
2294     * @return <code>true</code> if the subtree matches, or 
2295     *   <code>false</code> if they do not match or the other object has a
2296     *   different node type or is <code>null</code>
2297     */
2298    public boolean match(VariableDeclarationStatement node, Object   other) {
2299        if (!(other instanceof VariableDeclarationStatement)) {
2300            return false;
2301        }
2302        VariableDeclarationStatement o = (VariableDeclarationStatement) other;
2303        int level = node.getAST().apiLevel;
2304        if (level == AST.JLS2_INTERNAL) {
2305            if (node.getModifiers() != o.getModifiers()) {
2306                return false;
2307            }
2308        }
2309        if (level >= AST.JLS3) {
2310            if (!safeSubtreeListMatch(node.modifiers(), o.modifiers())) {
2311                return false;
2312            }
2313        }
2314        return safeSubtreeMatch(node.getType(), o.getType())
2315            && safeSubtreeListMatch(node.fragments(), o.fragments());
2316    }
2317
2318    /**
2319     * Returns whether the given node and the other object match.
2320     * <p>
2321     * The default implementation provided by this class tests whether the
2322     * other object is a node of the same type with structurally isomorphic
2323     * child subtrees. Subclasses may override this method as needed.
2324     * </p>
2325     * 
2326     * @param node the node
2327     * @param other the other object, or <code>null</code>
2328     * @return <code>true</code> if the subtree matches, or 
2329     *   <code>false</code> if they do not match or the other object has a
2330     *   different node type or is <code>null</code>
2331     */
2332    public boolean match(WhileStatement node, Object   other) {
2333        if (!(other instanceof WhileStatement)) {
2334            return false;
2335        }
2336        WhileStatement o = (WhileStatement) other;
2337        return (
2338            safeSubtreeMatch(node.getExpression(), o.getExpression())
2339                && safeSubtreeMatch(node.getBody(), o.getBody()));
2340    }
2341
2342    /**
2343     * Returns whether the given node and the other object match.
2344     * <p>
2345     * The default implementation provided by this class tests whether the
2346     * other object is a node of the same type with structurally isomorphic
2347     * child subtrees. Subclasses may override this method as needed.
2348     * </p>
2349     * 
2350     * @param node the node
2351     * @param other the other object, or <code>null</code>
2352     * @return <code>true</code> if the subtree matches, or 
2353     *   <code>false</code> if they do not match or the other object has a
2354     *   different node type or is <code>null</code>
2355     * @since 3.1
2356     */
2357    public boolean match(WildcardType node, Object   other) {
2358        if (!(other instanceof WildcardType)) {
2359            return false;
2360        }
2361        WildcardType o = (WildcardType) other;
2362        return node.isUpperBound() == o.isUpperBound()
2363        && safeSubtreeMatch(node.getBound(), o.getBound());
2364    }
2365    
2366}
2367
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags