1 /*
   2  * Copyright (c) 2001, 2019, 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.defs);
  67     }
  68 
  69     public void visitPackageDef(JCPackageDecl tree) {
  70         scan(tree.annotations);
  71         scan(tree.pid);
  72     }
  73 
  74     @Override
  75     public void visitModuleDef(JCModuleDecl tree) {
  76         scan(tree.mods);
  77         scan(tree.qualId);
  78         scan(tree.directives);
  79     }
  80 
  81     @Override
  82     public void visitExports(JCExports tree) {
  83         scan(tree.qualid);
  84         scan(tree.moduleNames);
  85     }
  86 
  87     @Override
  88     public void visitOpens(JCOpens tree) {
  89         scan(tree.qualid);
  90         scan(tree.moduleNames);
  91     }
  92 
  93     @Override
  94     public void visitProvides(JCProvides tree) {
  95         scan(tree.serviceName);
  96         scan(tree.implNames);
  97     }
  98 
  99     @Override
 100     public void visitRequires(JCRequires tree) {
 101         scan(tree.moduleName);
 102     }
 103 
 104     @Override
 105     public void visitUses(JCUses tree) {
 106         scan(tree.qualid);
 107     }
 108 
 109     public void visitImport(JCImport tree) {
 110         scan(tree.qualid);
 111     }
 112 
 113     public void visitClassDef(JCClassDecl tree) {
 114         scan(tree.mods);
 115         scan(tree.typarams);
 116         scan(tree.extending);
 117         scan(tree.implementing);
 118         scan(tree.defs);
 119     }
 120 
 121     public void visitMethodDef(JCMethodDecl tree) {
 122         scan(tree.mods);
 123         scan(tree.restype);
 124         scan(tree.typarams);
 125         scan(tree.recvparam);
 126         scan(tree.params);
 127         scan(tree.thrown);
 128         scan(tree.defaultValue);
 129         scan(tree.body);
 130     }
 131 
 132     public void visitVarDef(JCVariableDecl tree) {
 133         scan(tree.mods);
 134         scan(tree.vartype);
 135         scan(tree.nameexpr);
 136         scan(tree.init);
 137     }
 138 
 139     public void visitSkip(JCSkip tree) {
 140     }
 141 
 142     public void visitBlock(JCBlock tree) {
 143         scan(tree.stats);
 144     }
 145 
 146     public void visitDoLoop(JCDoWhileLoop tree) {
 147         scan(tree.body);
 148         scan(tree.cond);
 149     }
 150 
 151     public void visitWhileLoop(JCWhileLoop tree) {
 152         scan(tree.cond);
 153         scan(tree.body);
 154     }
 155 
 156     public void visitForLoop(JCForLoop tree) {
 157         scan(tree.init);
 158         scan(tree.cond);
 159         scan(tree.step);
 160         scan(tree.body);
 161     }
 162 
 163     public void visitForeachLoop(JCEnhancedForLoop tree) {
 164         scan(tree.var);
 165         scan(tree.expr);
 166         scan(tree.body);
 167     }
 168 
 169     public void visitLabelled(JCLabeledStatement tree) {
 170         scan(tree.body);
 171     }
 172 
 173     public void visitSwitch(JCSwitch tree) {
 174         scan(tree.selector);
 175         scan(tree.cases);
 176     }
 177 
 178     public void visitCase(JCCase tree) {
 179         scan(tree.pats);
 180         scan(tree.stats);
 181     }
 182 
 183     public void visitSwitchExpression(JCSwitchExpression tree) {
 184         scan(tree.selector);
 185         scan(tree.cases);
 186     }
 187 
 188     public void visitSynchronized(JCSynchronized tree) {
 189         scan(tree.lock);
 190         scan(tree.body);
 191     }
 192 
 193     public void visitTry(JCTry tree) {
 194         scan(tree.resources);
 195         scan(tree.body);
 196         scan(tree.catchers);
 197         scan(tree.finalizer);
 198     }
 199 
 200     public void visitCatch(JCCatch tree) {
 201         scan(tree.param);
 202         scan(tree.body);
 203     }
 204 
 205     public void visitConditional(JCConditional tree) {
 206         scan(tree.cond);
 207         scan(tree.truepart);
 208         scan(tree.falsepart);
 209     }
 210 
 211     public void visitIf(JCIf tree) {
 212         scan(tree.cond);
 213         scan(tree.thenpart);
 214         scan(tree.elsepart);
 215     }
 216 
 217     public void visitExec(JCExpressionStatement tree) {
 218         scan(tree.expr);
 219     }
 220 
 221     public void visitBreak(JCBreak tree) {
 222     }
 223 
 224     public void visitYield(JCYield tree) {
 225         scan(tree.value);
 226     }
 227 
 228     public void visitContinue(JCContinue tree) {
 229     }
 230 
 231     public void visitReturn(JCReturn tree) {
 232         scan(tree.expr);
 233     }
 234 
 235     public void visitThrow(JCThrow tree) {
 236         scan(tree.expr);
 237     }
 238 
 239     public void visitAssert(JCAssert tree) {
 240         scan(tree.cond);
 241         scan(tree.detail);
 242     }
 243 
 244     public void visitApply(JCMethodInvocation tree) {
 245         scan(tree.typeargs);
 246         scan(tree.meth);
 247         scan(tree.args);
 248     }
 249 
 250     public void visitNewClass(JCNewClass tree) {
 251         scan(tree.encl);
 252         scan(tree.typeargs);
 253         scan(tree.clazz);
 254         scan(tree.args);
 255         scan(tree.def);
 256     }
 257 
 258     public void visitNewArray(JCNewArray tree) {
 259         scan(tree.annotations);
 260         scan(tree.elemtype);
 261         scan(tree.dims);
 262         for (List<JCAnnotation> annos : tree.dimAnnotations)
 263             scan(annos);
 264         scan(tree.elems);
 265     }
 266 
 267     public void visitLambda(JCLambda tree) {
 268         scan(tree.body);
 269         scan(tree.params);
 270     }
 271 
 272     public void visitParens(JCParens tree) {
 273         scan(tree.expr);
 274     }
 275 
 276     public void visitAssign(JCAssign tree) {
 277         scan(tree.lhs);
 278         scan(tree.rhs);
 279     }
 280 
 281     public void visitAssignop(JCAssignOp tree) {
 282         scan(tree.lhs);
 283         scan(tree.rhs);
 284     }
 285 
 286     public void visitUnary(JCUnary tree) {
 287         scan(tree.arg);
 288     }
 289 
 290     public void visitBinary(JCBinary tree) {
 291         scan(tree.lhs);
 292         scan(tree.rhs);
 293     }
 294 
 295     public void visitTypeCast(JCTypeCast tree) {
 296         scan(tree.clazz);
 297         scan(tree.expr);
 298     }
 299 
 300     public void visitTypeTest(JCInstanceOf tree) {
 301         scan(tree.expr);
 302         scan(tree.pattern);
 303     }
 304 
 305     public void visitBindingPattern(JCBindingPattern tree) {
 306         if (tree.vartype != null)
 307             scan(tree.vartype);
 308     }
 309 
 310     public void visitIndexed(JCArrayAccess tree) {
 311         scan(tree.indexed);
 312         scan(tree.index);
 313     }
 314 
 315     public void visitSelect(JCFieldAccess tree) {
 316         scan(tree.selected);
 317     }
 318 
 319     public void visitReference(JCMemberReference tree) {
 320         scan(tree.expr);
 321         scan(tree.typeargs);
 322     }
 323 
 324     public void visitIdent(JCIdent tree) {
 325     }
 326 
 327     public void visitLiteral(JCLiteral tree) {
 328     }
 329 
 330     public void visitTypeIdent(JCPrimitiveTypeTree tree) {
 331     }
 332 
 333     public void visitTypeArray(JCArrayTypeTree tree) {
 334         scan(tree.elemtype);
 335     }
 336 
 337     public void visitTypeApply(JCTypeApply tree) {
 338         scan(tree.clazz);
 339         scan(tree.arguments);
 340     }
 341 
 342     public void visitTypeUnion(JCTypeUnion tree) {
 343         scan(tree.alternatives);
 344     }
 345 
 346     public void visitTypeIntersection(JCTypeIntersection tree) {
 347         scan(tree.bounds);
 348     }
 349 
 350     public void visitTypeParameter(JCTypeParameter tree) {
 351         scan(tree.annotations);
 352         scan(tree.bounds);
 353     }
 354 
 355     @Override
 356     public void visitWildcard(JCWildcard tree) {
 357         scan(tree.kind);
 358         if (tree.inner != null)
 359             scan(tree.inner);
 360     }
 361 
 362     @Override
 363     public void visitTypeBoundKind(TypeBoundKind that) {
 364     }
 365 
 366     public void visitModifiers(JCModifiers tree) {
 367         scan(tree.annotations);
 368     }
 369 
 370     public void visitAnnotation(JCAnnotation tree) {
 371         scan(tree.annotationType);
 372         scan(tree.args);
 373     }
 374 
 375     public void visitAnnotatedType(JCAnnotatedType tree) {
 376         scan(tree.annotations);
 377         scan(tree.underlyingType);
 378     }
 379 
 380     public void visitErroneous(JCErroneous tree) {
 381     }
 382 
 383     public void visitLetExpr(LetExpr tree) {
 384         scan(tree.defs);
 385         scan(tree.expr);
 386     }
 387 
 388     public void visitTree(JCTree tree) {
 389         Assert.error();
 390     }
 391 }