001 /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */ 002 package org.extendj.ast; 003 004 import java.util.HashSet; 005 import java.io.File; 006 import java.util.Set; 007 import java.util.Collections; 008 import java.util.Collection; 009 import java.util.ArrayList; 010 import beaver.*; 011 import java.util.*; 012 import java.io.ByteArrayOutputStream; 013 import java.io.PrintStream; 014 import java.lang.reflect.InvocationTargetException; 015 import java.lang.reflect.Method; 016 import org.jastadd.util.*; 017 import java.util.zip.*; 018 import java.io.*; 019 import org.jastadd.util.PrettyPrintable; 020 import org.jastadd.util.PrettyPrinter; 021 import java.io.FileNotFoundException; 022 import java.io.BufferedInputStream; 023 import java.io.DataInputStream; 024 /** 025 * @ast node 026 * @production ASTNode; 027 028 */ 029 public class ASTNode<T extends ASTNode> extends beaver.Symbol implements Cloneable, PrettyPrintable, Iterable<T> { 030 /** 031 * @aspect AccessControl 032 * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:150 033 */ 034 public void accessControl() { 035 } 036 /** 037 * @aspect AnonymousClasses 038 * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:123 039 */ 040 protected void collectExceptions(Collection c, ASTNode target) { 041 for (int i = 0; i < getNumChild(); i++) { 042 getChild(i).collectExceptions(c, target); 043 } 044 } 045 /** 046 * @aspect BranchTarget 047 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:90 048 */ 049 public void collectBranches(Collection<Stmt> c) { 050 for (int i = 0; i < getNumChild(); i++) { 051 getChild(i).collectBranches(c); 052 } 053 } 054 /** 055 * @aspect DeclareBeforeUse 056 * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:42 057 */ 058 public int varChildIndex(TypeDecl t) { 059 ASTNode node = this; 060 while (node != null && node.getParent() != null && node.getParent().getParent() != t) { 061 node = node.getParent(); 062 } 063 if (node == null) { 064 return -1; 065 } 066 return t.getBodyDeclListNoTransform().getIndexOfChild(node); 067 } 068 /** 069 * @aspect DefiniteAssignment 070 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:34 071 */ 072 public void definiteAssignment() { 073 } 074 /** 075 * @aspect DA 076 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:495 077 */ 078 protected boolean checkDUeverywhere(Variable v) { 079 for (int i = 0; i < getNumChild(); i++) { 080 if (!getChild(i).checkDUeverywhere(v)) { 081 return false; 082 } 083 } 084 return true; 085 } 086 /** 087 * @aspect DA 088 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:627 089 */ 090 protected boolean isDescendantTo(ASTNode node) { 091 if (this == node) { 092 return true; 093 } 094 if (getParent() == null) { 095 return false; 096 } 097 return getParent().isDescendantTo(node); 098 } 099 /** 100 * @aspect DumpTree 101 * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:38 102 */ 103 private String DUMP_TREE_INDENT = " "; 104 /** 105 * @aspect DumpTree 106 * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:40 107 */ 108 public String dumpTree() { 109 ByteArrayOutputStream bytes = new ByteArrayOutputStream(); 110 dumpTree(new PrintStream(bytes)); 111 return bytes.toString(); 112 } 113 /** 114 * @aspect DumpTree 115 * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:46 116 */ 117 public void dumpTree(PrintStream out) { 118 dumpTree(out, ""); 119 out.flush(); 120 } 121 /** 122 * @aspect DumpTree 123 * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:51 124 */ 125 public void dumpTree(PrintStream out, String indent) { 126 out.print(indent + getClass().getSimpleName()); 127 out.println(getTokens()); 128 String childIndent = indent + DUMP_TREE_INDENT; 129 for (int i = 0; i < getNumChild(); ++i) { 130 ASTNode child = getChild(i); 131 if (child == null) { 132 out.println(childIndent + "null"); 133 } else { 134 child.dumpTree(out, childIndent); 135 } 136 } 137 } 138 /** 139 * @aspect DumpTree 140 * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:65 141 */ 142 public String getTokens() { 143 StringBuilder sb = new StringBuilder(); 144 Method[] methods = getClass().getMethods(); 145 for (Method method : getClass().getMethods()) { 146 ASTNodeAnnotation.Token token = method.getAnnotation(ASTNodeAnnotation.Token.class); 147 if (token != null) { 148 try { 149 sb.append(" " + token.name() + "=\"" + method.invoke(this) + "\""); 150 } catch (IllegalAccessException e) { 151 } catch (InvocationTargetException e) { 152 } 153 } 154 } 155 return sb.toString(); 156 } 157 /** 158 * @aspect DumpTree 159 * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:81 160 */ 161 public String dumpTreeNoRewrite() { 162 ByteArrayOutputStream bytes = new ByteArrayOutputStream(); 163 dumpTreeNoRewrite(new PrintStream(bytes)); 164 return bytes.toString(); 165 } 166 /** 167 * @aspect DumpTree 168 * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:87 169 */ 170 public void dumpTreeNoRewrite(PrintStream out) { 171 dumpTreeNoRewrite(out, ""); 172 out.flush(); 173 } 174 /** 175 * @aspect DumpTree 176 * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:92 177 */ 178 public void dumpTreeNoRewrite(PrintStream out, String indent) { 179 out.print(indent + getClass().getSimpleName()); 180 out.println(getTokens()); 181 String childIndent = indent + DUMP_TREE_INDENT; 182 for (int i = 0; i < getNumChildNoTransform(); ++i) { 183 ASTNode child = getChildNoTransform(i); 184 if (child == null) { 185 out.println(childIndent + "null"); 186 } else { 187 child.dumpTreeNoRewrite(out, childIndent); 188 } 189 } 190 } 191 /** 192 * @aspect ErrorCheck 193 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:33 194 */ 195 protected String sourceFile() { 196 ASTNode node = this; 197 while (node != null && !(node instanceof CompilationUnit)) { 198 node = node.getParent(); 199 } 200 if (node == null) { 201 return "Unknown file"; 202 } 203 CompilationUnit u = (CompilationUnit) node; 204 return u.relativeName(); 205 } 206 /** 207 * @aspect ErrorCheck 208 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:57 209 */ 210 public ASTNode setLocation(ASTNode node) { 211 setStart(node.getStart()); 212 setEnd(node.getEnd()); 213 return this; 214 } 215 /** 216 * @aspect ErrorCheck 217 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:63 218 */ 219 public ASTNode setStart(int i) { 220 start = i; 221 return this; 222 } 223 /** 224 * @aspect ErrorCheck 225 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:67 226 */ 227 public int start() { 228 return start; 229 } 230 /** 231 * @aspect ErrorCheck 232 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:70 233 */ 234 public ASTNode setEnd(int i) { 235 end = i; 236 return this; 237 } 238 /** 239 * @aspect ErrorCheck 240 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:74 241 */ 242 public int end() { 243 return end; 244 } 245 /** 246 * @aspect ErrorCheck 247 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:78 248 */ 249 public String location() { 250 return "" + lineNumber(); 251 } 252 /** 253 * @aspect ErrorCheck 254 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:81 255 */ 256 public String errorPrefix() { 257 return sourceFile() + ":" + location() + ":\n" + " *** Semantic Error: "; 258 } 259 /** 260 * @aspect ErrorCheck 261 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:84 262 */ 263 public String warningPrefix() { 264 return sourceFile() + ":" + location() + ":\n" + " *** WARNING: "; 265 } 266 /** 267 * @aspect ErrorCheck 268 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:198 269 */ 270 public void errorf(String messagefmt, Object... args) { 271 error(String.format(messagefmt, args)); 272 } 273 /** 274 * @aspect ErrorCheck 275 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:202 276 */ 277 public void error(String message) { 278 ASTNode node = this; 279 while (node != null && !(node instanceof CompilationUnit)) { 280 node = node.getParent(); 281 } 282 CompilationUnit cu = (CompilationUnit) node; 283 if (getNumChild() == 0 && getStart() != 0 && getEnd() != 0) { 284 int line = getLine(getStart()); 285 int column = getColumn(getStart()); 286 int endLine = getLine(getEnd()); 287 int endColumn = getColumn(getEnd()); 288 cu.errors.add(new Problem(sourceFile(), message, line, column, endLine, endColumn, 289 Problem.Severity.ERROR, Problem.Kind.SEMANTIC)); 290 } else { 291 cu.errors.add(new Problem(sourceFile(), message, lineNumber(), Problem.Severity.ERROR, 292 Problem.Kind.SEMANTIC)); 293 } 294 } 295 /** 296 * @aspect ErrorCheck 297 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:221 298 */ 299 public void warning(String s) { 300 ASTNode node = this; 301 while (node != null && !(node instanceof CompilationUnit)) { 302 node = node.getParent(); 303 } 304 CompilationUnit cu = (CompilationUnit) node; 305 cu.warnings.add(new Problem(sourceFile(), "WARNING: " + s, lineNumber(), Problem.Severity.WARNING)); 306 } 307 /** 308 * @aspect ExceptionHandling 309 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:87 310 */ 311 public void exceptionHandling() { 312 } 313 /** 314 * @aspect ExceptionHandling 315 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:271 316 */ 317 protected boolean reachedException(TypeDecl type) { 318 for (int i = 0; i < getNumChild(); i++) { 319 if (getChild(i).reachedException(type)) { 320 return true; 321 } 322 } 323 return false; 324 } 325 /** 326 * @aspect LookupMethod 327 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:92 328 */ 329 public static Collection removeInstanceMethods(Collection c) { 330 c = new LinkedList(c); 331 for (Iterator iter = c.iterator(); iter.hasNext(); ) { 332 MethodDecl m = (MethodDecl) iter.next(); 333 if (!m.isStatic()) { 334 iter.remove(); 335 } 336 } 337 return c; 338 } 339 /** 340 * Utility method to put a SimpleSet-item in a signature map. 341 * @aspect MemberMethods 342 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:511 343 */ 344 protected static void putSimpleSetElement(Map<String,SimpleSet> map, String key, SimpleSet value) { 345 SimpleSet set = map.get(key); 346 if (set == null) { 347 set = SimpleSet.emptySet; 348 } 349 map.put(key, set.add(value)); 350 } 351 /** 352 * @aspect VariableScope 353 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:274 354 */ 355 public SimpleSet removeInstanceVariables(SimpleSet oldSet) { 356 SimpleSet newSet = SimpleSet.emptySet; 357 for (Iterator iter = oldSet.iterator(); iter.hasNext(); ) { 358 Variable v = (Variable) iter.next(); 359 if (!v.isInstanceVariable()) { 360 newSet = newSet.add(v); 361 } 362 } 363 return newSet; 364 } 365 /** 366 * @aspect Modifiers 367 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:32 368 */ 369 void checkModifiers() { 370 } 371 /** 372 * @return a copy of the block as an NTAFinallyBlock 373 * @aspect NTAFinally 374 * @declaredat /home/jesper/git/extendj/java4/frontend/NTAFinally.jrag:35 375 */ 376 protected static NTAFinallyBlock ntaFinallyBlock(FinallyHost origin, Stmt branch, Block block) { 377 NTAFinallyBlock ntaBlock = new NTAFinallyBlock(origin); 378 ntaBlock.addStmt((Block) block.treeCopyNoTransform()); 379 /*if (!block.canCompleteNormally()) { 380 * // the target block's exit will replace our own exit code 381 * // so we can just goto that block! 382 * ntaBlock.addGoto(block); 383 * } else ... 384 */ 385 if (block.canCompleteNormally()) { 386 FinallyHost enclosing = block.enclosingFinally(branch); 387 if (enclosing != null) { 388 ntaBlock.addStmt(ntaFinallyBlock(enclosing, branch, enclosing.getFinallyBlock())); 389 } 390 } 391 return ntaBlock; 392 } 393 /** 394 * @aspect NameCheck 395 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:33 396 */ 397 public void nameCheck() { 398 } 399 /** 400 * @aspect NameCheck 401 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:36 402 */ 403 public TypeDecl extractSingleType(SimpleSet c) { 404 if (c.size() != 1) { 405 return null; 406 } 407 return (TypeDecl) c.iterator().next(); 408 } 409 /** 410 * Pretty-print this ASTNode. 411 * @return pretty-printed representation of this AST node 412 * @aspect PrettyPrintUtil 413 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:41 414 */ 415 public String prettyPrint() { 416 ByteArrayOutputStream buf = new ByteArrayOutputStream(); 417 prettyPrint(new PrettyPrinter(" ", new PrintStream(buf))); 418 return buf.toString(); 419 } 420 /** 421 * Pretty print this AST node to the target PrintStream. 422 * @param out target for pretty printing 423 * @aspect PrettyPrintUtil 424 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:51 425 */ 426 public void prettyPrint(PrintStream out) { 427 prettyPrint(new PrettyPrinter(" ", out)); 428 } 429 /** 430 * @return the name of the class implementing this AST node 431 * @aspect PrettyPrintUtil 432 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:58 433 */ 434 public String toString() { 435 return getClass().getName(); 436 } 437 /** 438 * @aspect PrettyPrintUtil 439 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:62 440 */ 441 public void prettyPrint(PrettyPrinter out) { 442 } 443 /** 444 * @aspect PrimitiveTypes 445 * @declaredat /home/jesper/git/extendj/java4/frontend/PrimitiveTypes.jrag:32 446 */ 447 protected static final String PRIMITIVE_PACKAGE_NAME = "@primitive"; 448 /** 449 * @aspect StructuredPrettyPrint 450 * @declaredat /home/jesper/git/extendj/java4/frontend/StructuredPrettyPrint.jadd:32 451 */ 452 public String structuredPrettyPrint() throws IOException { 453 ByteArrayOutputStream out = new ByteArrayOutputStream(); 454 // First, transform the tree by wrapping all expressions in ParExpr. 455 wrapExprs(); 456 prettyPrint(new PrintStream(out, false, "UTF8")); 457 return out.toString().trim(); 458 } 459 /** 460 * Hacky way of inserting parens around all expressions. 461 * @aspect StructuredPrettyPrint 462 * @declaredat /home/jesper/git/extendj/java4/frontend/StructuredPrettyPrint.jadd:43 463 */ 464 private void wrapExprs() { 465 for (int i = 0; i < getNumChildNoTransform(); ++i) { 466 ASTNode child = getChildNoTransform(i); 467 if (child instanceof Expr && 468 !(child instanceof ParExpr) && 469 !(child instanceof Access) && 470 !(child instanceof Literal)) { 471 child.setParent(null); 472 ParExpr parExpr = new ParExpr((Expr) child); 473 setChild(parExpr, i); 474 } 475 child.wrapExprs(); 476 } 477 } 478 /** 479 * @aspect TypeCheck 480 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:33 481 */ 482 public void typeCheck() { 483 } 484 /** 485 * @aspect UnreachableStatements 486 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:33 487 */ 488 void checkUnreachableStmt() { 489 } 490 /** 491 * @aspect VariableDeclarationTransformation 492 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:154 493 */ 494 public void clearLocations() { 495 setStart(0); 496 setEnd(0); 497 for (int i = 0; i < getNumChildNoTransform(); i++) { 498 getChildNoTransform(i).clearLocations(); 499 } 500 } 501 /** 502 * @aspect CodeGeneration 503 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:33 504 */ 505 public void setSourceLineNumber(int i) { 506 setStart(ASTNode.makePosition(i, 1)); 507 } 508 /** 509 * @aspect CodeGeneration 510 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:54 511 */ 512 protected int findFirstSourceLineNumber() { 513 if (getStart() != 0) { 514 return getLine(getStart()); 515 } 516 for (int i = 0; i < getNumChild(); i++) { 517 int num = getChild(i).findFirstSourceLineNumber(); 518 if (num != -1) { 519 return num; 520 } 521 } 522 return -1; 523 } 524 /** 525 * @aspect CodeGeneration 526 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:213 527 */ 528 public void error() { 529 Throwable t = new Throwable(); 530 StackTraceElement[] ste = new Throwable().getStackTrace(); 531 String s = ste[1].toString(); 532 throw new Error(s+" Cannot create bytecode for:"+getClass().getName()); 533 } 534 /** 535 * @aspect CreateBCode 536 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:232 537 */ 538 public void createBCode(CodeGeneration gen) { 539 for (int i=0; i<getNumChild(); i++) { 540 getChild(i).createBCode(gen); 541 } 542 } 543 /** 544 * @aspect FlushCaches 545 * @declaredat /home/jesper/git/extendj/java4/backend/FlushCaches.jrag:33 546 */ 547 public void flushCaches() { 548 flushCache(); 549 for (int i = 0; i < getNumChild(); i++) { 550 getChild(i).flushCaches(); 551 } 552 } 553 /** 554 * @aspect GenerateClassfile 555 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:355 556 */ 557 public boolean clear() { 558 boolean empty = true; 559 for (int i = 0; i < getNumChild(); i++) { 560 ASTNode child = getChild(i); 561 if (!child.clear()) { 562 empty = false; 563 } else { 564 if (child instanceof List) { 565 ((ASTNode) this).setChild(new List(), i); 566 } else if (child instanceof Opt) { 567 ((ASTNode) this).setChild(new Opt(), i); 568 } 569 //setChild(null, i); 570 } 571 } 572 if (empty) { 573 setParent(null); 574 } 575 if (flush()) { 576 flushCache(); 577 } 578 return empty; 579 } 580 /** 581 * @aspect InnerClasses 582 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:192 583 */ 584 public void collectEnclosingVariables(HashSet set, TypeDecl typeDecl) { 585 for (int i = 0; i < getNumChild(); i++) { 586 getChild(i).collectEnclosingVariables(set, typeDecl); 587 } 588 } 589 /** 590 * @aspect Transformations 591 * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:33 592 */ 593 public void transformation() { 594 for (int i = 0; i < getNumChild(); i++) { 595 getChild(i).transformation(); 596 } 597 } 598 /** Imperative transformation of the AST 599 * This should be removed. 600 * 601 * Usage: this.replaceWith(replacement) 602 * 603 * @param replacement node to replace this node with 604 * @return the new node 605 * @deprecated 606 * @aspect Transformations 607 * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:210 608 */ 609 @Deprecated 610 protected void replaceWith(ASTNode replacement) { 611 int replacePos = getParent().getIndexOfChild(this); 612 getParent().setChild(replacement, replacePos); 613 } 614 /** 615 * @aspect Enums 616 * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:159 617 */ 618 protected void transformEnumConstructors() { 619 for (int i = 0; i < getNumChildNoTransform(); i++) { 620 ASTNode child = getChildNoTransform(i); 621 if (child != null) { 622 child.transformEnumConstructors(); 623 } 624 } 625 } 626 /** 627 * @aspect Enums 628 * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:490 629 */ 630 protected void checkEnum(EnumDecl enumDecl) { 631 for (int i = 0; i < getNumChild(); i++) { 632 getChild(i).checkEnum(enumDecl); 633 } 634 } 635 /** 636 * Finds one method with the given name, and no parameters, in the specified 637 * type. 638 * @param type type to search for the method declaration 639 * @param name name of the method 640 * @return method declaration 641 * @aspect EnhancedForToBytecode 642 * @declaredat /home/jesper/git/extendj/java5/backend/EnhancedForCodegen.jrag:110 643 */ 644 protected static MethodDecl getMethod(TypeDecl type, String name) { 645 Collection<MethodDecl> methods = (Collection<MethodDecl>) type.memberMethods(name); 646 for (MethodDecl method: methods) { 647 if (method.getNumParameter() == 0) { 648 return method; 649 } 650 } 651 throw new Error("Could not find " + type.typeName() + 652 "." + name + "()"); 653 } 654 /** 655 * @aspect UncheckedConversion 656 * @declaredat /home/jesper/git/extendj/java7/frontend/UncheckedConversion.jrag:65 657 */ 658 public void checkUncheckedConversion(TypeDecl source, TypeDecl dest) { 659 if (source.isUncheckedConversionTo(dest)) { 660 warning("unchecked conversion from raw type " + source.typeName() 661 + " to generic type " + dest.typeName()); 662 } 663 } 664 /** 665 * Checking of the SafeVarargs annotation is only needed for method 666 * declarations. 667 * @aspect Warnings 668 * @declaredat /home/jesper/git/extendj/java7/frontend/Warnings.jadd:60 669 */ 670 public void checkWarnings() { 671 } 672 /** 673 * @declaredat ASTNode:1 674 */ 675 public ASTNode() { 676 super(); 677 init$Children(); 678 } 679 /** 680 * Initializes the child array to the correct size. 681 * Initializes List and Opt nta children. 682 * @apilevel internal 683 * @ast method 684 * @declaredat ASTNode:11 685 */ 686 public void init$Children() { 687 } 688 /** 689 * @apilevel internal 690 * @declaredat ASTNode:16 691 */ 692 private int childIndex; 693 /** 694 * @apilevel low-level 695 * @declaredat ASTNode:21 696 */ 697 public int getIndexOfChild(ASTNode node) { 698 if (node == null) { 699 return -1; 700 } 701 if (node.childIndex < numChildren && node == children[node.childIndex]) { 702 return node.childIndex; 703 } 704 for(int i = 0; children != null && i < children.length; i++) { 705 if (children[i] == node) { 706 node.childIndex = i; 707 return i; 708 } 709 } 710 return -1; 711 } 712 /** 713 * @apilevel internal 714 * @declaredat ASTNode:40 715 */ 716 public static final boolean generatedWithCacheCycle = false; 717 /** 718 * @apilevel internal 719 * @declaredat ASTNode:44 720 */ 721 public static final boolean generatedWithComponentCheck = false; 722 /** 723 * Parent pointer 724 * @apilevel low-level 725 * @declaredat ASTNode:50 726 */ 727 protected ASTNode parent; 728 /** 729 * Child array 730 * @apilevel low-level 731 * @declaredat ASTNode:56 732 */ 733 protected ASTNode[] children; 734 /** 735 * @apilevel internal 736 * @declaredat ASTNode:62 737 */ 738 private static ASTNode$State state = new ASTNode$State(); 739 /** 740 * @apilevel internal 741 * @declaredat ASTNode:67 742 */ 743 public final ASTNode$State state() { 744 return state; 745 } 746 /** 747 * @apilevel internal 748 * @declaredat ASTNode:74 749 */ 750 public boolean in$Circle = false; 751 /** 752 * @apilevel internal 753 * @declaredat ASTNode:79 754 */ 755 public boolean in$Circle() { 756 return in$Circle; 757 } 758 /** 759 * @apilevel internal 760 * @declaredat ASTNode:86 761 */ 762 public void in$Circle(boolean b) { 763 in$Circle = b; 764 } 765 /** 766 * @apilevel internal 767 * @declaredat ASTNode:93 768 */ 769 public boolean is$Final = false; 770 /** 771 * @apilevel internal 772 * @declaredat ASTNode:97 773 */ 774 public boolean is$Final() { return is$Final; } 775 /** 776 * @apilevel internal 777 * @declaredat ASTNode:101 778 */ 779 public void is$Final(boolean b) { is$Final = b; } 780 /** 781 * @apilevel low-level 782 * @declaredat ASTNode:106 783 */ 784 public T getChild(int i) { 785 786 ASTNode node = this.getChildNoTransform(i); 787 if (node == null) { 788 return null; 789 } 790 if (node.is$Final()) { 791 return (T) node; 792 } 793 if (!node.mayHaveRewrite()) { 794 node.is$Final(this.is$Final()); 795 return (T) node; 796 } 797 if (!node.in$Circle()) { 798 int rewriteState; 799 int num = state().boundariesCrossed; 800 do { 801 state().push(ASTNode$State.REWRITE_CHANGE); 802 ASTNode oldNode = node; 803 oldNode.in$Circle(true); 804 node = node.rewriteTo(); 805 if (node != oldNode) { 806 this.setChild(node, i); 807 } 808 oldNode.in$Circle(false); 809 rewriteState = state().pop(); 810 } while(rewriteState == ASTNode$State.REWRITE_CHANGE); 811 if (rewriteState == ASTNode$State.REWRITE_NOCHANGE && this.is$Final()) { 812 node.is$Final(true); 813 state().boundariesCrossed = num; 814 } else { 815 } 816 } else if (this.is$Final() != node.is$Final()) { 817 state().boundariesCrossed++; 818 } else { 819 } 820 return (T) node; 821 822 823 } 824 /** 825 * @apilevel low-level 826 * @declaredat ASTNode:149 827 */ 828 public void addChild(T node) { 829 setChild(node, getNumChildNoTransform()); 830 } 831 /** 832 * <p><em>This method does not invoke AST transformations.</em></p> 833 * @apilevel low-level 834 * @declaredat ASTNode:156 835 */ 836 public final T getChildNoTransform(int i) { 837 if (children == null) { 838 return null; 839 } 840 T child = (T)children[i]; 841 return child; 842 } 843 /** 844 * @apilevel low-level 845 * @declaredat ASTNode:166 846 */ 847 protected int numChildren; 848 /** 849 * @apilevel low-level 850 * @declaredat ASTNode:171 851 */ 852 protected int numChildren() { 853 return numChildren; 854 } 855 /** 856 * @apilevel low-level 857 * @declaredat ASTNode:178 858 */ 859 public int getNumChild() { 860 return numChildren(); 861 } 862 /** 863 * <p><em>This method does not invoke AST transformations.</em></p> 864 * @apilevel low-level 865 * @declaredat ASTNode:186 866 */ 867 public final int getNumChildNoTransform() { 868 return numChildren(); 869 } 870 /** 871 * @apilevel low-level 872 * @declaredat ASTNode:192 873 */ 874 public void setChild(ASTNode node, int i) { 875 if (children == null) { 876 children = new ASTNode[(i+1>4 || !(this instanceof List))?i+1:4]; 877 } else if (i >= children.length) { 878 ASTNode c[] = new ASTNode[i << 1]; 879 System.arraycopy(children, 0, c, 0, children.length); 880 children = c; 881 } 882 children[i] = node; 883 if (i >= numChildren) { 884 numChildren = i+1; 885 } 886 if (node != null) { 887 node.setParent(this); 888 node.childIndex = i; 889 } 890 } 891 /** 892 * @apilevel low-level 893 * @declaredat ASTNode:212 894 */ 895 public void insertChild(ASTNode node, int i) { 896 if (children == null) { 897 children = new ASTNode[(i+1>4 || !(this instanceof List))?i+1:4]; 898 children[i] = node; 899 } else { 900 ASTNode c[] = new ASTNode[children.length + 1]; 901 System.arraycopy(children, 0, c, 0, i); 902 c[i] = node; 903 if (i < children.length) { 904 System.arraycopy(children, i, c, i+1, children.length-i); 905 for(int j = i+1; j < c.length; ++j) { 906 if (c[j] != null) { 907 c[j].childIndex = j; 908 } 909 } 910 } 911 children = c; 912 } 913 numChildren++; 914 if (node != null) { 915 node.setParent(this); 916 node.childIndex = i; 917 } 918 } 919 /** 920 * @apilevel low-level 921 * @declaredat ASTNode:239 922 */ 923 public void removeChild(int i) { 924 if (children != null) { 925 ASTNode child = (ASTNode) children[i]; 926 if (child != null) { 927 child.parent = null; 928 child.childIndex = -1; 929 } 930 // Adding a check of this instance to make sure its a List, a move of children doesn't make 931 // any sense for a node unless its a list. Also, there is a problem if a child of a non-List node is removed 932 // and siblings are moved one step to the right, with null at the end. 933 if (this instanceof List || this instanceof Opt) { 934 System.arraycopy(children, i+1, children, i, children.length-i-1); 935 children[children.length-1] = null; 936 numChildren--; 937 // fix child indices 938 for(int j = i; j < numChildren; ++j) { 939 if (children[j] != null) { 940 child = (ASTNode) children[j]; 941 child.childIndex = j; 942 } 943 } 944 } else { 945 children[i] = null; 946 } 947 } 948 } 949 /** 950 * @apilevel low-level 951 * @declaredat ASTNode:268 952 */ 953 public ASTNode getParent() { 954 if (parent != null && ((ASTNode) parent).is$Final() != is$Final()) { 955 state().boundariesCrossed++; 956 } 957 return (ASTNode) parent; 958 } 959 /** 960 * @apilevel low-level 961 * @declaredat ASTNode:277 962 */ 963 public void setParent(ASTNode node) { 964 parent = node; 965 } 966 /** 967 * @apilevel low-level 968 * @declaredat ASTNode:328 969 */ 970 public java.util.Iterator<T> iterator() { 971 return new java.util.Iterator<T>() { 972 private int counter = 0; 973 public boolean hasNext() { 974 return counter < getNumChild(); 975 } 976 public T next() { 977 if (hasNext()) 978 return (T)getChild(counter++); 979 else 980 return null; 981 } 982 public void remove() { 983 throw new UnsupportedOperationException(); 984 } 985 }; 986 } 987 /** 988 * @apilevel internal 989 * @declaredat ASTNode:348 990 */ 991 public boolean mayHaveRewrite() { 992 return false; 993 } 994 /** 995 * @apilevel low-level 996 * @declaredat ASTNode:354 997 */ 998 public void flushTreeCache() { 999 flushCache(); 1000 if (children == null) { 1001 return; 1002 } 1003 for (int i = 0; i < children.length; i++) { 1004 if (children[i] != null && ((ASTNode)children[i]).is$Final) { 1005 ((ASTNode)children[i]).flushTreeCache(); 1006 } 1007 } 1008 } 1009 /** 1010 * @apilevel low-level 1011 * @declaredat ASTNode:368 1012 */ 1013 public void flushCache() { 1014 flushAttrAndCollectionCache(); 1015 } 1016 /** 1017 * @apilevel internal 1018 * @declaredat ASTNode:374 1019 */ 1020 public void flushAttrAndCollectionCache() { 1021 flushAttrCache(); 1022 flushCollectionCache(); 1023 } 1024 /** 1025 * @apilevel internal 1026 * @declaredat ASTNode:381 1027 */ 1028 public void flushAttrCache() { 1029 } 1030 /** 1031 * @apilevel internal 1032 * @declaredat ASTNode:386 1033 */ 1034 public void flushCollectionCache() { 1035 } 1036 /** 1037 * @apilevel internal 1038 * @declaredat ASTNode:391 1039 */ 1040 public void flushRewriteCache() { 1041 in$Circle(false); 1042 is$Final(false); 1043 } 1044 /** 1045 * @apilevel internal 1046 * @declaredat ASTNode:398 1047 */ 1048 public ASTNode<T> clone() throws CloneNotSupportedException { 1049 ASTNode node = (ASTNode) super.clone(); 1050 if (node.is$Final()) { 1051 node.flushAttrAndCollectionCache(); 1052 } 1053 node.in$Circle(false); 1054 // flush rewrites 1055 node.is$Final(false); 1056 return node; 1057 } 1058 /** 1059 * @apilevel internal 1060 * @declaredat ASTNode:411 1061 */ 1062 public ASTNode<T> copy() { 1063 try { 1064 ASTNode node = (ASTNode) clone(); 1065 node.parent = null; 1066 if (children != null) { 1067 node.children = (ASTNode[]) children.clone(); 1068 } 1069 return node; 1070 } catch (CloneNotSupportedException e) { 1071 throw new Error("Error: clone not supported for " + getClass().getName()); 1072 } 1073 } 1074 /** 1075 * Create a deep copy of the AST subtree at this node. 1076 * The copy is dangling, i.e. has no parent. 1077 * @return dangling copy of the subtree at this node 1078 * @apilevel low-level 1079 * @deprecated Please use treeCopy or treeCopyNoTransform instead 1080 * @declaredat ASTNode:430 1081 */ 1082 @Deprecated 1083 public ASTNode<T> fullCopy() { 1084 return treeCopyNoTransform(); 1085 } 1086 /** 1087 * Create a deep copy of the AST subtree at this node. 1088 * The copy is dangling, i.e. has no parent. 1089 * @return dangling copy of the subtree at this node 1090 * @apilevel low-level 1091 * @declaredat ASTNode:440 1092 */ 1093 public ASTNode<T> treeCopyNoTransform() { 1094 ASTNode tree = (ASTNode) copy(); 1095 if (children != null) { 1096 for (int i = 0; i < children.length; ++i) { 1097 ASTNode child = (ASTNode) children[i]; 1098 if (child != null) { 1099 child = child.treeCopyNoTransform(); 1100 tree.setChild(child, i); 1101 } 1102 } 1103 } 1104 return tree; 1105 } 1106 /** 1107 * Create a deep copy of the AST subtree at this node. 1108 * The subtree of this node is traversed to trigger rewrites before copy. 1109 * The copy is dangling, i.e. has no parent. 1110 * @return dangling copy of the subtree at this node 1111 * @apilevel low-level 1112 * @declaredat ASTNode:460 1113 */ 1114 public ASTNode<T> treeCopy() { 1115 doFullTraversal(); 1116 return treeCopyNoTransform(); 1117 } 1118 /** 1119 * Performs a full traversal of the tree using getChild to trigger rewrites 1120 * @apilevel low-level 1121 * @declaredat ASTNode:468 1122 */ 1123 public void doFullTraversal() { 1124 for (int i = 0; i < getNumChild(); i++) { 1125 getChild(i).doFullTraversal(); 1126 } 1127 } 1128 /** 1129 * @apilevel internal 1130 * @declaredat ASTNode:476 1131 */ 1132 protected boolean is$Equal(ASTNode n1, ASTNode n2) { 1133 if (n1 == null && n2 == null) return true; 1134 if (n1 == null || n2 == null) return false; 1135 return n1.is$Equal(n2); 1136 } 1137 /** 1138 * @apilevel internal 1139 * @declaredat ASTNode:484 1140 */ 1141 protected boolean is$Equal(ASTNode node) { 1142 if (getClass() != node.getClass()) { 1143 return false; 1144 } 1145 if (numChildren != node.numChildren) { 1146 return false; 1147 } 1148 for (int i = 0; i < numChildren; i++) { 1149 if (children[i] == null && node.children[i] != null) { 1150 return false; 1151 } 1152 if (!((ASTNode)children[i]).is$Equal(((ASTNode)node.children[i]))) { 1153 return false; 1154 } 1155 } 1156 return true; 1157 } 1158 /** 1159 * The collectErrors method is refined so that it calls 1160 * the checkWarnings method on each ASTNode to report 1161 * unchecked warnings. 1162 * @aspect Warnings 1163 * @declaredat /home/jesper/git/extendj/java7/frontend/Warnings.jadd:42 1164 */ 1165 public void collectErrors() { 1166 nameCheck(); 1167 typeCheck(); 1168 accessControl(); 1169 exceptionHandling(); 1170 checkUnreachableStmt(); 1171 definiteAssignment(); 1172 checkModifiers(); 1173 checkWarnings(); 1174 for(int i = 0; i < getNumChild(); i++) { 1175 getChild(i).collectErrors(); 1176 } 1177 } 1178 /** 1179 * @aspect <NoAspect> 1180 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaBody.jrag:47 1181 */ 1182 protected void collect_contributors_BlockLambdaBody_lambdaReturns() { 1183 for(int i = 0; i < getNumChild(); i++) { 1184 getChild(i).collect_contributors_BlockLambdaBody_lambdaReturns(); 1185 } 1186 } 1187 protected void contributeTo_BlockLambdaBody_BlockLambdaBody_lambdaReturns(ArrayList<ReturnStmt> collection) { 1188 } 1189 1190 /** 1191 * @attribute syn 1192 * @aspect ErrorCheck 1193 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:45 1194 */ 1195 @ASTNodeAnnotation.Attribute 1196 public int lineNumber() { 1197 { 1198 ASTNode n = this; 1199 while (n.getParent() != null && n.getStart() == 0) { 1200 n = n.getParent(); 1201 } 1202 return getLine(n.getStart()); 1203 } 1204 } 1205 /** 1206 * @attribute syn 1207 * @aspect CodeGeneration 1208 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:37 1209 */ 1210 @ASTNodeAnnotation.Attribute 1211 public int sourceLineNumber() { 1212 int sourceLineNumber_value = getStart() != 0 ? getLine(getStart()) : -1; 1213 1214 return sourceLineNumber_value; 1215 } 1216 /** 1217 * @attribute syn 1218 * @aspect GenerateClassfile 1219 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:379 1220 */ 1221 @ASTNodeAnnotation.Attribute 1222 public boolean flush() { 1223 boolean flush_value = true; 1224 1225 return flush_value; 1226 } 1227 /** 1228 * @attribute syn 1229 * @aspect InnerClasses 1230 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:119 1231 */ 1232 @ASTNodeAnnotation.Attribute 1233 public boolean isStringAdd() { 1234 boolean isStringAdd_value = false; 1235 1236 return isStringAdd_value; 1237 } 1238 /** 1239 * @attribute syn 1240 * @aspect LookupParTypeDecl 1241 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1240 1242 */ 1243 @ASTNodeAnnotation.Attribute 1244 public boolean usesTypeVariable() { 1245 { 1246 for (int i = 0; i < getNumChild(); i++) { 1247 if (getChild(i).usesTypeVariable()) { 1248 return true; 1249 } 1250 } 1251 return false; 1252 } 1253 } 1254 /** 1255 * @attribute inh 1256 * @aspect AddOptionsToProgram 1257 * @declaredat /home/jesper/git/extendj/java4/frontend/Options.jadd:39 1258 */ 1259 /** 1260 * @attribute inh 1261 * @aspect AddOptionsToProgram 1262 * @declaredat /home/jesper/git/extendj/java4/frontend/Options.jadd:39 1263 */ 1264 @ASTNodeAnnotation.Attribute 1265 public Program program() { 1266 Program program_value = getParent().Define_program(this, null); 1267 1268 return program_value; 1269 } 1270 /** 1271 * @apilevel internal 1272 */ 1273 public ASTNode rewriteTo() { 1274 if (state().peek() == ASTNode$State.REWRITE_CHANGE) { 1275 state().pop(); 1276 state().push(ASTNode$State.REWRITE_NOCHANGE); 1277 } 1278 return this; 1279 } 1280 /** 1281 * @apilevel internal 1282 */ 1283 public TypeDecl Define_superType(ASTNode caller, ASTNode child) { 1284 ASTNode self = this; 1285 ASTNode parent = getParent(); 1286 while (parent != null && !parent.canDefine_superType(self, caller)) { 1287 caller = self; 1288 self = parent; 1289 parent = self.getParent(); 1290 } 1291 return parent.Define_superType(self, caller); 1292 } 1293 1294 /** 1295 * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:34 1296 * @apilevel internal 1297 * @return {@code true} if this node has an equation for the inherited attribute superType 1298 */ 1299 protected boolean canDefine_superType(ASTNode caller, ASTNode child) { 1300 return false; 1301 } 1302 /** 1303 * @apilevel internal 1304 */ 1305 public ConstructorDecl Define_constructorDecl(ASTNode caller, ASTNode child) { 1306 ASTNode self = this; 1307 ASTNode parent = getParent(); 1308 while (parent != null && !parent.canDefine_constructorDecl(self, caller)) { 1309 caller = self; 1310 self = parent; 1311 parent = self.getParent(); 1312 } 1313 return parent.Define_constructorDecl(self, caller); 1314 } 1315 1316 /** 1317 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:117 1318 * @apilevel internal 1319 * @return {@code true} if this node has an equation for the inherited attribute constructorDecl 1320 */ 1321 protected boolean canDefine_constructorDecl(ASTNode caller, ASTNode child) { 1322 return false; 1323 } 1324 /** 1325 * @apilevel internal 1326 */ 1327 public TypeDecl Define_componentType(ASTNode caller, ASTNode child) { 1328 ASTNode self = this; 1329 ASTNode parent = getParent(); 1330 while (parent != null && !parent.canDefine_componentType(self, caller)) { 1331 caller = self; 1332 self = parent; 1333 parent = self.getParent(); 1334 } 1335 return parent.Define_componentType(self, caller); 1336 } 1337 1338 /** 1339 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:41 1340 * @apilevel internal 1341 * @return {@code true} if this node has an equation for the inherited attribute componentType 1342 */ 1343 protected boolean canDefine_componentType(ASTNode caller, ASTNode child) { 1344 return false; 1345 } 1346 /** 1347 * @apilevel internal 1348 */ 1349 public LabeledStmt Define_lookupLabel(ASTNode caller, ASTNode child, String name) { 1350 ASTNode self = this; 1351 ASTNode parent = getParent(); 1352 while (parent != null && !parent.canDefine_lookupLabel(self, caller, name)) { 1353 caller = self; 1354 self = parent; 1355 parent = self.getParent(); 1356 } 1357 return parent.Define_lookupLabel(self, caller, name); 1358 } 1359 1360 /** 1361 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:252 1362 * @apilevel internal 1363 * @return {@code true} if this node has an equation for the inherited attribute lookupLabel 1364 */ 1365 protected boolean canDefine_lookupLabel(ASTNode caller, ASTNode child, String name) { 1366 return false; 1367 } 1368 /** 1369 * @apilevel internal 1370 */ 1371 public int Define_blockIndex(ASTNode caller, ASTNode child) { 1372 ASTNode self = this; 1373 ASTNode parent = getParent(); 1374 while (parent != null && !parent.canDefine_blockIndex(self, caller)) { 1375 caller = self; 1376 self = parent; 1377 parent = self.getParent(); 1378 } 1379 return parent.Define_blockIndex(self, caller); 1380 } 1381 1382 /** 1383 * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:36 1384 * @apilevel internal 1385 * @return {@code true} if this node has an equation for the inherited attribute blockIndex 1386 */ 1387 protected boolean canDefine_blockIndex(ASTNode caller, ASTNode child) { 1388 return false; 1389 } 1390 /** 1391 * @apilevel internal 1392 */ 1393 public boolean Define_isDest(ASTNode caller, ASTNode child) { 1394 ASTNode self = this; 1395 ASTNode parent = getParent(); 1396 while (parent != null && !parent.canDefine_isDest(self, caller)) { 1397 caller = self; 1398 self = parent; 1399 parent = self.getParent(); 1400 } 1401 return parent.Define_isDest(self, caller); 1402 } 1403 1404 /** 1405 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:67 1406 * @apilevel internal 1407 * @return {@code true} if this node has an equation for the inherited attribute isDest 1408 */ 1409 protected boolean canDefine_isDest(ASTNode caller, ASTNode child) { 1410 return false; 1411 } 1412 /** 1413 * @apilevel internal 1414 */ 1415 public boolean Define_isSource(ASTNode caller, ASTNode child) { 1416 ASTNode self = this; 1417 ASTNode parent = getParent(); 1418 while (parent != null && !parent.canDefine_isSource(self, caller)) { 1419 caller = self; 1420 self = parent; 1421 parent = self.getParent(); 1422 } 1423 return parent.Define_isSource(self, caller); 1424 } 1425 1426 /** 1427 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:66 1428 * @apilevel internal 1429 * @return {@code true} if this node has an equation for the inherited attribute isSource 1430 */ 1431 protected boolean canDefine_isSource(ASTNode caller, ASTNode child) { 1432 return false; 1433 } 1434 /** 1435 * @apilevel internal 1436 */ 1437 public boolean Define_isIncOrDec(ASTNode caller, ASTNode child) { 1438 ASTNode self = this; 1439 ASTNode parent = getParent(); 1440 while (parent != null && !parent.canDefine_isIncOrDec(self, caller)) { 1441 caller = self; 1442 self = parent; 1443 parent = self.getParent(); 1444 } 1445 return parent.Define_isIncOrDec(self, caller); 1446 } 1447 1448 /** 1449 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:74 1450 * @apilevel internal 1451 * @return {@code true} if this node has an equation for the inherited attribute isIncOrDec 1452 */ 1453 protected boolean canDefine_isIncOrDec(ASTNode caller, ASTNode child) { 1454 return false; 1455 } 1456 /** 1457 * @apilevel internal 1458 */ 1459 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 1460 ASTNode self = this; 1461 ASTNode parent = getParent(); 1462 while (parent != null && !parent.canDefine_isDAbefore(self, caller, v)) { 1463 caller = self; 1464 self = parent; 1465 parent = self.getParent(); 1466 } 1467 return parent.Define_isDAbefore(self, caller, v); 1468 } 1469 1470 /** 1471 * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:213 1472 * @apilevel internal 1473 * @return {@code true} if this node has an equation for the inherited attribute isDAbefore 1474 */ 1475 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 1476 return false; 1477 } 1478 /** 1479 * @apilevel internal 1480 */ 1481 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 1482 ASTNode self = this; 1483 ASTNode parent = getParent(); 1484 while (parent != null && !parent.canDefine_isDUbefore(self, caller, v)) { 1485 caller = self; 1486 self = parent; 1487 parent = self.getParent(); 1488 } 1489 return parent.Define_isDUbefore(self, caller, v); 1490 } 1491 1492 /** 1493 * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:148 1494 * @apilevel internal 1495 * @return {@code true} if this node has an equation for the inherited attribute isDUbefore 1496 */ 1497 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 1498 return false; 1499 } 1500 /** 1501 * @apilevel internal 1502 */ 1503 public TypeDecl Define_typeException(ASTNode caller, ASTNode child) { 1504 ASTNode self = this; 1505 ASTNode parent = getParent(); 1506 while (parent != null && !parent.canDefine_typeException(self, caller)) { 1507 caller = self; 1508 self = parent; 1509 parent = self.getParent(); 1510 } 1511 return parent.Define_typeException(self, caller); 1512 } 1513 1514 /** 1515 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:40 1516 * @apilevel internal 1517 * @return {@code true} if this node has an equation for the inherited attribute typeException 1518 */ 1519 protected boolean canDefine_typeException(ASTNode caller, ASTNode child) { 1520 return false; 1521 } 1522 /** 1523 * @apilevel internal 1524 */ 1525 public TypeDecl Define_typeRuntimeException(ASTNode caller, ASTNode child) { 1526 ASTNode self = this; 1527 ASTNode parent = getParent(); 1528 while (parent != null && !parent.canDefine_typeRuntimeException(self, caller)) { 1529 caller = self; 1530 self = parent; 1531 parent = self.getParent(); 1532 } 1533 return parent.Define_typeRuntimeException(self, caller); 1534 } 1535 1536 /** 1537 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:42 1538 * @apilevel internal 1539 * @return {@code true} if this node has an equation for the inherited attribute typeRuntimeException 1540 */ 1541 protected boolean canDefine_typeRuntimeException(ASTNode caller, ASTNode child) { 1542 return false; 1543 } 1544 /** 1545 * @apilevel internal 1546 */ 1547 public TypeDecl Define_typeError(ASTNode caller, ASTNode child) { 1548 ASTNode self = this; 1549 ASTNode parent = getParent(); 1550 while (parent != null && !parent.canDefine_typeError(self, caller)) { 1551 caller = self; 1552 self = parent; 1553 parent = self.getParent(); 1554 } 1555 return parent.Define_typeError(self, caller); 1556 } 1557 1558 /** 1559 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:44 1560 * @apilevel internal 1561 * @return {@code true} if this node has an equation for the inherited attribute typeError 1562 */ 1563 protected boolean canDefine_typeError(ASTNode caller, ASTNode child) { 1564 return false; 1565 } 1566 /** 1567 * @apilevel internal 1568 */ 1569 public TypeDecl Define_typeNullPointerException(ASTNode caller, ASTNode child) { 1570 ASTNode self = this; 1571 ASTNode parent = getParent(); 1572 while (parent != null && !parent.canDefine_typeNullPointerException(self, caller)) { 1573 caller = self; 1574 self = parent; 1575 parent = self.getParent(); 1576 } 1577 return parent.Define_typeNullPointerException(self, caller); 1578 } 1579 1580 /** 1581 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:46 1582 * @apilevel internal 1583 * @return {@code true} if this node has an equation for the inherited attribute typeNullPointerException 1584 */ 1585 protected boolean canDefine_typeNullPointerException(ASTNode caller, ASTNode child) { 1586 return false; 1587 } 1588 /** 1589 * @apilevel internal 1590 */ 1591 public TypeDecl Define_typeThrowable(ASTNode caller, ASTNode child) { 1592 ASTNode self = this; 1593 ASTNode parent = getParent(); 1594 while (parent != null && !parent.canDefine_typeThrowable(self, caller)) { 1595 caller = self; 1596 self = parent; 1597 parent = self.getParent(); 1598 } 1599 return parent.Define_typeThrowable(self, caller); 1600 } 1601 1602 /** 1603 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:48 1604 * @apilevel internal 1605 * @return {@code true} if this node has an equation for the inherited attribute typeThrowable 1606 */ 1607 protected boolean canDefine_typeThrowable(ASTNode caller, ASTNode child) { 1608 return false; 1609 } 1610 /** 1611 * @apilevel internal 1612 */ 1613 public boolean Define_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 1614 ASTNode self = this; 1615 ASTNode parent = getParent(); 1616 while (parent != null && !parent.canDefine_handlesException(self, caller, exceptionType)) { 1617 caller = self; 1618 self = parent; 1619 parent = self.getParent(); 1620 } 1621 return parent.Define_handlesException(self, caller, exceptionType); 1622 } 1623 1624 /** 1625 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:150 1626 * @apilevel internal 1627 * @return {@code true} if this node has an equation for the inherited attribute handlesException 1628 */ 1629 protected boolean canDefine_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 1630 return false; 1631 } 1632 /** 1633 * @apilevel internal 1634 */ 1635 public Collection Define_lookupConstructor(ASTNode caller, ASTNode child) { 1636 ASTNode self = this; 1637 ASTNode parent = getParent(); 1638 while (parent != null && !parent.canDefine_lookupConstructor(self, caller)) { 1639 caller = self; 1640 self = parent; 1641 parent = self.getParent(); 1642 } 1643 return parent.Define_lookupConstructor(self, caller); 1644 } 1645 1646 /** 1647 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:37 1648 * @apilevel internal 1649 * @return {@code true} if this node has an equation for the inherited attribute lookupConstructor 1650 */ 1651 protected boolean canDefine_lookupConstructor(ASTNode caller, ASTNode child) { 1652 return false; 1653 } 1654 /** 1655 * @apilevel internal 1656 */ 1657 public Collection Define_lookupSuperConstructor(ASTNode caller, ASTNode child) { 1658 ASTNode self = this; 1659 ASTNode parent = getParent(); 1660 while (parent != null && !parent.canDefine_lookupSuperConstructor(self, caller)) { 1661 caller = self; 1662 self = parent; 1663 parent = self.getParent(); 1664 } 1665 return parent.Define_lookupSuperConstructor(self, caller); 1666 } 1667 1668 /** 1669 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:41 1670 * @apilevel internal 1671 * @return {@code true} if this node has an equation for the inherited attribute lookupSuperConstructor 1672 */ 1673 protected boolean canDefine_lookupSuperConstructor(ASTNode caller, ASTNode child) { 1674 return false; 1675 } 1676 /** 1677 * @apilevel internal 1678 */ 1679 public Expr Define_nestedScope(ASTNode caller, ASTNode child) { 1680 ASTNode self = this; 1681 ASTNode parent = getParent(); 1682 while (parent != null && !parent.canDefine_nestedScope(self, caller)) { 1683 caller = self; 1684 self = parent; 1685 parent = self.getParent(); 1686 } 1687 return parent.Define_nestedScope(self, caller); 1688 } 1689 1690 /** 1691 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:42 1692 * @apilevel internal 1693 * @return {@code true} if this node has an equation for the inherited attribute nestedScope 1694 */ 1695 protected boolean canDefine_nestedScope(ASTNode caller, ASTNode child) { 1696 return false; 1697 } 1698 /** 1699 * @apilevel internal 1700 */ 1701 public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) { 1702 ASTNode self = this; 1703 ASTNode parent = getParent(); 1704 while (parent != null && !parent.canDefine_lookupMethod(self, caller, name)) { 1705 caller = self; 1706 self = parent; 1707 parent = self.getParent(); 1708 } 1709 return parent.Define_lookupMethod(self, caller, name); 1710 } 1711 1712 /** 1713 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:81 1714 * @apilevel internal 1715 * @return {@code true} if this node has an equation for the inherited attribute lookupMethod 1716 */ 1717 protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) { 1718 return false; 1719 } 1720 /** 1721 * @apilevel internal 1722 */ 1723 public TypeDecl Define_typeObject(ASTNode caller, ASTNode child) { 1724 ASTNode self = this; 1725 ASTNode parent = getParent(); 1726 while (parent != null && !parent.canDefine_typeObject(self, caller)) { 1727 caller = self; 1728 self = parent; 1729 parent = self.getParent(); 1730 } 1731 return parent.Define_typeObject(self, caller); 1732 } 1733 1734 /** 1735 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:41 1736 * @apilevel internal 1737 * @return {@code true} if this node has an equation for the inherited attribute typeObject 1738 */ 1739 protected boolean canDefine_typeObject(ASTNode caller, ASTNode child) { 1740 return false; 1741 } 1742 /** 1743 * @apilevel internal 1744 */ 1745 public TypeDecl Define_typeCloneable(ASTNode caller, ASTNode child) { 1746 ASTNode self = this; 1747 ASTNode parent = getParent(); 1748 while (parent != null && !parent.canDefine_typeCloneable(self, caller)) { 1749 caller = self; 1750 self = parent; 1751 parent = self.getParent(); 1752 } 1753 return parent.Define_typeCloneable(self, caller); 1754 } 1755 1756 /** 1757 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:42 1758 * @apilevel internal 1759 * @return {@code true} if this node has an equation for the inherited attribute typeCloneable 1760 */ 1761 protected boolean canDefine_typeCloneable(ASTNode caller, ASTNode child) { 1762 return false; 1763 } 1764 /** 1765 * @apilevel internal 1766 */ 1767 public TypeDecl Define_typeSerializable(ASTNode caller, ASTNode child) { 1768 ASTNode self = this; 1769 ASTNode parent = getParent(); 1770 while (parent != null && !parent.canDefine_typeSerializable(self, caller)) { 1771 caller = self; 1772 self = parent; 1773 parent = self.getParent(); 1774 } 1775 return parent.Define_typeSerializable(self, caller); 1776 } 1777 1778 /** 1779 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:43 1780 * @apilevel internal 1781 * @return {@code true} if this node has an equation for the inherited attribute typeSerializable 1782 */ 1783 protected boolean canDefine_typeSerializable(ASTNode caller, ASTNode child) { 1784 return false; 1785 } 1786 /** 1787 * @apilevel internal 1788 */ 1789 public TypeDecl Define_typeBoolean(ASTNode caller, ASTNode child) { 1790 ASTNode self = this; 1791 ASTNode parent = getParent(); 1792 while (parent != null && !parent.canDefine_typeBoolean(self, caller)) { 1793 caller = self; 1794 self = parent; 1795 parent = self.getParent(); 1796 } 1797 return parent.Define_typeBoolean(self, caller); 1798 } 1799 1800 /** 1801 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:55 1802 * @apilevel internal 1803 * @return {@code true} if this node has an equation for the inherited attribute typeBoolean 1804 */ 1805 protected boolean canDefine_typeBoolean(ASTNode caller, ASTNode child) { 1806 return false; 1807 } 1808 /** 1809 * @apilevel internal 1810 */ 1811 public TypeDecl Define_typeByte(ASTNode caller, ASTNode child) { 1812 ASTNode self = this; 1813 ASTNode parent = getParent(); 1814 while (parent != null && !parent.canDefine_typeByte(self, caller)) { 1815 caller = self; 1816 self = parent; 1817 parent = self.getParent(); 1818 } 1819 return parent.Define_typeByte(self, caller); 1820 } 1821 1822 /** 1823 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:56 1824 * @apilevel internal 1825 * @return {@code true} if this node has an equation for the inherited attribute typeByte 1826 */ 1827 protected boolean canDefine_typeByte(ASTNode caller, ASTNode child) { 1828 return false; 1829 } 1830 /** 1831 * @apilevel internal 1832 */ 1833 public TypeDecl Define_typeShort(ASTNode caller, ASTNode child) { 1834 ASTNode self = this; 1835 ASTNode parent = getParent(); 1836 while (parent != null && !parent.canDefine_typeShort(self, caller)) { 1837 caller = self; 1838 self = parent; 1839 parent = self.getParent(); 1840 } 1841 return parent.Define_typeShort(self, caller); 1842 } 1843 1844 /** 1845 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:57 1846 * @apilevel internal 1847 * @return {@code true} if this node has an equation for the inherited attribute typeShort 1848 */ 1849 protected boolean canDefine_typeShort(ASTNode caller, ASTNode child) { 1850 return false; 1851 } 1852 /** 1853 * @apilevel internal 1854 */ 1855 public TypeDecl Define_typeChar(ASTNode caller, ASTNode child) { 1856 ASTNode self = this; 1857 ASTNode parent = getParent(); 1858 while (parent != null && !parent.canDefine_typeChar(self, caller)) { 1859 caller = self; 1860 self = parent; 1861 parent = self.getParent(); 1862 } 1863 return parent.Define_typeChar(self, caller); 1864 } 1865 1866 /** 1867 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:58 1868 * @apilevel internal 1869 * @return {@code true} if this node has an equation for the inherited attribute typeChar 1870 */ 1871 protected boolean canDefine_typeChar(ASTNode caller, ASTNode child) { 1872 return false; 1873 } 1874 /** 1875 * @apilevel internal 1876 */ 1877 public TypeDecl Define_typeInt(ASTNode caller, ASTNode child) { 1878 ASTNode self = this; 1879 ASTNode parent = getParent(); 1880 while (parent != null && !parent.canDefine_typeInt(self, caller)) { 1881 caller = self; 1882 self = parent; 1883 parent = self.getParent(); 1884 } 1885 return parent.Define_typeInt(self, caller); 1886 } 1887 1888 /** 1889 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:59 1890 * @apilevel internal 1891 * @return {@code true} if this node has an equation for the inherited attribute typeInt 1892 */ 1893 protected boolean canDefine_typeInt(ASTNode caller, ASTNode child) { 1894 return false; 1895 } 1896 /** 1897 * @apilevel internal 1898 */ 1899 public TypeDecl Define_typeLong(ASTNode caller, ASTNode child) { 1900 ASTNode self = this; 1901 ASTNode parent = getParent(); 1902 while (parent != null && !parent.canDefine_typeLong(self, caller)) { 1903 caller = self; 1904 self = parent; 1905 parent = self.getParent(); 1906 } 1907 return parent.Define_typeLong(self, caller); 1908 } 1909 1910 /** 1911 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:60 1912 * @apilevel internal 1913 * @return {@code true} if this node has an equation for the inherited attribute typeLong 1914 */ 1915 protected boolean canDefine_typeLong(ASTNode caller, ASTNode child) { 1916 return false; 1917 } 1918 /** 1919 * @apilevel internal 1920 */ 1921 public TypeDecl Define_typeFloat(ASTNode caller, ASTNode child) { 1922 ASTNode self = this; 1923 ASTNode parent = getParent(); 1924 while (parent != null && !parent.canDefine_typeFloat(self, caller)) { 1925 caller = self; 1926 self = parent; 1927 parent = self.getParent(); 1928 } 1929 return parent.Define_typeFloat(self, caller); 1930 } 1931 1932 /** 1933 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:61 1934 * @apilevel internal 1935 * @return {@code true} if this node has an equation for the inherited attribute typeFloat 1936 */ 1937 protected boolean canDefine_typeFloat(ASTNode caller, ASTNode child) { 1938 return false; 1939 } 1940 /** 1941 * @apilevel internal 1942 */ 1943 public TypeDecl Define_typeDouble(ASTNode caller, ASTNode child) { 1944 ASTNode self = this; 1945 ASTNode parent = getParent(); 1946 while (parent != null && !parent.canDefine_typeDouble(self, caller)) { 1947 caller = self; 1948 self = parent; 1949 parent = self.getParent(); 1950 } 1951 return parent.Define_typeDouble(self, caller); 1952 } 1953 1954 /** 1955 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:62 1956 * @apilevel internal 1957 * @return {@code true} if this node has an equation for the inherited attribute typeDouble 1958 */ 1959 protected boolean canDefine_typeDouble(ASTNode caller, ASTNode child) { 1960 return false; 1961 } 1962 /** 1963 * @apilevel internal 1964 */ 1965 public TypeDecl Define_typeString(ASTNode caller, ASTNode child) { 1966 ASTNode self = this; 1967 ASTNode parent = getParent(); 1968 while (parent != null && !parent.canDefine_typeString(self, caller)) { 1969 caller = self; 1970 self = parent; 1971 parent = self.getParent(); 1972 } 1973 return parent.Define_typeString(self, caller); 1974 } 1975 1976 /** 1977 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:63 1978 * @apilevel internal 1979 * @return {@code true} if this node has an equation for the inherited attribute typeString 1980 */ 1981 protected boolean canDefine_typeString(ASTNode caller, ASTNode child) { 1982 return false; 1983 } 1984 /** 1985 * @apilevel internal 1986 */ 1987 public TypeDecl Define_typeVoid(ASTNode caller, ASTNode child) { 1988 ASTNode self = this; 1989 ASTNode parent = getParent(); 1990 while (parent != null && !parent.canDefine_typeVoid(self, caller)) { 1991 caller = self; 1992 self = parent; 1993 parent = self.getParent(); 1994 } 1995 return parent.Define_typeVoid(self, caller); 1996 } 1997 1998 /** 1999 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:66 2000 * @apilevel internal 2001 * @return {@code true} if this node has an equation for the inherited attribute typeVoid 2002 */ 2003 protected boolean canDefine_typeVoid(ASTNode caller, ASTNode child) { 2004 return false; 2005 } 2006 /** 2007 * @apilevel internal 2008 */ 2009 public TypeDecl Define_typeNull(ASTNode caller, ASTNode child) { 2010 ASTNode self = this; 2011 ASTNode parent = getParent(); 2012 while (parent != null && !parent.canDefine_typeNull(self, caller)) { 2013 caller = self; 2014 self = parent; 2015 parent = self.getParent(); 2016 } 2017 return parent.Define_typeNull(self, caller); 2018 } 2019 2020 /** 2021 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:69 2022 * @apilevel internal 2023 * @return {@code true} if this node has an equation for the inherited attribute typeNull 2024 */ 2025 protected boolean canDefine_typeNull(ASTNode caller, ASTNode child) { 2026 return false; 2027 } 2028 /** 2029 * @apilevel internal 2030 */ 2031 public TypeDecl Define_unknownType(ASTNode caller, ASTNode child) { 2032 ASTNode self = this; 2033 ASTNode parent = getParent(); 2034 while (parent != null && !parent.canDefine_unknownType(self, caller)) { 2035 caller = self; 2036 self = parent; 2037 parent = self.getParent(); 2038 } 2039 return parent.Define_unknownType(self, caller); 2040 } 2041 2042 /** 2043 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:33 2044 * @apilevel internal 2045 * @return {@code true} if this node has an equation for the inherited attribute unknownType 2046 */ 2047 protected boolean canDefine_unknownType(ASTNode caller, ASTNode child) { 2048 return false; 2049 } 2050 /** 2051 * @apilevel internal 2052 */ 2053 public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) { 2054 ASTNode self = this; 2055 ASTNode parent = getParent(); 2056 while (parent != null && !parent.canDefine_hasPackage(self, caller, packageName)) { 2057 caller = self; 2058 self = parent; 2059 parent = self.getParent(); 2060 } 2061 return parent.Define_hasPackage(self, caller, packageName); 2062 } 2063 2064 /** 2065 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:126 2066 * @apilevel internal 2067 * @return {@code true} if this node has an equation for the inherited attribute hasPackage 2068 */ 2069 protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) { 2070 return false; 2071 } 2072 /** 2073 * @apilevel internal 2074 */ 2075 public TypeDecl Define_lookupType(ASTNode caller, ASTNode child, String packageName, String typeName) { 2076 ASTNode self = this; 2077 ASTNode parent = getParent(); 2078 while (parent != null && !parent.canDefine_lookupType(self, caller, packageName, typeName)) { 2079 caller = self; 2080 self = parent; 2081 parent = self.getParent(); 2082 } 2083 return parent.Define_lookupType(self, caller, packageName, typeName); 2084 } 2085 2086 /** 2087 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:140 2088 * @apilevel internal 2089 * @return {@code true} if this node has an equation for the inherited attribute lookupType 2090 */ 2091 protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String packageName, String typeName) { 2092 return false; 2093 } 2094 /** 2095 * @apilevel internal 2096 */ 2097 public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) { 2098 ASTNode self = this; 2099 ASTNode parent = getParent(); 2100 while (parent != null && !parent.canDefine_lookupType(self, caller, name)) { 2101 caller = self; 2102 self = parent; 2103 parent = self.getParent(); 2104 } 2105 return parent.Define_lookupType(self, caller, name); 2106 } 2107 2108 /** 2109 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:332 2110 * @apilevel internal 2111 * @return {@code true} if this node has an equation for the inherited attribute lookupType 2112 */ 2113 protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) { 2114 return false; 2115 } 2116 /** 2117 * @apilevel internal 2118 */ 2119 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 2120 ASTNode self = this; 2121 ASTNode parent = getParent(); 2122 while (parent != null && !parent.canDefine_lookupVariable(self, caller, name)) { 2123 caller = self; 2124 self = parent; 2125 parent = self.getParent(); 2126 } 2127 return parent.Define_lookupVariable(self, caller, name); 2128 } 2129 2130 /** 2131 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:33 2132 * @apilevel internal 2133 * @return {@code true} if this node has an equation for the inherited attribute lookupVariable 2134 */ 2135 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 2136 return false; 2137 } 2138 /** 2139 * @apilevel internal 2140 */ 2141 public boolean Define_mayBePublic(ASTNode caller, ASTNode child) { 2142 ASTNode self = this; 2143 ASTNode parent = getParent(); 2144 while (parent != null && !parent.canDefine_mayBePublic(self, caller)) { 2145 caller = self; 2146 self = parent; 2147 parent = self.getParent(); 2148 } 2149 return parent.Define_mayBePublic(self, caller); 2150 } 2151 2152 /** 2153 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:312 2154 * @apilevel internal 2155 * @return {@code true} if this node has an equation for the inherited attribute mayBePublic 2156 */ 2157 protected boolean canDefine_mayBePublic(ASTNode caller, ASTNode child) { 2158 return false; 2159 } 2160 /** 2161 * @apilevel internal 2162 */ 2163 public boolean Define_mayBeProtected(ASTNode caller, ASTNode child) { 2164 ASTNode self = this; 2165 ASTNode parent = getParent(); 2166 while (parent != null && !parent.canDefine_mayBeProtected(self, caller)) { 2167 caller = self; 2168 self = parent; 2169 parent = self.getParent(); 2170 } 2171 return parent.Define_mayBeProtected(self, caller); 2172 } 2173 2174 /** 2175 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:313 2176 * @apilevel internal 2177 * @return {@code true} if this node has an equation for the inherited attribute mayBeProtected 2178 */ 2179 protected boolean canDefine_mayBeProtected(ASTNode caller, ASTNode child) { 2180 return false; 2181 } 2182 /** 2183 * @apilevel internal 2184 */ 2185 public boolean Define_mayBePrivate(ASTNode caller, ASTNode child) { 2186 ASTNode self = this; 2187 ASTNode parent = getParent(); 2188 while (parent != null && !parent.canDefine_mayBePrivate(self, caller)) { 2189 caller = self; 2190 self = parent; 2191 parent = self.getParent(); 2192 } 2193 return parent.Define_mayBePrivate(self, caller); 2194 } 2195 2196 /** 2197 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:314 2198 * @apilevel internal 2199 * @return {@code true} if this node has an equation for the inherited attribute mayBePrivate 2200 */ 2201 protected boolean canDefine_mayBePrivate(ASTNode caller, ASTNode child) { 2202 return false; 2203 } 2204 /** 2205 * @apilevel internal 2206 */ 2207 public boolean Define_mayBeStatic(ASTNode caller, ASTNode child) { 2208 ASTNode self = this; 2209 ASTNode parent = getParent(); 2210 while (parent != null && !parent.canDefine_mayBeStatic(self, caller)) { 2211 caller = self; 2212 self = parent; 2213 parent = self.getParent(); 2214 } 2215 return parent.Define_mayBeStatic(self, caller); 2216 } 2217 2218 /** 2219 * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:62 2220 * @apilevel internal 2221 * @return {@code true} if this node has an equation for the inherited attribute mayBeStatic 2222 */ 2223 protected boolean canDefine_mayBeStatic(ASTNode caller, ASTNode child) { 2224 return false; 2225 } 2226 /** 2227 * @apilevel internal 2228 */ 2229 public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) { 2230 ASTNode self = this; 2231 ASTNode parent = getParent(); 2232 while (parent != null && !parent.canDefine_mayBeFinal(self, caller)) { 2233 caller = self; 2234 self = parent; 2235 parent = self.getParent(); 2236 } 2237 return parent.Define_mayBeFinal(self, caller); 2238 } 2239 2240 /** 2241 * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:335 2242 * @apilevel internal 2243 * @return {@code true} if this node has an equation for the inherited attribute mayBeFinal 2244 */ 2245 protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) { 2246 return false; 2247 } 2248 /** 2249 * @apilevel internal 2250 */ 2251 public boolean Define_mayBeAbstract(ASTNode caller, ASTNode child) { 2252 ASTNode self = this; 2253 ASTNode parent = getParent(); 2254 while (parent != null && !parent.canDefine_mayBeAbstract(self, caller)) { 2255 caller = self; 2256 self = parent; 2257 parent = self.getParent(); 2258 } 2259 return parent.Define_mayBeAbstract(self, caller); 2260 } 2261 2262 /** 2263 * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:55 2264 * @apilevel internal 2265 * @return {@code true} if this node has an equation for the inherited attribute mayBeAbstract 2266 */ 2267 protected boolean canDefine_mayBeAbstract(ASTNode caller, ASTNode child) { 2268 return false; 2269 } 2270 /** 2271 * @apilevel internal 2272 */ 2273 public boolean Define_mayBeVolatile(ASTNode caller, ASTNode child) { 2274 ASTNode self = this; 2275 ASTNode parent = getParent(); 2276 while (parent != null && !parent.canDefine_mayBeVolatile(self, caller)) { 2277 caller = self; 2278 self = parent; 2279 parent = self.getParent(); 2280 } 2281 return parent.Define_mayBeVolatile(self, caller); 2282 } 2283 2284 /** 2285 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:309 2286 * @apilevel internal 2287 * @return {@code true} if this node has an equation for the inherited attribute mayBeVolatile 2288 */ 2289 protected boolean canDefine_mayBeVolatile(ASTNode caller, ASTNode child) { 2290 return false; 2291 } 2292 /** 2293 * @apilevel internal 2294 */ 2295 public boolean Define_mayBeTransient(ASTNode caller, ASTNode child) { 2296 ASTNode self = this; 2297 ASTNode parent = getParent(); 2298 while (parent != null && !parent.canDefine_mayBeTransient(self, caller)) { 2299 caller = self; 2300 self = parent; 2301 parent = self.getParent(); 2302 } 2303 return parent.Define_mayBeTransient(self, caller); 2304 } 2305 2306 /** 2307 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:308 2308 * @apilevel internal 2309 * @return {@code true} if this node has an equation for the inherited attribute mayBeTransient 2310 */ 2311 protected boolean canDefine_mayBeTransient(ASTNode caller, ASTNode child) { 2312 return false; 2313 } 2314 /** 2315 * @apilevel internal 2316 */ 2317 public boolean Define_mayBeStrictfp(ASTNode caller, ASTNode child) { 2318 ASTNode self = this; 2319 ASTNode parent = getParent(); 2320 while (parent != null && !parent.canDefine_mayBeStrictfp(self, caller)) { 2321 caller = self; 2322 self = parent; 2323 parent = self.getParent(); 2324 } 2325 return parent.Define_mayBeStrictfp(self, caller); 2326 } 2327 2328 /** 2329 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:320 2330 * @apilevel internal 2331 * @return {@code true} if this node has an equation for the inherited attribute mayBeStrictfp 2332 */ 2333 protected boolean canDefine_mayBeStrictfp(ASTNode caller, ASTNode child) { 2334 return false; 2335 } 2336 /** 2337 * @apilevel internal 2338 */ 2339 public boolean Define_mayBeSynchronized(ASTNode caller, ASTNode child) { 2340 ASTNode self = this; 2341 ASTNode parent = getParent(); 2342 while (parent != null && !parent.canDefine_mayBeSynchronized(self, caller)) { 2343 caller = self; 2344 self = parent; 2345 parent = self.getParent(); 2346 } 2347 return parent.Define_mayBeSynchronized(self, caller); 2348 } 2349 2350 /** 2351 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:318 2352 * @apilevel internal 2353 * @return {@code true} if this node has an equation for the inherited attribute mayBeSynchronized 2354 */ 2355 protected boolean canDefine_mayBeSynchronized(ASTNode caller, ASTNode child) { 2356 return false; 2357 } 2358 /** 2359 * @apilevel internal 2360 */ 2361 public boolean Define_mayBeNative(ASTNode caller, ASTNode child) { 2362 ASTNode self = this; 2363 ASTNode parent = getParent(); 2364 while (parent != null && !parent.canDefine_mayBeNative(self, caller)) { 2365 caller = self; 2366 self = parent; 2367 parent = self.getParent(); 2368 } 2369 return parent.Define_mayBeNative(self, caller); 2370 } 2371 2372 /** 2373 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:319 2374 * @apilevel internal 2375 * @return {@code true} if this node has an equation for the inherited attribute mayBeNative 2376 */ 2377 protected boolean canDefine_mayBeNative(ASTNode caller, ASTNode child) { 2378 return false; 2379 } 2380 /** 2381 * @apilevel internal 2382 */ 2383 public ASTNode Define_enclosingBlock(ASTNode caller, ASTNode child) { 2384 ASTNode self = this; 2385 ASTNode parent = getParent(); 2386 while (parent != null && !parent.canDefine_enclosingBlock(self, caller)) { 2387 caller = self; 2388 self = parent; 2389 parent = self.getParent(); 2390 } 2391 return parent.Define_enclosingBlock(self, caller); 2392 } 2393 2394 /** 2395 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:311 2396 * @apilevel internal 2397 * @return {@code true} if this node has an equation for the inherited attribute enclosingBlock 2398 */ 2399 protected boolean canDefine_enclosingBlock(ASTNode caller, ASTNode child) { 2400 return false; 2401 } 2402 /** 2403 * @apilevel internal 2404 */ 2405 public VariableScope Define_outerScope(ASTNode caller, ASTNode child) { 2406 ASTNode self = this; 2407 ASTNode parent = getParent(); 2408 while (parent != null && !parent.canDefine_outerScope(self, caller)) { 2409 caller = self; 2410 self = parent; 2411 parent = self.getParent(); 2412 } 2413 return parent.Define_outerScope(self, caller); 2414 } 2415 2416 /** 2417 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:35 2418 * @apilevel internal 2419 * @return {@code true} if this node has an equation for the inherited attribute outerScope 2420 */ 2421 protected boolean canDefine_outerScope(ASTNode caller, ASTNode child) { 2422 return false; 2423 } 2424 /** 2425 * @apilevel internal 2426 */ 2427 public boolean Define_insideLoop(ASTNode caller, ASTNode child) { 2428 ASTNode self = this; 2429 ASTNode parent = getParent(); 2430 while (parent != null && !parent.canDefine_insideLoop(self, caller)) { 2431 caller = self; 2432 self = parent; 2433 parent = self.getParent(); 2434 } 2435 return parent.Define_insideLoop(self, caller); 2436 } 2437 2438 /** 2439 * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:150 2440 * @apilevel internal 2441 * @return {@code true} if this node has an equation for the inherited attribute insideLoop 2442 */ 2443 protected boolean canDefine_insideLoop(ASTNode caller, ASTNode child) { 2444 return false; 2445 } 2446 /** 2447 * @apilevel internal 2448 */ 2449 public boolean Define_insideSwitch(ASTNode caller, ASTNode child) { 2450 ASTNode self = this; 2451 ASTNode parent = getParent(); 2452 while (parent != null && !parent.canDefine_insideSwitch(self, caller)) { 2453 caller = self; 2454 self = parent; 2455 parent = self.getParent(); 2456 } 2457 return parent.Define_insideSwitch(self, caller); 2458 } 2459 2460 /** 2461 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:452 2462 * @apilevel internal 2463 * @return {@code true} if this node has an equation for the inherited attribute insideSwitch 2464 */ 2465 protected boolean canDefine_insideSwitch(ASTNode caller, ASTNode child) { 2466 return false; 2467 } 2468 /** 2469 * @apilevel internal 2470 */ 2471 public Case Define_bind(ASTNode caller, ASTNode child, Case c) { 2472 ASTNode self = this; 2473 ASTNode parent = getParent(); 2474 while (parent != null && !parent.canDefine_bind(self, caller, c)) { 2475 caller = self; 2476 self = parent; 2477 parent = self.getParent(); 2478 } 2479 return parent.Define_bind(self, caller, c); 2480 } 2481 2482 /** 2483 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:497 2484 * @apilevel internal 2485 * @return {@code true} if this node has an equation for the inherited attribute bind 2486 */ 2487 protected boolean canDefine_bind(ASTNode caller, ASTNode child, Case c) { 2488 return false; 2489 } 2490 /** 2491 * @apilevel internal 2492 */ 2493 public Program Define_program(ASTNode caller, ASTNode child) { 2494 ASTNode self = this; 2495 ASTNode parent = getParent(); 2496 while (parent != null && !parent.canDefine_program(self, caller)) { 2497 caller = self; 2498 self = parent; 2499 parent = self.getParent(); 2500 } 2501 return parent.Define_program(self, caller); 2502 } 2503 2504 /** 2505 * @declaredat /home/jesper/git/extendj/java4/frontend/Options.jadd:40 2506 * @apilevel internal 2507 * @return {@code true} if this node has an equation for the inherited attribute program 2508 */ 2509 protected boolean canDefine_program(ASTNode caller, ASTNode child) { 2510 return false; 2511 } 2512 /** 2513 * @apilevel internal 2514 */ 2515 public NameType Define_nameType(ASTNode caller, ASTNode child) { 2516 ASTNode self = this; 2517 ASTNode parent = getParent(); 2518 while (parent != null && !parent.canDefine_nameType(self, caller)) { 2519 caller = self; 2520 self = parent; 2521 parent = self.getParent(); 2522 } 2523 return parent.Define_nameType(self, caller); 2524 } 2525 2526 /** 2527 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodReference.jrag:196 2528 * @apilevel internal 2529 * @return {@code true} if this node has an equation for the inherited attribute nameType 2530 */ 2531 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 2532 return false; 2533 } 2534 /** 2535 * @apilevel internal 2536 */ 2537 public boolean Define_isAnonymous(ASTNode caller, ASTNode child) { 2538 ASTNode self = this; 2539 ASTNode parent = getParent(); 2540 while (parent != null && !parent.canDefine_isAnonymous(self, caller)) { 2541 caller = self; 2542 self = parent; 2543 parent = self.getParent(); 2544 } 2545 return parent.Define_isAnonymous(self, caller); 2546 } 2547 2548 /** 2549 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:242 2550 * @apilevel internal 2551 * @return {@code true} if this node has an equation for the inherited attribute isAnonymous 2552 */ 2553 protected boolean canDefine_isAnonymous(ASTNode caller, ASTNode child) { 2554 return false; 2555 } 2556 /** 2557 * @apilevel internal 2558 */ 2559 public Variable Define_unknownField(ASTNode caller, ASTNode child) { 2560 ASTNode self = this; 2561 ASTNode parent = getParent(); 2562 while (parent != null && !parent.canDefine_unknownField(self, caller)) { 2563 caller = self; 2564 self = parent; 2565 parent = self.getParent(); 2566 } 2567 return parent.Define_unknownField(self, caller); 2568 } 2569 2570 /** 2571 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:257 2572 * @apilevel internal 2573 * @return {@code true} if this node has an equation for the inherited attribute unknownField 2574 */ 2575 protected boolean canDefine_unknownField(ASTNode caller, ASTNode child) { 2576 return false; 2577 } 2578 /** 2579 * @apilevel internal 2580 */ 2581 public MethodDecl Define_unknownMethod(ASTNode caller, ASTNode child) { 2582 ASTNode self = this; 2583 ASTNode parent = getParent(); 2584 while (parent != null && !parent.canDefine_unknownMethod(self, caller)) { 2585 caller = self; 2586 self = parent; 2587 parent = self.getParent(); 2588 } 2589 return parent.Define_unknownMethod(self, caller); 2590 } 2591 2592 /** 2593 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:261 2594 * @apilevel internal 2595 * @return {@code true} if this node has an equation for the inherited attribute unknownMethod 2596 */ 2597 protected boolean canDefine_unknownMethod(ASTNode caller, ASTNode child) { 2598 return false; 2599 } 2600 /** 2601 * @apilevel internal 2602 */ 2603 public ConstructorDecl Define_unknownConstructor(ASTNode caller, ASTNode child) { 2604 ASTNode self = this; 2605 ASTNode parent = getParent(); 2606 while (parent != null && !parent.canDefine_unknownConstructor(self, caller)) { 2607 caller = self; 2608 self = parent; 2609 parent = self.getParent(); 2610 } 2611 return parent.Define_unknownConstructor(self, caller); 2612 } 2613 2614 /** 2615 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:268 2616 * @apilevel internal 2617 * @return {@code true} if this node has an equation for the inherited attribute unknownConstructor 2618 */ 2619 protected boolean canDefine_unknownConstructor(ASTNode caller, ASTNode child) { 2620 return false; 2621 } 2622 /** 2623 * @apilevel internal 2624 */ 2625 public TypeDecl Define_declType(ASTNode caller, ASTNode child) { 2626 ASTNode self = this; 2627 ASTNode parent = getParent(); 2628 while (parent != null && !parent.canDefine_declType(self, caller)) { 2629 caller = self; 2630 self = parent; 2631 parent = self.getParent(); 2632 } 2633 return parent.Define_declType(self, caller); 2634 } 2635 2636 /** 2637 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:604 2638 * @apilevel internal 2639 * @return {@code true} if this node has an equation for the inherited attribute declType 2640 */ 2641 protected boolean canDefine_declType(ASTNode caller, ASTNode child) { 2642 return false; 2643 } 2644 /** 2645 * @apilevel internal 2646 */ 2647 public BodyDecl Define_enclosingBodyDecl(ASTNode caller, ASTNode child) { 2648 ASTNode self = this; 2649 ASTNode parent = getParent(); 2650 while (parent != null && !parent.canDefine_enclosingBodyDecl(self, caller)) { 2651 caller = self; 2652 self = parent; 2653 parent = self.getParent(); 2654 } 2655 return parent.Define_enclosingBodyDecl(self, caller); 2656 } 2657 2658 /** 2659 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:565 2660 * @apilevel internal 2661 * @return {@code true} if this node has an equation for the inherited attribute enclosingBodyDecl 2662 */ 2663 protected boolean canDefine_enclosingBodyDecl(ASTNode caller, ASTNode child) { 2664 return false; 2665 } 2666 /** 2667 * @apilevel internal 2668 */ 2669 public boolean Define_isMemberType(ASTNode caller, ASTNode child) { 2670 ASTNode self = this; 2671 ASTNode parent = getParent(); 2672 while (parent != null && !parent.canDefine_isMemberType(self, caller)) { 2673 caller = self; 2674 self = parent; 2675 parent = self.getParent(); 2676 } 2677 return parent.Define_isMemberType(self, caller); 2678 } 2679 2680 /** 2681 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:579 2682 * @apilevel internal 2683 * @return {@code true} if this node has an equation for the inherited attribute isMemberType 2684 */ 2685 protected boolean canDefine_isMemberType(ASTNode caller, ASTNode child) { 2686 return false; 2687 } 2688 /** 2689 * @apilevel internal 2690 */ 2691 public TypeDecl Define_hostType(ASTNode caller, ASTNode child) { 2692 ASTNode self = this; 2693 ASTNode parent = getParent(); 2694 while (parent != null && !parent.canDefine_hostType(self, caller)) { 2695 caller = self; 2696 self = parent; 2697 parent = self.getParent(); 2698 } 2699 return parent.Define_hostType(self, caller); 2700 } 2701 2702 /** 2703 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:632 2704 * @apilevel internal 2705 * @return {@code true} if this node has an equation for the inherited attribute hostType 2706 */ 2707 protected boolean canDefine_hostType(ASTNode caller, ASTNode child) { 2708 return false; 2709 } 2710 /** 2711 * @apilevel internal 2712 */ 2713 public TypeDecl Define_switchType(ASTNode caller, ASTNode child) { 2714 ASTNode self = this; 2715 ASTNode parent = getParent(); 2716 while (parent != null && !parent.canDefine_switchType(self, caller)) { 2717 caller = self; 2718 self = parent; 2719 parent = self.getParent(); 2720 } 2721 return parent.Define_switchType(self, caller); 2722 } 2723 2724 /** 2725 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:421 2726 * @apilevel internal 2727 * @return {@code true} if this node has an equation for the inherited attribute switchType 2728 */ 2729 protected boolean canDefine_switchType(ASTNode caller, ASTNode child) { 2730 return false; 2731 } 2732 /** 2733 * @apilevel internal 2734 */ 2735 public TypeDecl Define_returnType(ASTNode caller, ASTNode child) { 2736 ASTNode self = this; 2737 ASTNode parent = getParent(); 2738 while (parent != null && !parent.canDefine_returnType(self, caller)) { 2739 caller = self; 2740 self = parent; 2741 parent = self.getParent(); 2742 } 2743 return parent.Define_returnType(self, caller); 2744 } 2745 2746 /** 2747 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:38 2748 * @apilevel internal 2749 * @return {@code true} if this node has an equation for the inherited attribute returnType 2750 */ 2751 protected boolean canDefine_returnType(ASTNode caller, ASTNode child) { 2752 return false; 2753 } 2754 /** 2755 * @apilevel internal 2756 */ 2757 public TypeDecl Define_enclosingInstance(ASTNode caller, ASTNode child) { 2758 ASTNode self = this; 2759 ASTNode parent = getParent(); 2760 while (parent != null && !parent.canDefine_enclosingInstance(self, caller)) { 2761 caller = self; 2762 self = parent; 2763 parent = self.getParent(); 2764 } 2765 return parent.Define_enclosingInstance(self, caller); 2766 } 2767 2768 /** 2769 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:601 2770 * @apilevel internal 2771 * @return {@code true} if this node has an equation for the inherited attribute enclosingInstance 2772 */ 2773 protected boolean canDefine_enclosingInstance(ASTNode caller, ASTNode child) { 2774 return false; 2775 } 2776 /** 2777 * @apilevel internal 2778 */ 2779 public String Define_methodHost(ASTNode caller, ASTNode child) { 2780 ASTNode self = this; 2781 ASTNode parent = getParent(); 2782 while (parent != null && !parent.canDefine_methodHost(self, caller)) { 2783 caller = self; 2784 self = parent; 2785 parent = self.getParent(); 2786 } 2787 return parent.Define_methodHost(self, caller); 2788 } 2789 2790 /** 2791 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:652 2792 * @apilevel internal 2793 * @return {@code true} if this node has an equation for the inherited attribute methodHost 2794 */ 2795 protected boolean canDefine_methodHost(ASTNode caller, ASTNode child) { 2796 return false; 2797 } 2798 /** 2799 * @apilevel internal 2800 */ 2801 public boolean Define_inExplicitConstructorInvocation(ASTNode caller, ASTNode child) { 2802 ASTNode self = this; 2803 ASTNode parent = getParent(); 2804 while (parent != null && !parent.canDefine_inExplicitConstructorInvocation(self, caller)) { 2805 caller = self; 2806 self = parent; 2807 parent = self.getParent(); 2808 } 2809 return parent.Define_inExplicitConstructorInvocation(self, caller); 2810 } 2811 2812 /** 2813 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:171 2814 * @apilevel internal 2815 * @return {@code true} if this node has an equation for the inherited attribute inExplicitConstructorInvocation 2816 */ 2817 protected boolean canDefine_inExplicitConstructorInvocation(ASTNode caller, ASTNode child) { 2818 return false; 2819 } 2820 /** 2821 * @apilevel internal 2822 */ 2823 public TypeDecl Define_enclosingExplicitConstructorHostType(ASTNode caller, ASTNode child) { 2824 ASTNode self = this; 2825 ASTNode parent = getParent(); 2826 while (parent != null && !parent.canDefine_enclosingExplicitConstructorHostType(self, caller)) { 2827 caller = self; 2828 self = parent; 2829 parent = self.getParent(); 2830 } 2831 return parent.Define_enclosingExplicitConstructorHostType(self, caller); 2832 } 2833 2834 /** 2835 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:180 2836 * @apilevel internal 2837 * @return {@code true} if this node has an equation for the inherited attribute enclosingExplicitConstructorHostType 2838 */ 2839 protected boolean canDefine_enclosingExplicitConstructorHostType(ASTNode caller, ASTNode child) { 2840 return false; 2841 } 2842 /** 2843 * @apilevel internal 2844 */ 2845 public boolean Define_inStaticContext(ASTNode caller, ASTNode child) { 2846 ASTNode self = this; 2847 ASTNode parent = getParent(); 2848 while (parent != null && !parent.canDefine_inStaticContext(self, caller)) { 2849 caller = self; 2850 self = parent; 2851 parent = self.getParent(); 2852 } 2853 return parent.Define_inStaticContext(self, caller); 2854 } 2855 2856 /** 2857 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:194 2858 * @apilevel internal 2859 * @return {@code true} if this node has an equation for the inherited attribute inStaticContext 2860 */ 2861 protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) { 2862 return false; 2863 } 2864 /** 2865 * @apilevel internal 2866 */ 2867 public boolean Define_reportUnreachable(ASTNode caller, ASTNode child) { 2868 ASTNode self = this; 2869 ASTNode parent = getParent(); 2870 while (parent != null && !parent.canDefine_reportUnreachable(self, caller)) { 2871 caller = self; 2872 self = parent; 2873 parent = self.getParent(); 2874 } 2875 return parent.Define_reportUnreachable(self, caller); 2876 } 2877 2878 /** 2879 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:284 2880 * @apilevel internal 2881 * @return {@code true} if this node has an equation for the inherited attribute reportUnreachable 2882 */ 2883 protected boolean canDefine_reportUnreachable(ASTNode caller, ASTNode child) { 2884 return false; 2885 } 2886 /** 2887 * @apilevel internal 2888 */ 2889 public boolean Define_isMethodParameter(ASTNode caller, ASTNode child) { 2890 ASTNode self = this; 2891 ASTNode parent = getParent(); 2892 while (parent != null && !parent.canDefine_isMethodParameter(self, caller)) { 2893 caller = self; 2894 self = parent; 2895 parent = self.getParent(); 2896 } 2897 return parent.Define_isMethodParameter(self, caller); 2898 } 2899 2900 /** 2901 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:49 2902 * @apilevel internal 2903 * @return {@code true} if this node has an equation for the inherited attribute isMethodParameter 2904 */ 2905 protected boolean canDefine_isMethodParameter(ASTNode caller, ASTNode child) { 2906 return false; 2907 } 2908 /** 2909 * @apilevel internal 2910 */ 2911 public boolean Define_isConstructorParameter(ASTNode caller, ASTNode child) { 2912 ASTNode self = this; 2913 ASTNode parent = getParent(); 2914 while (parent != null && !parent.canDefine_isConstructorParameter(self, caller)) { 2915 caller = self; 2916 self = parent; 2917 parent = self.getParent(); 2918 } 2919 return parent.Define_isConstructorParameter(self, caller); 2920 } 2921 2922 /** 2923 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:50 2924 * @apilevel internal 2925 * @return {@code true} if this node has an equation for the inherited attribute isConstructorParameter 2926 */ 2927 protected boolean canDefine_isConstructorParameter(ASTNode caller, ASTNode child) { 2928 return false; 2929 } 2930 /** 2931 * @apilevel internal 2932 */ 2933 public boolean Define_isExceptionHandlerParameter(ASTNode caller, ASTNode child) { 2934 ASTNode self = this; 2935 ASTNode parent = getParent(); 2936 while (parent != null && !parent.canDefine_isExceptionHandlerParameter(self, caller)) { 2937 caller = self; 2938 self = parent; 2939 parent = self.getParent(); 2940 } 2941 return parent.Define_isExceptionHandlerParameter(self, caller); 2942 } 2943 2944 /** 2945 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:51 2946 * @apilevel internal 2947 * @return {@code true} if this node has an equation for the inherited attribute isExceptionHandlerParameter 2948 */ 2949 protected boolean canDefine_isExceptionHandlerParameter(ASTNode caller, ASTNode child) { 2950 return false; 2951 } 2952 /** 2953 * @apilevel internal 2954 */ 2955 public int Define_variableScopeEndLabel(ASTNode caller, ASTNode child, CodeGeneration gen) { 2956 ASTNode self = this; 2957 ASTNode parent = getParent(); 2958 while (parent != null && !parent.canDefine_variableScopeEndLabel(self, caller, gen)) { 2959 caller = self; 2960 self = parent; 2961 parent = self.getParent(); 2962 } 2963 return parent.Define_variableScopeEndLabel(self, caller, gen); 2964 } 2965 2966 /** 2967 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:71 2968 * @apilevel internal 2969 * @return {@code true} if this node has an equation for the inherited attribute variableScopeEndLabel 2970 */ 2971 protected boolean canDefine_variableScopeEndLabel(ASTNode caller, ASTNode child, CodeGeneration gen) { 2972 return false; 2973 } 2974 /** 2975 * @apilevel internal 2976 */ 2977 public TypeDecl Define_expectedType(ASTNode caller, ASTNode child) { 2978 ASTNode self = this; 2979 ASTNode parent = getParent(); 2980 while (parent != null && !parent.canDefine_expectedType(self, caller)) { 2981 caller = self; 2982 self = parent; 2983 parent = self.getParent(); 2984 } 2985 return parent.Define_expectedType(self, caller); 2986 } 2987 2988 /** 2989 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:97 2990 * @apilevel internal 2991 * @return {@code true} if this node has an equation for the inherited attribute expectedType 2992 */ 2993 protected boolean canDefine_expectedType(ASTNode caller, ASTNode child) { 2994 return false; 2995 } 2996 /** 2997 * @apilevel internal 2998 */ 2999 public int Define_localNum(ASTNode caller, ASTNode child) { 3000 ASTNode self = this; 3001 ASTNode parent = getParent(); 3002 while (parent != null && !parent.canDefine_localNum(self, caller)) { 3003 caller = self; 3004 self = parent; 3005 parent = self.getParent(); 3006 } 3007 return parent.Define_localNum(self, caller); 3008 } 3009 3010 /** 3011 * @declaredat /home/jesper/git/extendj/java7/backend/TryWithResources.jrag:309 3012 * @apilevel internal 3013 * @return {@code true} if this node has an equation for the inherited attribute localNum 3014 */ 3015 protected boolean canDefine_localNum(ASTNode caller, ASTNode child) { 3016 return false; 3017 } 3018 /** 3019 * @apilevel internal 3020 */ 3021 public int Define_resultSaveLocalNum(ASTNode caller, ASTNode child) { 3022 ASTNode self = this; 3023 ASTNode parent = getParent(); 3024 while (parent != null && !parent.canDefine_resultSaveLocalNum(self, caller)) { 3025 caller = self; 3026 self = parent; 3027 parent = self.getParent(); 3028 } 3029 return parent.Define_resultSaveLocalNum(self, caller); 3030 } 3031 3032 /** 3033 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:102 3034 * @apilevel internal 3035 * @return {@code true} if this node has an equation for the inherited attribute resultSaveLocalNum 3036 */ 3037 protected boolean canDefine_resultSaveLocalNum(ASTNode caller, ASTNode child) { 3038 return false; 3039 } 3040 /** 3041 * @apilevel internal 3042 */ 3043 public boolean Define_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) { 3044 ASTNode self = this; 3045 ASTNode parent = getParent(); 3046 while (parent != null && !parent.canDefine_mayUseAnnotationTarget(self, caller, name)) { 3047 caller = self; 3048 self = parent; 3049 parent = self.getParent(); 3050 } 3051 return parent.Define_mayUseAnnotationTarget(self, caller, name); 3052 } 3053 3054 /** 3055 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:98 3056 * @apilevel internal 3057 * @return {@code true} if this node has an equation for the inherited attribute mayUseAnnotationTarget 3058 */ 3059 protected boolean canDefine_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) { 3060 return false; 3061 } 3062 /** 3063 * @apilevel internal 3064 */ 3065 public ElementValue Define_lookupElementTypeValue(ASTNode caller, ASTNode child, String name) { 3066 ASTNode self = this; 3067 ASTNode parent = getParent(); 3068 while (parent != null && !parent.canDefine_lookupElementTypeValue(self, caller, name)) { 3069 caller = self; 3070 self = parent; 3071 parent = self.getParent(); 3072 } 3073 return parent.Define_lookupElementTypeValue(self, caller, name); 3074 } 3075 3076 /** 3077 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:225 3078 * @apilevel internal 3079 * @return {@code true} if this node has an equation for the inherited attribute lookupElementTypeValue 3080 */ 3081 protected boolean canDefine_lookupElementTypeValue(ASTNode caller, ASTNode child, String name) { 3082 return false; 3083 } 3084 /** 3085 * @apilevel internal 3086 */ 3087 public boolean Define_withinSuppressWarnings(ASTNode caller, ASTNode child, String annot) { 3088 ASTNode self = this; 3089 ASTNode parent = getParent(); 3090 while (parent != null && !parent.canDefine_withinSuppressWarnings(self, caller, annot)) { 3091 caller = self; 3092 self = parent; 3093 parent = self.getParent(); 3094 } 3095 return parent.Define_withinSuppressWarnings(self, caller, annot); 3096 } 3097 3098 /** 3099 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:344 3100 * @apilevel internal 3101 * @return {@code true} if this node has an equation for the inherited attribute withinSuppressWarnings 3102 */ 3103 protected boolean canDefine_withinSuppressWarnings(ASTNode caller, ASTNode child, String annot) { 3104 return false; 3105 } 3106 /** 3107 * @apilevel internal 3108 */ 3109 public boolean Define_withinDeprecatedAnnotation(ASTNode caller, ASTNode child) { 3110 ASTNode self = this; 3111 ASTNode parent = getParent(); 3112 while (parent != null && !parent.canDefine_withinDeprecatedAnnotation(self, caller)) { 3113 caller = self; 3114 self = parent; 3115 parent = self.getParent(); 3116 } 3117 return parent.Define_withinDeprecatedAnnotation(self, caller); 3118 } 3119 3120 /** 3121 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:451 3122 * @apilevel internal 3123 * @return {@code true} if this node has an equation for the inherited attribute withinDeprecatedAnnotation 3124 */ 3125 protected boolean canDefine_withinDeprecatedAnnotation(ASTNode caller, ASTNode child) { 3126 return false; 3127 } 3128 /** 3129 * @apilevel internal 3130 */ 3131 public Annotation Define_lookupAnnotation(ASTNode caller, ASTNode child, TypeDecl typeDecl) { 3132 ASTNode self = this; 3133 ASTNode parent = getParent(); 3134 while (parent != null && !parent.canDefine_lookupAnnotation(self, caller, typeDecl)) { 3135 caller = self; 3136 self = parent; 3137 parent = self.getParent(); 3138 } 3139 return parent.Define_lookupAnnotation(self, caller, typeDecl); 3140 } 3141 3142 /** 3143 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:508 3144 * @apilevel internal 3145 * @return {@code true} if this node has an equation for the inherited attribute lookupAnnotation 3146 */ 3147 protected boolean canDefine_lookupAnnotation(ASTNode caller, ASTNode child, TypeDecl typeDecl) { 3148 return false; 3149 } 3150 /** 3151 * @apilevel internal 3152 */ 3153 public TypeDecl Define_enclosingAnnotationDecl(ASTNode caller, ASTNode child) { 3154 ASTNode self = this; 3155 ASTNode parent = getParent(); 3156 while (parent != null && !parent.canDefine_enclosingAnnotationDecl(self, caller)) { 3157 caller = self; 3158 self = parent; 3159 parent = self.getParent(); 3160 } 3161 return parent.Define_enclosingAnnotationDecl(self, caller); 3162 } 3163 3164 /** 3165 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:545 3166 * @apilevel internal 3167 * @return {@code true} if this node has an equation for the inherited attribute enclosingAnnotationDecl 3168 */ 3169 protected boolean canDefine_enclosingAnnotationDecl(ASTNode caller, ASTNode child) { 3170 return false; 3171 } 3172 /** 3173 * @apilevel internal 3174 */ 3175 public TypeDecl Define_assignConvertedType(ASTNode caller, ASTNode child) { 3176 ASTNode self = this; 3177 ASTNode parent = getParent(); 3178 while (parent != null && !parent.canDefine_assignConvertedType(self, caller)) { 3179 caller = self; 3180 self = parent; 3181 parent = self.getParent(); 3182 } 3183 return parent.Define_assignConvertedType(self, caller); 3184 } 3185 3186 /** 3187 * @declaredat /home/jesper/git/extendj/java8/backend/ToClassInherited.jrag:40 3188 * @apilevel internal 3189 * @return {@code true} if this node has an equation for the inherited attribute assignConvertedType 3190 */ 3191 protected boolean canDefine_assignConvertedType(ASTNode caller, ASTNode child) { 3192 return false; 3193 } 3194 /** 3195 * @apilevel internal 3196 */ 3197 public boolean Define_inExtendsOrImplements(ASTNode caller, ASTNode child) { 3198 ASTNode self = this; 3199 ASTNode parent = getParent(); 3200 while (parent != null && !parent.canDefine_inExtendsOrImplements(self, caller)) { 3201 caller = self; 3202 self = parent; 3203 parent = self.getParent(); 3204 } 3205 return parent.Define_inExtendsOrImplements(self, caller); 3206 } 3207 3208 /** 3209 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:337 3210 * @apilevel internal 3211 * @return {@code true} if this node has an equation for the inherited attribute inExtendsOrImplements 3212 */ 3213 protected boolean canDefine_inExtendsOrImplements(ASTNode caller, ASTNode child) { 3214 return false; 3215 } 3216 /** 3217 * @apilevel internal 3218 */ 3219 public TypeDecl Define_typeWildcard(ASTNode caller, ASTNode child) { 3220 ASTNode self = this; 3221 ASTNode parent = getParent(); 3222 while (parent != null && !parent.canDefine_typeWildcard(self, caller)) { 3223 caller = self; 3224 self = parent; 3225 parent = self.getParent(); 3226 } 3227 return parent.Define_typeWildcard(self, caller); 3228 } 3229 3230 /** 3231 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1490 3232 * @apilevel internal 3233 * @return {@code true} if this node has an equation for the inherited attribute typeWildcard 3234 */ 3235 protected boolean canDefine_typeWildcard(ASTNode caller, ASTNode child) { 3236 return false; 3237 } 3238 /** 3239 * @apilevel internal 3240 */ 3241 public TypeDecl Define_lookupWildcardExtends(ASTNode caller, ASTNode child, TypeDecl typeDecl) { 3242 ASTNode self = this; 3243 ASTNode parent = getParent(); 3244 while (parent != null && !parent.canDefine_lookupWildcardExtends(self, caller, typeDecl)) { 3245 caller = self; 3246 self = parent; 3247 parent = self.getParent(); 3248 } 3249 return parent.Define_lookupWildcardExtends(self, caller, typeDecl); 3250 } 3251 3252 /** 3253 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1499 3254 * @apilevel internal 3255 * @return {@code true} if this node has an equation for the inherited attribute lookupWildcardExtends 3256 */ 3257 protected boolean canDefine_lookupWildcardExtends(ASTNode caller, ASTNode child, TypeDecl typeDecl) { 3258 return false; 3259 } 3260 /** 3261 * @apilevel internal 3262 */ 3263 public TypeDecl Define_lookupWildcardSuper(ASTNode caller, ASTNode child, TypeDecl typeDecl) { 3264 ASTNode self = this; 3265 ASTNode parent = getParent(); 3266 while (parent != null && !parent.canDefine_lookupWildcardSuper(self, caller, typeDecl)) { 3267 caller = self; 3268 self = parent; 3269 parent = self.getParent(); 3270 } 3271 return parent.Define_lookupWildcardSuper(self, caller, typeDecl); 3272 } 3273 3274 /** 3275 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1513 3276 * @apilevel internal 3277 * @return {@code true} if this node has an equation for the inherited attribute lookupWildcardSuper 3278 */ 3279 protected boolean canDefine_lookupWildcardSuper(ASTNode caller, ASTNode child, TypeDecl typeDecl) { 3280 return false; 3281 } 3282 /** 3283 * @apilevel internal 3284 */ 3285 public LUBType Define_lookupLUBType(ASTNode caller, ASTNode child, Collection bounds) { 3286 ASTNode self = this; 3287 ASTNode parent = getParent(); 3288 while (parent != null && !parent.canDefine_lookupLUBType(self, caller, bounds)) { 3289 caller = self; 3290 self = parent; 3291 parent = self.getParent(); 3292 } 3293 return parent.Define_lookupLUBType(self, caller, bounds); 3294 } 3295 3296 /** 3297 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1541 3298 * @apilevel internal 3299 * @return {@code true} if this node has an equation for the inherited attribute lookupLUBType 3300 */ 3301 protected boolean canDefine_lookupLUBType(ASTNode caller, ASTNode child, Collection bounds) { 3302 return false; 3303 } 3304 /** 3305 * @apilevel internal 3306 */ 3307 public GLBType Define_lookupGLBType(ASTNode caller, ASTNode child, ArrayList bounds) { 3308 ASTNode self = this; 3309 ASTNode parent = getParent(); 3310 while (parent != null && !parent.canDefine_lookupGLBType(self, caller, bounds)) { 3311 caller = self; 3312 self = parent; 3313 parent = self.getParent(); 3314 } 3315 return parent.Define_lookupGLBType(self, caller, bounds); 3316 } 3317 3318 /** 3319 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1582 3320 * @apilevel internal 3321 * @return {@code true} if this node has an equation for the inherited attribute lookupGLBType 3322 */ 3323 protected boolean canDefine_lookupGLBType(ASTNode caller, ASTNode child, ArrayList bounds) { 3324 return false; 3325 } 3326 /** 3327 * @apilevel internal 3328 */ 3329 public TypeDecl Define_genericDecl(ASTNode caller, ASTNode child) { 3330 ASTNode self = this; 3331 ASTNode parent = getParent(); 3332 while (parent != null && !parent.canDefine_genericDecl(self, caller)) { 3333 caller = self; 3334 self = parent; 3335 parent = self.getParent(); 3336 } 3337 return parent.Define_genericDecl(self, caller); 3338 } 3339 3340 /** 3341 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:82 3342 * @apilevel internal 3343 * @return {@code true} if this node has an equation for the inherited attribute genericDecl 3344 */ 3345 protected boolean canDefine_genericDecl(ASTNode caller, ASTNode child) { 3346 return false; 3347 } 3348 /** 3349 * @apilevel internal 3350 */ 3351 public boolean Define_variableArityValid(ASTNode caller, ASTNode child) { 3352 ASTNode self = this; 3353 ASTNode parent = getParent(); 3354 while (parent != null && !parent.canDefine_variableArityValid(self, caller)) { 3355 caller = self; 3356 self = parent; 3357 parent = self.getParent(); 3358 } 3359 return parent.Define_variableArityValid(self, caller); 3360 } 3361 3362 /** 3363 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableArityParameters.jrag:30 3364 * @apilevel internal 3365 * @return {@code true} if this node has an equation for the inherited attribute variableArityValid 3366 */ 3367 protected boolean canDefine_variableArityValid(ASTNode caller, ASTNode child) { 3368 return false; 3369 } 3370 /** 3371 * @apilevel internal 3372 */ 3373 public ClassInstanceExpr Define_getClassInstanceExpr(ASTNode caller, ASTNode child) { 3374 ASTNode self = this; 3375 ASTNode parent = getParent(); 3376 while (parent != null && !parent.canDefine_getClassInstanceExpr(self, caller)) { 3377 caller = self; 3378 self = parent; 3379 parent = self.getParent(); 3380 } 3381 return parent.Define_getClassInstanceExpr(self, caller); 3382 } 3383 3384 /** 3385 * @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:91 3386 * @apilevel internal 3387 * @return {@code true} if this node has an equation for the inherited attribute getClassInstanceExpr 3388 */ 3389 protected boolean canDefine_getClassInstanceExpr(ASTNode caller, ASTNode child) { 3390 return false; 3391 } 3392 /** 3393 * @apilevel internal 3394 */ 3395 public boolean Define_isAnonymousDecl(ASTNode caller, ASTNode child) { 3396 ASTNode self = this; 3397 ASTNode parent = getParent(); 3398 while (parent != null && !parent.canDefine_isAnonymousDecl(self, caller)) { 3399 caller = self; 3400 self = parent; 3401 parent = self.getParent(); 3402 } 3403 return parent.Define_isAnonymousDecl(self, caller); 3404 } 3405 3406 /** 3407 * @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:406 3408 * @apilevel internal 3409 * @return {@code true} if this node has an equation for the inherited attribute isAnonymousDecl 3410 */ 3411 protected boolean canDefine_isAnonymousDecl(ASTNode caller, ASTNode child) { 3412 return false; 3413 } 3414 /** 3415 * @apilevel internal 3416 */ 3417 public boolean Define_isExplicitGenericConstructorAccess(ASTNode caller, ASTNode child) { 3418 ASTNode self = this; 3419 ASTNode parent = getParent(); 3420 while (parent != null && !parent.canDefine_isExplicitGenericConstructorAccess(self, caller)) { 3421 caller = self; 3422 self = parent; 3423 parent = self.getParent(); 3424 } 3425 return parent.Define_isExplicitGenericConstructorAccess(self, caller); 3426 } 3427 3428 /** 3429 * @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:422 3430 * @apilevel internal 3431 * @return {@code true} if this node has an equation for the inherited attribute isExplicitGenericConstructorAccess 3432 */ 3433 protected boolean canDefine_isExplicitGenericConstructorAccess(ASTNode caller, ASTNode child) { 3434 return false; 3435 } 3436 /** 3437 * @apilevel internal 3438 */ 3439 public boolean Define_isCatchParam(ASTNode caller, ASTNode child) { 3440 ASTNode self = this; 3441 ASTNode parent = getParent(); 3442 while (parent != null && !parent.canDefine_isCatchParam(self, caller)) { 3443 caller = self; 3444 self = parent; 3445 parent = self.getParent(); 3446 } 3447 return parent.Define_isCatchParam(self, caller); 3448 } 3449 3450 /** 3451 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:210 3452 * @apilevel internal 3453 * @return {@code true} if this node has an equation for the inherited attribute isCatchParam 3454 */ 3455 protected boolean canDefine_isCatchParam(ASTNode caller, ASTNode child) { 3456 return false; 3457 } 3458 /** 3459 * @apilevel internal 3460 */ 3461 public CatchClause Define_catchClause(ASTNode caller, ASTNode child) { 3462 ASTNode self = this; 3463 ASTNode parent = getParent(); 3464 while (parent != null && !parent.canDefine_catchClause(self, caller)) { 3465 caller = self; 3466 self = parent; 3467 parent = self.getParent(); 3468 } 3469 return parent.Define_catchClause(self, caller); 3470 } 3471 3472 /** 3473 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:219 3474 * @apilevel internal 3475 * @return {@code true} if this node has an equation for the inherited attribute catchClause 3476 */ 3477 protected boolean canDefine_catchClause(ASTNode caller, ASTNode child) { 3478 return false; 3479 } 3480 /** 3481 * @apilevel internal 3482 */ 3483 public boolean Define_resourcePreviouslyDeclared(ASTNode caller, ASTNode child, String name) { 3484 ASTNode self = this; 3485 ASTNode parent = getParent(); 3486 while (parent != null && !parent.canDefine_resourcePreviouslyDeclared(self, caller, name)) { 3487 caller = self; 3488 self = parent; 3489 parent = self.getParent(); 3490 } 3491 return parent.Define_resourcePreviouslyDeclared(self, caller, name); 3492 } 3493 3494 /** 3495 * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:184 3496 * @apilevel internal 3497 * @return {@code true} if this node has an equation for the inherited attribute resourcePreviouslyDeclared 3498 */ 3499 protected boolean canDefine_resourcePreviouslyDeclared(ASTNode caller, ASTNode child, String name) { 3500 return false; 3501 } 3502 /** 3503 * @apilevel internal 3504 */ 3505 public TypeDecl Define_targetType(ASTNode caller, ASTNode child) { 3506 ASTNode self = this; 3507 ASTNode parent = getParent(); 3508 while (parent != null && !parent.canDefine_targetType(self, caller)) { 3509 caller = self; 3510 self = parent; 3511 parent = self.getParent(); 3512 } 3513 return parent.Define_targetType(self, caller); 3514 } 3515 3516 /** 3517 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:126 3518 * @apilevel internal 3519 * @return {@code true} if this node has an equation for the inherited attribute targetType 3520 */ 3521 protected boolean canDefine_targetType(ASTNode caller, ASTNode child) { 3522 return false; 3523 } 3524 /** 3525 * @apilevel internal 3526 */ 3527 public CompilationUnit Define_compilationUnit(ASTNode caller, ASTNode child) { 3528 ASTNode self = this; 3529 ASTNode parent = getParent(); 3530 while (parent != null && !parent.canDefine_compilationUnit(self, caller)) { 3531 caller = self; 3532 self = parent; 3533 parent = self.getParent(); 3534 } 3535 return parent.Define_compilationUnit(self, caller); 3536 } 3537 3538 /** 3539 * @declaredat /home/jesper/git/extendj/java4/frontend/ClassPath.jrag:79 3540 * @apilevel internal 3541 * @return {@code true} if this node has an equation for the inherited attribute compilationUnit 3542 */ 3543 protected boolean canDefine_compilationUnit(ASTNode caller, ASTNode child) { 3544 return false; 3545 } 3546 /** 3547 * @apilevel internal 3548 */ 3549 public SimpleSet Define_allImportedTypes(ASTNode caller, ASTNode child, String name) { 3550 ASTNode self = this; 3551 ASTNode parent = getParent(); 3552 while (parent != null && !parent.canDefine_allImportedTypes(self, caller, name)) { 3553 caller = self; 3554 self = parent; 3555 parent = self.getParent(); 3556 } 3557 return parent.Define_allImportedTypes(self, caller, name); 3558 } 3559 3560 /** 3561 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:53 3562 * @apilevel internal 3563 * @return {@code true} if this node has an equation for the inherited attribute allImportedTypes 3564 */ 3565 protected boolean canDefine_allImportedTypes(ASTNode caller, ASTNode child, String name) { 3566 return false; 3567 } 3568 /** 3569 * @apilevel internal 3570 */ 3571 public String Define_packageName(ASTNode caller, ASTNode child) { 3572 ASTNode self = this; 3573 ASTNode parent = getParent(); 3574 while (parent != null && !parent.canDefine_packageName(self, caller)) { 3575 caller = self; 3576 self = parent; 3577 parent = self.getParent(); 3578 } 3579 return parent.Define_packageName(self, caller); 3580 } 3581 3582 /** 3583 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:104 3584 * @apilevel internal 3585 * @return {@code true} if this node has an equation for the inherited attribute packageName 3586 */ 3587 protected boolean canDefine_packageName(ASTNode caller, ASTNode child) { 3588 return false; 3589 } 3590 /** 3591 * @apilevel internal 3592 */ 3593 public TypeDecl Define_enclosingType(ASTNode caller, ASTNode child) { 3594 ASTNode self = this; 3595 ASTNode parent = getParent(); 3596 while (parent != null && !parent.canDefine_enclosingType(self, caller)) { 3597 caller = self; 3598 self = parent; 3599 parent = self.getParent(); 3600 } 3601 return parent.Define_enclosingType(self, caller); 3602 } 3603 3604 /** 3605 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:715 3606 * @apilevel internal 3607 * @return {@code true} if this node has an equation for the inherited attribute enclosingType 3608 */ 3609 protected boolean canDefine_enclosingType(ASTNode caller, ASTNode child) { 3610 return false; 3611 } 3612 /** 3613 * @apilevel internal 3614 */ 3615 public boolean Define_isNestedType(ASTNode caller, ASTNode child) { 3616 ASTNode self = this; 3617 ASTNode parent = getParent(); 3618 while (parent != null && !parent.canDefine_isNestedType(self, caller)) { 3619 caller = self; 3620 self = parent; 3621 parent = self.getParent(); 3622 } 3623 return parent.Define_isNestedType(self, caller); 3624 } 3625 3626 /** 3627 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:714 3628 * @apilevel internal 3629 * @return {@code true} if this node has an equation for the inherited attribute isNestedType 3630 */ 3631 protected boolean canDefine_isNestedType(ASTNode caller, ASTNode child) { 3632 return false; 3633 } 3634 /** 3635 * @apilevel internal 3636 */ 3637 public boolean Define_isLocalClass(ASTNode caller, ASTNode child) { 3638 ASTNode self = this; 3639 ASTNode parent = getParent(); 3640 while (parent != null && !parent.canDefine_isLocalClass(self, caller)) { 3641 caller = self; 3642 self = parent; 3643 parent = self.getParent(); 3644 } 3645 return parent.Define_isLocalClass(self, caller); 3646 } 3647 3648 /** 3649 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:594 3650 * @apilevel internal 3651 * @return {@code true} if this node has an equation for the inherited attribute isLocalClass 3652 */ 3653 protected boolean canDefine_isLocalClass(ASTNode caller, ASTNode child) { 3654 return false; 3655 } 3656 /** 3657 * @apilevel internal 3658 */ 3659 public String Define_hostPackage(ASTNode caller, ASTNode child) { 3660 ASTNode self = this; 3661 ASTNode parent = getParent(); 3662 while (parent != null && !parent.canDefine_hostPackage(self, caller)) { 3663 caller = self; 3664 self = parent; 3665 parent = self.getParent(); 3666 } 3667 return parent.Define_hostPackage(self, caller); 3668 } 3669 3670 /** 3671 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:649 3672 * @apilevel internal 3673 * @return {@code true} if this node has an equation for the inherited attribute hostPackage 3674 */ 3675 protected boolean canDefine_hostPackage(ASTNode caller, ASTNode child) { 3676 return false; 3677 } 3678 /** 3679 * @apilevel internal 3680 */ 3681 public LambdaExpr Define_enclosingLambda(ASTNode caller, ASTNode child) { 3682 ASTNode self = this; 3683 ASTNode parent = getParent(); 3684 while (parent != null && !parent.canDefine_enclosingLambda(self, caller)) { 3685 caller = self; 3686 self = parent; 3687 parent = self.getParent(); 3688 } 3689 return parent.Define_enclosingLambda(self, caller); 3690 } 3691 3692 /** 3693 * @declaredat /home/jesper/git/extendj/java8/backend/ToClassInherited.jrag:34 3694 * @apilevel internal 3695 * @return {@code true} if this node has an equation for the inherited attribute enclosingLambda 3696 */ 3697 protected boolean canDefine_enclosingLambda(ASTNode caller, ASTNode child) { 3698 return false; 3699 } 3700 /** 3701 * @apilevel internal 3702 */ 3703 public boolean Define_assignmentContext(ASTNode caller, ASTNode child) { 3704 ASTNode self = this; 3705 ASTNode parent = getParent(); 3706 while (parent != null && !parent.canDefine_assignmentContext(self, caller)) { 3707 caller = self; 3708 self = parent; 3709 parent = self.getParent(); 3710 } 3711 return parent.Define_assignmentContext(self, caller); 3712 } 3713 3714 /** 3715 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:391 3716 * @apilevel internal 3717 * @return {@code true} if this node has an equation for the inherited attribute assignmentContext 3718 */ 3719 protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) { 3720 return false; 3721 } 3722 /** 3723 * @apilevel internal 3724 */ 3725 public boolean Define_invocationContext(ASTNode caller, ASTNode child) { 3726 ASTNode self = this; 3727 ASTNode parent = getParent(); 3728 while (parent != null && !parent.canDefine_invocationContext(self, caller)) { 3729 caller = self; 3730 self = parent; 3731 parent = self.getParent(); 3732 } 3733 return parent.Define_invocationContext(self, caller); 3734 } 3735 3736 /** 3737 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:392 3738 * @apilevel internal 3739 * @return {@code true} if this node has an equation for the inherited attribute invocationContext 3740 */ 3741 protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) { 3742 return false; 3743 } 3744 /** 3745 * @apilevel internal 3746 */ 3747 public boolean Define_castContext(ASTNode caller, ASTNode child) { 3748 ASTNode self = this; 3749 ASTNode parent = getParent(); 3750 while (parent != null && !parent.canDefine_castContext(self, caller)) { 3751 caller = self; 3752 self = parent; 3753 parent = self.getParent(); 3754 } 3755 return parent.Define_castContext(self, caller); 3756 } 3757 3758 /** 3759 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:393 3760 * @apilevel internal 3761 * @return {@code true} if this node has an equation for the inherited attribute castContext 3762 */ 3763 protected boolean canDefine_castContext(ASTNode caller, ASTNode child) { 3764 return false; 3765 } 3766 /** 3767 * @apilevel internal 3768 */ 3769 public boolean Define_stringContext(ASTNode caller, ASTNode child) { 3770 ASTNode self = this; 3771 ASTNode parent = getParent(); 3772 while (parent != null && !parent.canDefine_stringContext(self, caller)) { 3773 caller = self; 3774 self = parent; 3775 parent = self.getParent(); 3776 } 3777 return parent.Define_stringContext(self, caller); 3778 } 3779 3780 /** 3781 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:394 3782 * @apilevel internal 3783 * @return {@code true} if this node has an equation for the inherited attribute stringContext 3784 */ 3785 protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) { 3786 return false; 3787 } 3788 /** 3789 * @apilevel internal 3790 */ 3791 public boolean Define_numericContext(ASTNode caller, ASTNode child) { 3792 ASTNode self = this; 3793 ASTNode parent = getParent(); 3794 while (parent != null && !parent.canDefine_numericContext(self, caller)) { 3795 caller = self; 3796 self = parent; 3797 parent = self.getParent(); 3798 } 3799 return parent.Define_numericContext(self, caller); 3800 } 3801 3802 /** 3803 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:395 3804 * @apilevel internal 3805 * @return {@code true} if this node has an equation for the inherited attribute numericContext 3806 */ 3807 protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) { 3808 return false; 3809 } 3810 /** 3811 * @apilevel internal 3812 */ 3813 public int Define_typeVarPosition(ASTNode caller, ASTNode child) { 3814 ASTNode self = this; 3815 ASTNode parent = getParent(); 3816 while (parent != null && !parent.canDefine_typeVarPosition(self, caller)) { 3817 caller = self; 3818 self = parent; 3819 parent = self.getParent(); 3820 } 3821 return parent.Define_typeVarPosition(self, caller); 3822 } 3823 3824 /** 3825 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeVariablePositions.jrag:46 3826 * @apilevel internal 3827 * @return {@code true} if this node has an equation for the inherited attribute typeVarPosition 3828 */ 3829 protected boolean canDefine_typeVarPosition(ASTNode caller, ASTNode child) { 3830 return false; 3831 } 3832 /** 3833 * @apilevel internal 3834 */ 3835 public boolean Define_typeVarInMethod(ASTNode caller, ASTNode child) { 3836 ASTNode self = this; 3837 ASTNode parent = getParent(); 3838 while (parent != null && !parent.canDefine_typeVarInMethod(self, caller)) { 3839 caller = self; 3840 self = parent; 3841 parent = self.getParent(); 3842 } 3843 return parent.Define_typeVarInMethod(self, caller); 3844 } 3845 3846 /** 3847 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeVariablePositions.jrag:47 3848 * @apilevel internal 3849 * @return {@code true} if this node has an equation for the inherited attribute typeVarInMethod 3850 */ 3851 protected boolean canDefine_typeVarInMethod(ASTNode caller, ASTNode child) { 3852 return false; 3853 } 3854 /** 3855 * @apilevel internal 3856 */ 3857 public int Define_genericMethodLevel(ASTNode caller, ASTNode child) { 3858 ASTNode self = this; 3859 ASTNode parent = getParent(); 3860 while (parent != null && !parent.canDefine_genericMethodLevel(self, caller)) { 3861 caller = self; 3862 self = parent; 3863 parent = self.getParent(); 3864 } 3865 return parent.Define_genericMethodLevel(self, caller); 3866 } 3867 3868 /** 3869 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeVariablePositions.jrag:50 3870 * @apilevel internal 3871 * @return {@code true} if this node has an equation for the inherited attribute genericMethodLevel 3872 */ 3873 protected boolean canDefine_genericMethodLevel(ASTNode caller, ASTNode child) { 3874 return false; 3875 } 3876 /** 3877 * @apilevel internal 3878 */ 3879 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) { 3880 ASTNode self = this; 3881 ASTNode parent = getParent(); 3882 while (parent != null && !parent.canDefine_isDAbefore(self, caller, v, b)) { 3883 caller = self; 3884 self = parent; 3885 parent = self.getParent(); 3886 } 3887 return parent.Define_isDAbefore(self, caller, v, b); 3888 } 3889 3890 /** 3891 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:274 3892 * @apilevel internal 3893 * @return {@code true} if this node has an equation for the inherited attribute isDAbefore 3894 */ 3895 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) { 3896 return false; 3897 } 3898 /** 3899 * @apilevel internal 3900 */ 3901 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) { 3902 ASTNode self = this; 3903 ASTNode parent = getParent(); 3904 while (parent != null && !parent.canDefine_isDUbefore(self, caller, v, b)) { 3905 caller = self; 3906 self = parent; 3907 parent = self.getParent(); 3908 } 3909 return parent.Define_isDUbefore(self, caller, v, b); 3910 } 3911 3912 /** 3913 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:806 3914 * @apilevel internal 3915 * @return {@code true} if this node has an equation for the inherited attribute isDUbefore 3916 */ 3917 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) { 3918 return false; 3919 } 3920 /** 3921 * @apilevel internal 3922 */ 3923 public Stmt Define_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 3924 ASTNode self = this; 3925 ASTNode parent = getParent(); 3926 while (parent != null && !parent.canDefine_branchTarget(self, caller, branch)) { 3927 caller = self; 3928 self = parent; 3929 parent = self.getParent(); 3930 } 3931 return parent.Define_branchTarget(self, caller, branch); 3932 } 3933 3934 /** 3935 * @declaredat /home/jesper/git/extendj/java8/frontend/ExtraInheritedEqs.jrag:30 3936 * @apilevel internal 3937 * @return {@code true} if this node has an equation for the inherited attribute branchTarget 3938 */ 3939 protected boolean canDefine_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 3940 return false; 3941 } 3942 /** 3943 * @apilevel internal 3944 */ 3945 public FinallyHost Define_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) { 3946 ASTNode self = this; 3947 ASTNode parent = getParent(); 3948 while (parent != null && !parent.canDefine_enclosingFinally(self, caller, branch)) { 3949 caller = self; 3950 self = parent; 3951 parent = self.getParent(); 3952 } 3953 return parent.Define_enclosingFinally(self, caller, branch); 3954 } 3955 3956 /** 3957 * @declaredat /home/jesper/git/extendj/java8/frontend/ExtraInheritedEqs.jrag:29 3958 * @apilevel internal 3959 * @return {@code true} if this node has an equation for the inherited attribute enclosingFinally 3960 */ 3961 protected boolean canDefine_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) { 3962 return false; 3963 } 3964 /** 3965 * @apilevel internal 3966 */ 3967 public SimpleSet Define_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) { 3968 ASTNode self = this; 3969 ASTNode parent = getParent(); 3970 while (parent != null && !parent.canDefine_otherLocalClassDecls(self, caller, name)) { 3971 caller = self; 3972 self = parent; 3973 parent = self.getParent(); 3974 } 3975 return parent.Define_otherLocalClassDecls(self, caller, name); 3976 } 3977 3978 /** 3979 * @declaredat /home/jesper/git/extendj/java8/frontend/ExtraInheritedEqs.jrag:33 3980 * @apilevel internal 3981 * @return {@code true} if this node has an equation for the inherited attribute otherLocalClassDecls 3982 */ 3983 protected boolean canDefine_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) { 3984 return false; 3985 } 3986 /** 3987 * @apilevel internal 3988 */ 3989 public boolean Define_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) { 3990 ASTNode self = this; 3991 ASTNode parent = getParent(); 3992 while (parent != null && !parent.canDefine_leavesMonitor(self, caller, branch, monitor)) { 3993 caller = self; 3994 self = parent; 3995 parent = self.getParent(); 3996 } 3997 return parent.Define_leavesMonitor(self, caller, branch, monitor); 3998 } 3999 4000 /** 4001 * @declaredat /home/jesper/git/extendj/java8/backend/Tmp.jrag:29 4002 * @apilevel internal 4003 * @return {@code true} if this node has an equation for the inherited attribute leavesMonitor 4004 */ 4005 protected boolean canDefine_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) { 4006 return false; 4007 } 4008 /** 4009 * @apilevel internal 4010 */ 4011 public boolean Define_reachable(ASTNode caller, ASTNode child) { 4012 ASTNode self = this; 4013 ASTNode parent = getParent(); 4014 while (parent != null && !parent.canDefine_reachable(self, caller)) { 4015 caller = self; 4016 self = parent; 4017 parent = self.getParent(); 4018 } 4019 return parent.Define_reachable(self, caller); 4020 } 4021 4022 /** 4023 * @declaredat /home/jesper/git/extendj/java8/frontend/UnreachableStatements.jrag:29 4024 * @apilevel internal 4025 * @return {@code true} if this node has an equation for the inherited attribute reachable 4026 */ 4027 protected boolean canDefine_reachable(ASTNode caller, ASTNode child) { 4028 return false; 4029 } 4030 /** 4031 * @apilevel internal 4032 */ 4033 public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 4034 ASTNode self = this; 4035 ASTNode parent = getParent(); 4036 while (parent != null && !parent.canDefine_inhModifiedInScope(self, caller, var)) { 4037 caller = self; 4038 self = parent; 4039 parent = self.getParent(); 4040 } 4041 return parent.Define_inhModifiedInScope(self, caller, var); 4042 } 4043 4044 /** 4045 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:35 4046 * @apilevel internal 4047 * @return {@code true} if this node has an equation for the inherited attribute inhModifiedInScope 4048 */ 4049 protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 4050 return false; 4051 } 4052 /** 4053 * @apilevel internal 4054 */ 4055 public boolean Define_reachableCatchClause(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 4056 ASTNode self = this; 4057 ASTNode parent = getParent(); 4058 while (parent != null && !parent.canDefine_reachableCatchClause(self, caller, exceptionType)) { 4059 caller = self; 4060 self = parent; 4061 parent = self.getParent(); 4062 } 4063 return parent.Define_reachableCatchClause(self, caller, exceptionType); 4064 } 4065 4066 /** 4067 * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:143 4068 * @apilevel internal 4069 * @return {@code true} if this node has an equation for the inherited attribute reachableCatchClause 4070 */ 4071 protected boolean canDefine_reachableCatchClause(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 4072 return false; 4073 } 4074 /** 4075 * @apilevel internal 4076 */ 4077 public Collection<TypeDecl> Define_caughtExceptions(ASTNode caller, ASTNode child) { 4078 ASTNode self = this; 4079 ASTNode parent = getParent(); 4080 while (parent != null && !parent.canDefine_caughtExceptions(self, caller)) { 4081 caller = self; 4082 self = parent; 4083 parent = self.getParent(); 4084 } 4085 return parent.Define_caughtExceptions(self, caller); 4086 } 4087 4088 /** 4089 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:223 4090 * @apilevel internal 4091 * @return {@code true} if this node has an equation for the inherited attribute caughtExceptions 4092 */ 4093 protected boolean canDefine_caughtExceptions(ASTNode caller, ASTNode child) { 4094 return false; 4095 } 4096 /** 4097 * @apilevel internal 4098 */ 4099 public TypeDecl Define_inferredType(ASTNode caller, ASTNode child) { 4100 ASTNode self = this; 4101 ASTNode parent = getParent(); 4102 while (parent != null && !parent.canDefine_inferredType(self, caller)) { 4103 caller = self; 4104 self = parent; 4105 parent = self.getParent(); 4106 } 4107 return parent.Define_inferredType(self, caller); 4108 } 4109 4110 /** 4111 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:454 4112 * @apilevel internal 4113 * @return {@code true} if this node has an equation for the inherited attribute inferredType 4114 */ 4115 protected boolean canDefine_inferredType(ASTNode caller, ASTNode child) { 4116 return false; 4117 } 4118 }