1 /*
   2  * Copyright (c) 2001, 2006, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.javac.tree;
  27 
  28 import com.sun.tools.javac.util.*;
  29 import com.sun.tools.javac.tree.JCTree.*;
  30 
  31 /** A subclass of Tree.Visitor, this class defines
  32  *  a general tree scanner pattern. Translation proceeds recursively in
  33  *  left-to-right order down a tree. There is one visitor method in this class
  34  *  for every possible kind of tree node.  To obtain a specific
  35  *  scanner, it suffices to override those visitor methods which
  36  *  do some interesting work. The scanner class itself takes care of all
  37  *  navigational aspects.
  38  *
  39  *  <p><b>This is NOT part of any supported API.
  40  *  If you write code that depends on this, you do so at your own risk.
  41  *  This code and its internal interfaces are subject to change or
  42  *  deletion without notice.</b>
  43  */
  44 public class TreeScanner extends Visitor {
  45 
  46     /** Visitor method: Scan a single node.
  47      */
  48     public void scan(JCTree tree) {
  49         if(tree!=null) tree.accept(this);
  50     }
  51 
  52     /** Visitor method: scan a list of nodes.
  53      */
  54     public void scan(List<? extends JCTree> trees) {
  55         if (trees != null)
  56         for (List<? extends JCTree> l = trees; l.nonEmpty(); l = l.tail)
  57             scan(l.head);
  58     }
  59 
  60 
  61 /* ***************************************************************************
  62  * Visitor methods
  63  ****************************************************************************/
  64 
  65     public void visitTopLevel(JCCompilationUnit tree) {
  66         scan(tree.packageAnnotations);
  67         scan(tree.pid);
  68         scan(tree.defs);
  69     }
  70 
  71     public void visitImport(JCImport tree) {
  72         scan(tree.qualid);
  73     }
  74 
  75     public void visitClassDef(JCClassDecl tree) {
  76         scan(tree.mods);
  77         scan(tree.typarams);
  78         scan(tree.extending);
  79         scan(tree.implementing);
  80         scan(tree.defs);
  81     }
  82 
  83     public void visitMethodDef(JCMethodDecl tree) {
  84         scan(tree.mods);
  85         scan(tree.restype);
  86         scan(tree.typarams);
  87         scan(tree.params);
  88         scan(tree.receiverAnnotations);
  89         scan(tree.thrown);
  90         scan(tree.defaultValue);
  91         scan(tree.body);
  92     }
  93 
  94     public void visitVarDef(JCVariableDecl tree) {
  95         scan(tree.mods);
  96         scan(tree.vartype);
  97         scan(tree.init);
  98     }
  99 
 100     public void visitSkip(JCSkip tree) {
 101     }
 102 
 103     public void visitBlock(JCBlock tree) {
 104         scan(tree.stats);
 105     }
 106 
 107     public void visitDoLoop(JCDoWhileLoop tree) {
 108         scan(tree.body);
 109         scan(tree.cond);
 110     }
 111 
 112     public void visitWhileLoop(JCWhileLoop tree) {
 113         scan(tree.cond);
 114         scan(tree.body);
 115     }
 116 
 117     public void visitForLoop(JCForLoop tree) {
 118         scan(tree.init);
 119         scan(tree.cond);
 120         scan(tree.step);
 121         scan(tree.body);
 122     }
 123 
 124     public void visitForeachLoop(JCEnhancedForLoop tree) {
 125         scan(tree.var);
 126         scan(tree.expr);
 127         scan(tree.body);
 128     }
 129 
 130     public void visitLabelled(JCLabeledStatement tree) {
 131         scan(tree.body);
 132     }
 133 
 134     public void visitSwitch(JCSwitch tree) {
 135         scan(tree.selector);
 136         scan(tree.cases);
 137     }
 138 
 139     public void visitCase(JCCase tree) {
 140         scan(tree.pat);
 141         scan(tree.stats);
 142     }
 143 
 144     public void visitSynchronized(JCSynchronized tree) {
 145         scan(tree.lock);
 146         scan(tree.body);
 147     }
 148 
 149     public void visitTry(JCTry tree) {
 150         scan(tree.resources);
 151         scan(tree.body);
 152         scan(tree.catchers);
 153         scan(tree.finalizer);
 154     }
 155 
 156     public void visitCatch(JCCatch tree) {
 157         scan(tree.param);
 158         scan(tree.body);
 159     }
 160 
 161     public void visitConditional(JCConditional tree) {
 162         scan(tree.cond);
 163         scan(tree.truepart);
 164         scan(tree.falsepart);
 165     }
 166 
 167     public void visitIf(JCIf tree) {
 168         scan(tree.cond);
 169         scan(tree.thenpart);
 170         scan(tree.elsepart);
 171     }
 172 
 173     public void visitExec(JCExpressionStatement tree) {
 174         scan(tree.expr);
 175     }
 176 
 177     public void visitBreak(JCBreak tree) {
 178     }
 179 
 180     public void visitContinue(JCContinue tree) {
 181     }
 182 
 183     public void visitReturn(JCReturn tree) {
 184         scan(tree.expr);
 185     }
 186 
 187     public void visitThrow(JCThrow tree) {
 188         scan(tree.expr);
 189     }
 190 
 191     public void visitAssert(JCAssert tree) {
 192         scan(tree.cond);
 193         scan(tree.detail);
 194     }
 195 
 196     public void visitApply(JCMethodInvocation tree) {
 197         scan(tree.typeargs);
 198         scan(tree.meth);
 199         scan(tree.args);
 200     }
 201 
 202     public void visitNewClass(JCNewClass tree) {
 203         scan(tree.encl);
 204         scan(tree.clazz);
 205         scan(tree.typeargs);
 206         scan(tree.args);
 207         scan(tree.def);
 208     }
 209 
 210     public void visitNewArray(JCNewArray tree) {
 211         scan(tree.annotations);
 212         scan(tree.elemtype);
 213         scan(tree.dims);
 214         for (List<JCTypeAnnotation> annos : tree.dimAnnotations)
 215             scan(annos);
 216         scan(tree.elems);
 217     }
 218 
 219     public void visitParens(JCParens tree) {
 220         scan(tree.expr);
 221     }
 222 
 223     public void visitAssign(JCAssign tree) {
 224         scan(tree.lhs);
 225         scan(tree.rhs);
 226     }
 227 
 228     public void visitAssignop(JCAssignOp tree) {
 229         scan(tree.lhs);
 230         scan(tree.rhs);
 231     }
 232 
 233     public void visitUnary(JCUnary tree) {
 234         scan(tree.arg);
 235     }
 236 
 237     public void visitBinary(JCBinary tree) {
 238         scan(tree.lhs);
 239         scan(tree.rhs);
 240     }
 241 
 242     public void visitTypeCast(JCTypeCast tree) {
 243         scan(tree.clazz);
 244         scan(tree.expr);
 245     }
 246 
 247     public void visitTypeTest(JCInstanceOf tree) {
 248         scan(tree.expr);
 249         scan(tree.clazz);
 250     }
 251 
 252     public void visitIndexed(JCArrayAccess tree) {
 253         scan(tree.indexed);
 254         scan(tree.index);
 255     }
 256 
 257     public void visitSelect(JCFieldAccess tree) {
 258         scan(tree.selected);
 259     }
 260 
 261     public void visitIdent(JCIdent tree) {
 262     }
 263 
 264     public void visitLiteral(JCLiteral tree) {
 265     }
 266 
 267     public void visitTypeIdent(JCPrimitiveTypeTree tree) {
 268     }
 269 
 270     public void visitTypeArray(JCArrayTypeTree tree) {
 271         scan(tree.elemtype);
 272     }
 273 
 274     public void visitTypeApply(JCTypeApply tree) {
 275         scan(tree.clazz);
 276         scan(tree.arguments);
 277     }
 278 
 279     public void visitTypeDisjoint(JCTypeDisjoint tree) {
 280         scan(tree.components);
 281     }
 282 
 283     public void visitTypeParameter(JCTypeParameter tree) {
 284         scan(tree.annotations);
 285         scan(tree.bounds);
 286     }
 287 
 288     @Override
 289     public void visitWildcard(JCWildcard tree) {
 290         scan(tree.kind);
 291         if (tree.inner != null)
 292             scan(tree.inner);
 293     }
 294 
 295     @Override
 296     public void visitTypeBoundKind(TypeBoundKind that) {
 297     }
 298 
 299     public void visitModifiers(JCModifiers tree) {
 300         scan(tree.annotations);
 301     }
 302 
 303     public void visitAnnotation(JCAnnotation tree) {
 304         scan(tree.annotationType);
 305         scan(tree.args);
 306     }
 307 
 308     public void visitAnnotatedType(JCAnnotatedType tree) {
 309         scan(tree.annotations);
 310         scan(tree.underlyingType);
 311     }
 312 
 313     public void visitErroneous(JCErroneous tree) {
 314     }
 315 
 316     public void visitLetExpr(LetExpr tree) {
 317         scan(tree.defs);
 318         scan(tree.expr);
 319     }
 320 
 321     public void visitTree(JCTree tree) {
 322         assert false;
 323     }
 324 }