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 * @declaredat /home/jesper/git/extendj/java4/grammar/Java.ast:63 027 * @production ClassDecl : {@link ReferenceType} ::= <span class="component">{@link Modifiers}</span> <span class="component"><ID:String></span> <span class="component">[SuperClass:{@link Access}]</span> <span class="component">Implements:{@link Access}*</span> <span class="component">{@link BodyDecl}*</span> <span class="component">[ImplicitConstructor:{@link ConstructorDecl}]</span>; 028 029 */ 030 public class ClassDecl extends ReferenceType implements Cloneable { 031 /** 032 * @aspect AccessControl 033 * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:175 034 */ 035 public void accessControl() { 036 super.accessControl(); 037 038 // 8.1.1.2 final Classes 039 TypeDecl typeDecl = superclass(); 040 if (!typeDecl.isUnknown() && !typeDecl.accessibleFromExtend(this)) { 041 errorf("class %s may not extend non accessible type %s", fullName(), typeDecl.fullName()); 042 } 043 044 if (hasSuperclass() && !superclass().accessibleFrom(this)) { 045 errorf("a superclass must be accessible which %s is not", superclass().name()); 046 } 047 048 // 8.1.4 049 for (int i = 0; i < getNumImplements(); i++) { 050 TypeDecl decl = getImplements(i).type(); 051 if (!decl.isCircular() && !decl.accessibleFrom(this)) { 052 errorf("class %s can not implement non accessible type %s", fullName(), decl.fullName()); 053 } 054 } 055 } 056 /** 057 * @aspect ErrorCheck 058 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:243 059 */ 060 public void collectErrors() { 061 super.collectErrors(); 062 if (hasImplicitConstructor()) { 063 getImplicitConstructor().collectErrors(); 064 } 065 } 066 /** 067 * @aspect Modifiers 068 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:122 069 */ 070 public void checkModifiers() { 071 super.checkModifiers(); 072 // 8.1.1.2 final Classes 073 TypeDecl typeDecl = superclass(); 074 if (!typeDecl.isUnknown() && typeDecl.isFinal()) { 075 errorf("class %s may not extend final class %s", fullName(), typeDecl.fullName()); 076 } 077 078 } 079 /** 080 * @aspect Java4PrettyPrint 081 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:362 082 */ 083 public void prettyPrint(PrettyPrinter out) { 084 if (hasDocComment()) { 085 out.print(docComment()); 086 } 087 if (!out.isNewLine()) { 088 out.println(); 089 } 090 out.print(getModifiers()); 091 out.print("class "); 092 out.print(getID()); 093 if (hasSuperClass()) { 094 out.print(" extends "); 095 out.print(getSuperClass()); 096 } 097 if (hasImplements()) { 098 out.print(" implements "); 099 out.join(getImplementss(), new PrettyPrinter.Joiner() { 100 @Override 101 public void printSeparator(PrettyPrinter out) { 102 out.print(", "); 103 } 104 }); 105 } 106 out.print(" {"); 107 out.println(); 108 out.indent(1); 109 out.join(getBodyDecls(), new PrettyPrinter.Joiner() { 110 @Override 111 public void printSeparator(PrettyPrinter out) { 112 out.println(); 113 out.println(); 114 } 115 }); 116 if (!out.isNewLine()) { 117 out.println(); 118 } 119 out.print("}"); 120 } 121 /** 122 * @aspect SuperClasses 123 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:647 124 */ 125 public boolean hasSuperclass() { 126 return !isObject(); 127 } 128 /** 129 * @aspect SuperClasses 130 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:651 131 */ 132 public TypeDecl superclass() { 133 if (isObject()) { 134 return unknownType(); 135 } else if (hasSuperClass() && !isCircular() && getSuperClass().type().isClassDecl()) { 136 return getSuperClass().type(); 137 } else { 138 return typeObject(); 139 } 140 } 141 /** 142 * @aspect SuperClasses 143 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:688 144 */ 145 public Iterator<TypeDecl> interfacesIterator() { 146 return new Iterator<TypeDecl>() { 147 public boolean hasNext() { 148 computeNextCurrent(); 149 return current != null; 150 } 151 public TypeDecl next() { 152 return current; 153 } 154 public void remove() { 155 throw new UnsupportedOperationException(); 156 } 157 private int index = 0; 158 private TypeDecl current = null; 159 private void computeNextCurrent() { 160 current = null; 161 if (isObject() || isCircular()) { 162 return; 163 } 164 while (index < getNumImplements()) { 165 TypeDecl typeDecl = getImplements(index++).type(); 166 if (!typeDecl.isCircular() && typeDecl.isInterfaceDecl()) { 167 current = typeDecl; 168 return; 169 } 170 } 171 } 172 }; 173 } 174 /** 175 * @aspect TypeHierarchyCheck 176 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:321 177 */ 178 public void refined_TypeHierarchyCheck_ClassDecl_typeCheck() { 179 super.typeCheck(); 180 181 // check if methods from superclass are incompatible with interface methods 182 for (Iterator<MethodDecl> iter = interfacesMethodsIterator(); iter.hasNext(); ) { 183 MethodDecl decl = iter.next(); 184 SimpleSet set = localMethodsSignature(decl.signature()); 185 Iterator i2 = set.iterator(); 186 boolean overridden = false; 187 while (i2.hasNext()) { 188 MethodDecl m = (MethodDecl) i2.next(); 189 // regardless of overriding 190 // 8.4.6.3 191 if (m.overrideCandidate(decl)) { 192 overridden = true; 193 if (!m.mayOverride(decl)) { 194 errorf("the return type of method %s in %s does not match the return type of" 195 + " method %s in %s and may thus not be overridden", 196 m.fullSignature(), m.hostType().typeName(), decl.fullSignature(), 197 decl.hostType().typeName()); 198 } 199 } 200 } 201 if (!overridden) { 202 set = ancestorMethods(decl.signature()); 203 for (i2 = set.iterator(); i2.hasNext(); ) { 204 MethodDecl m = (MethodDecl) i2.next(); 205 if (!m.isAbstract() && m.overrideCandidate(decl) && 206 !m.mayOverride(decl)) { 207 errorf("the return type of method %s in %s does not match the return type of" 208 + " method %s in %s and may thus not be overridden", 209 m.fullSignature(), m.hostType().typeName(), decl.fullSignature(), 210 decl.hostType().typeName()); 211 } 212 } 213 } 214 } 215 } 216 /** 217 * @aspect TypeHierarchyCheck 218 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:362 219 */ 220 public void refined_TypeHierarchyCheck_ClassDecl_nameCheck() { 221 super.nameCheck(); 222 if (hasSuperClass() && !getSuperClass().type().isClassDecl()) { 223 errorf("a class may only inherit another class, which %s is not", 224 getSuperClass().type().typeName()); 225 } 226 if (isObject() && hasSuperClass()) { 227 error("class Object may not have a superclass"); 228 } 229 if (isObject() && getNumImplements() != 0) { 230 error("class Object may not implement an interface"); 231 } 232 233 // 8.1.3 234 if (isCircular()) { 235 errorf("circular inheritance dependency in %s", typeName()); 236 } 237 238 // 8.1.4 239 HashSet set = new HashSet(); 240 for (int i = 0; i < getNumImplements(); i++) { 241 TypeDecl decl = getImplements(i).type(); 242 if (!decl.isInterfaceDecl() && !decl.isUnknown()) { 243 errorf("type %s can not implement the non-interface type %s", fullName(), decl.fullName()); 244 } 245 if (set.contains(decl)) { 246 errorf("type %s is mentionened multiple times in implements clause", decl.fullName()); 247 } 248 set.add(decl); 249 } 250 251 for (Iterator iter = interfacesMethodsIterator(); iter.hasNext(); ) { 252 MethodDecl m = (MethodDecl) iter.next(); 253 if (localMethodsSignature(m.signature()).isEmpty()) { 254 SimpleSet s = superclass().methodsSignature(m.signature()); 255 for (Iterator i2 = s.iterator(); i2.hasNext(); ) { 256 MethodDecl n = (MethodDecl) i2.next(); 257 if (n.accessibleFrom(this)) { 258 interfaceMethodCompatibleWithInherited(m, n); 259 } 260 } 261 if (s.isEmpty()) { 262 for (Iterator i2 = interfacesMethodsSignature(m.signature()).iterator(); i2.hasNext(); ) { 263 MethodDecl n = (MethodDecl) i2.next(); 264 // TODO don't report error twice 265 checkAbstractMethodDecls(m, n); 266 } 267 } 268 } 269 } 270 } 271 /** 272 * Check compatibility of interface method and superclass method. 273 * @param m interface method 274 * @param n superclass method 275 * @aspect TypeHierarchyCheck 276 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:419 277 */ 278 private void interfaceMethodCompatibleWithInherited(MethodDecl m, MethodDecl n) { 279 if (n.isAbstract()) { 280 checkAbstractMethodDecls(m, n); 281 } 282 if (n.isStatic()) { 283 error("Xa static method may not hide an instance method"); 284 } 285 if (!n.isAbstract() && !n.isPublic()) { 286 errorf("Xoverriding access modifier error for %s in %s and %s", 287 m.fullSignature(), m.hostType().typeName(), n.hostType().typeName()); 288 } 289 if (!n.mayOverride(m) && !m.mayOverride(m)) { 290 errorf("Xthe return type of method %s in %s does not match" 291 + " the return type of method %s in %s and may thus not be overridden", 292 m.fullSignature(), m.hostType().typeName(), n.fullSignature(), n.hostType().typeName()); 293 } 294 295 if (!n.isAbstract()) { 296 // n implements and overrides method m in the interface 297 // may not throw more checked exceptions 298 for (Access e: n.getExceptionList()) { 299 if (e.type().isCheckedException()) { 300 boolean found = false; 301 for (Access declException: m.getExceptionList()) { 302 if (e.type().instanceOf(declException.type())) { 303 found = true; 304 break; 305 } 306 } 307 if (!found) { 308 errorf("%s in %s may not throw more checked exceptions than overridden method %s in %s", 309 n.fullSignature(), n.hostType().typeName(), m.fullSignature(), 310 m.hostType().typeName()); 311 } 312 } 313 } 314 } 315 } 316 /** 317 * @aspect GenerateClassfile 318 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:59 319 */ 320 public void generateClassfile() { 321 super.generateClassfile(); 322 String fileName = destinationPath(); 323 if (program().options().verbose()) { 324 System.out.println("Writing class file to " + fileName); 325 } 326 try { 327 ConstantPool cp = constantPool(); 328 329 // force building of constant pool 330 cp.addClass(constantPoolName()); 331 if (hasSuperclass()) { 332 cp.addClass(superclass().constantPoolName()); 333 } 334 int numInterfaces = 0; 335 for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); numInterfaces++) { 336 cp.addClass(iter.next().constantPoolName()); 337 } 338 for (Iterator iter = bcFields().iterator(); iter.hasNext(); ) { 339 FieldDeclaration field = (FieldDeclaration) iter.next(); 340 cp.addUtf8(field.name()); 341 cp.addUtf8(field.type().typeDescriptor()); 342 field.attributes(); 343 } 344 if (needsEnclosing()) { 345 cp.addUtf8("this$0"); 346 cp.addUtf8(enclosing().typeDescriptor()); 347 cp.addUtf8("Synthetic"); 348 } 349 350 for (Iterator iter = bcMethods().iterator(); iter.hasNext(); ) { 351 BodyDecl decl = (BodyDecl) iter.next(); 352 decl.touchMethod(cp); 353 } 354 if (hasClinit()) { 355 cp.addUtf8("<clinit>"); 356 cp.addUtf8("()V"); 357 clinit_attributes(); 358 } 359 attributes(); 360 361 // Actual ClassFile generation 362 File dest = new File(fileName); 363 File parentFile = dest.getParentFile(); 364 if (parentFile != null) { 365 parentFile.mkdirs(); 366 } 367 FileOutputStream f = new FileOutputStream(fileName); 368 DataOutputStream out = new DataOutputStream(new BufferedOutputStream(f)); 369 out.writeInt(magicHeader()); 370 out.writeChar(minorVersion()); 371 out.writeChar(majorVersion()); 372 cp.emit(out); 373 int flags = flags(); 374 if (isNestedType()) { 375 flags = mangledFlags(flags); 376 } 377 flags |= Modifiers.ACC_SUPER; 378 out.writeChar(flags); 379 out.writeChar(cp.addClass(constantPoolName())); 380 out.writeChar(hasSuperclass() ? cp.addClass(superclass().constantPoolName()) : 0); 381 out.writeChar(numInterfaces); 382 for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); ) { 383 out.writeChar(cp.addClass(iter.next().constantPoolName())); 384 } 385 Collection fields = bcFields(); 386 out.writeChar(fields.size() + (needsEnclosing() ? 1 : 0)); 387 for (Iterator iter = fields.iterator(); iter.hasNext(); ) { 388 FieldDeclaration field = (FieldDeclaration) iter.next(); 389 out.writeChar(field.flags()); 390 out.writeChar(cp.addUtf8(field.name())); 391 out.writeChar(cp.addUtf8(field.type().typeDescriptor())); 392 out.writeChar(field.attributes().size()); 393 for (Iterator itera = field.attributes().iterator(); itera.hasNext();) { 394 ((Attribute) itera.next()).emit(out); 395 } 396 } 397 if (needsEnclosing()) { 398 out.writeChar(0 /*Modifiers.ACC_PRIVATE*/); 399 out.writeChar(cp.addUtf8("this$0")); 400 out.writeChar(cp.addUtf8(enclosing().typeDescriptor())); 401 out.writeChar(1); 402 new SyntheticAttribute(cp).emit(out); 403 404 } 405 406 Collection methods = bcMethods(); 407 out.writeChar(methods.size() + (hasClinit() ? 1 : 0)); 408 for (Iterator iter = methods.iterator(); iter.hasNext(); ) { 409 BodyDecl b = (BodyDecl) iter.next(); 410 b.generateMethod(out, cp); 411 } 412 if (hasClinit()) { 413 out.writeChar(Modifiers.ACC_STATIC); 414 out.writeChar(cp.addUtf8("<clinit>")); 415 out.writeChar(cp.addUtf8("()V")); 416 out.writeChar(clinit_attributes().size()); 417 for (Iterator itera = clinit_attributes().iterator(); itera.hasNext();) { 418 ((Attribute) itera.next()).emit(out); 419 } 420 } 421 out.writeChar(attributes().size()); 422 for (Iterator itera = attributes().iterator(); itera.hasNext();) { 423 ((Attribute) itera.next()).emit(out); 424 } 425 426 out.close(); 427 } catch (IOException e) { 428 e.printStackTrace(); 429 } 430 } 431 /** 432 * @aspect Transformations 433 * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:56 434 */ 435 public void transformation() { 436 super.transformation(); 437 if (hasImplicitConstructor()) { 438 getImplicitConstructor().transformation(); 439 } 440 } 441 /** 442 * @aspect Generics 443 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:231 444 */ 445 public TypeDecl makeGeneric(Signatures.ClassSignature s) { 446 // NOTE: we are overwriting List- and Opt- children here using setSuperClassOpt 447 // and setImplementsList. This is dangerous since those children are in some 448 // cases NTAs, and we should not use set methods to try to overwrite NTA values. 449 // However, we have to do this here in order to not trigger rewrites that in 450 // turn need to access certain (inherited) lookup attributes, and we are reasonably 451 // sure that we are in fact not overwriting NTA children. We exclude EnumDecl here 452 // because its [SuperClass] and Implements* are in fact NTAs. 453 // /Jesper 2015-01-22 454 if (this instanceof EnumDecl) { 455 return this; // Enum superclass and superinterfaces are NTAs. 456 } 457 if (s.hasFormalTypeParameters()) { 458 ASTNode node = getParent(); 459 int index = node.getIndexOfChild(this); 460 node.setChild( 461 new GenericClassDecl( 462 getModifiersNoTransform(), 463 getID(), 464 s.hasSuperclassSignature() 465 ? new Opt(s.superclassSignature()) 466 : getSuperClassOptNoTransform(), 467 s.hasSuperinterfaceSignature() 468 ? s.superinterfaceSignature() 469 : getImplementsListNoTransform(), 470 getBodyDeclListNoTransform(), 471 s.typeParameters() 472 ), 473 index 474 ); 475 return (TypeDecl) node.getChildNoTransform(index); 476 } else { 477 if (s.hasSuperclassSignature()) { 478 setSuperClassOpt(new Opt(s.superclassSignature())); 479 } 480 if (s.hasSuperinterfaceSignature()) { 481 setImplementsList(s.superinterfaceSignature()); 482 } 483 return this; 484 } 485 } 486 /** 487 * @aspect LookupParTypeDecl 488 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1424 489 */ 490 public ClassDecl substitutedClassDecl(Parameterization parTypeDecl) { 491 return new ClassDeclSubstituted( 492 (Modifiers) getModifiers().treeCopyNoTransform(), 493 getID(), 494 hasSuperClass() ? new Opt(getSuperClass().type().substitute(parTypeDecl)) : new Opt(), 495 getImplementsList().substitute(parTypeDecl), 496 this 497 ); 498 } 499 /** 500 * @declaredat ASTNode:1 501 */ 502 public ClassDecl() { 503 super(); 504 } 505 /** 506 * Initializes the child array to the correct size. 507 * Initializes List and Opt nta children. 508 * @apilevel internal 509 * @ast method 510 * @declaredat ASTNode:10 511 */ 512 public void init$Children() { 513 children = new ASTNode[5]; 514 setChild(new Opt(), 1); 515 setChild(new List(), 2); 516 setChild(new List(), 3); 517 setChild(new Opt(), 4); 518 } 519 /** 520 * @declaredat ASTNode:17 521 */ 522 public ClassDecl(Modifiers p0, String p1, Opt<Access> p2, List<Access> p3, List<BodyDecl> p4) { 523 setChild(p0, 0); 524 setID(p1); 525 setChild(p2, 1); 526 setChild(p3, 2); 527 setChild(p4, 3); 528 } 529 /** 530 * @declaredat ASTNode:24 531 */ 532 public ClassDecl(Modifiers p0, beaver.Symbol p1, Opt<Access> p2, List<Access> p3, List<BodyDecl> p4) { 533 setChild(p0, 0); 534 setID(p1); 535 setChild(p2, 1); 536 setChild(p3, 2); 537 setChild(p4, 3); 538 } 539 /** 540 * @apilevel low-level 541 * @declaredat ASTNode:34 542 */ 543 protected int numChildren() { 544 return 4; 545 } 546 /** 547 * @apilevel internal 548 * @declaredat ASTNode:40 549 */ 550 public boolean mayHaveRewrite() { 551 return false; 552 } 553 /** 554 * @apilevel internal 555 * @declaredat ASTNode:46 556 */ 557 public void flushAttrCache() { 558 super.flushAttrCache(); 559 constructors_reset(); 560 getImplicitConstructorOpt_reset(); 561 methodsSignatureMap_reset(); 562 ancestorMethods_String_reset(); 563 memberTypes_String_reset(); 564 memberFieldsMap_reset(); 565 memberFields_String_reset(); 566 unimplementedMethods_reset(); 567 hasAbstract_reset(); 568 castingConversionTo_TypeDecl_reset(); 569 isString_reset(); 570 isObject_reset(); 571 instanceOf_TypeDecl_reset(); 572 isCircular_reset(); 573 typeDescriptor_reset(); 574 erasedAncestorMethodsMap_reset(); 575 implementedInterfaces_reset(); 576 subtype_TypeDecl_reset(); 577 needsSignatureAttribute_reset(); 578 classSignature_reset(); 579 strictSubtype_TypeDecl_reset(); 580 hasOverridingMethodInSuper_MethodDecl_reset(); 581 } 582 /** 583 * @apilevel internal 584 * @declaredat ASTNode:74 585 */ 586 public void flushCollectionCache() { 587 super.flushCollectionCache(); 588 } 589 /** 590 * @apilevel internal 591 * @declaredat ASTNode:80 592 */ 593 public void flushRewriteCache() { 594 super.flushRewriteCache(); 595 } 596 /** 597 * @apilevel internal 598 * @declaredat ASTNode:86 599 */ 600 public ClassDecl clone() throws CloneNotSupportedException { 601 ClassDecl node = (ClassDecl) super.clone(); 602 return node; 603 } 604 /** 605 * @apilevel internal 606 * @declaredat ASTNode:93 607 */ 608 public ClassDecl copy() { 609 try { 610 ClassDecl node = (ClassDecl) clone(); 611 node.parent = null; 612 if (children != null) { 613 node.children = (ASTNode[]) children.clone(); 614 } 615 return node; 616 } catch (CloneNotSupportedException e) { 617 throw new Error("Error: clone not supported for " + getClass().getName()); 618 } 619 } 620 /** 621 * Create a deep copy of the AST subtree at this node. 622 * The copy is dangling, i.e. has no parent. 623 * @return dangling copy of the subtree at this node 624 * @apilevel low-level 625 * @deprecated Please use treeCopy or treeCopyNoTransform instead 626 * @declaredat ASTNode:112 627 */ 628 @Deprecated 629 public ClassDecl fullCopy() { 630 return treeCopyNoTransform(); 631 } 632 /** 633 * Create a deep copy of the AST subtree at this node. 634 * The copy is dangling, i.e. has no parent. 635 * @return dangling copy of the subtree at this node 636 * @apilevel low-level 637 * @declaredat ASTNode:122 638 */ 639 public ClassDecl treeCopyNoTransform() { 640 ClassDecl tree = (ClassDecl) copy(); 641 if (children != null) { 642 for (int i = 0; i < children.length; ++i) { 643 switch (i) { 644 case 4: 645 tree.children[i] = new Opt(); 646 continue; 647 } 648 ASTNode child = (ASTNode) children[i]; 649 if (child != null) { 650 child = child.treeCopyNoTransform(); 651 tree.setChild(child, i); 652 } 653 } 654 } 655 return tree; 656 } 657 /** 658 * Create a deep copy of the AST subtree at this node. 659 * The subtree of this node is traversed to trigger rewrites before copy. 660 * The copy is dangling, i.e. has no parent. 661 * @return dangling copy of the subtree at this node 662 * @apilevel low-level 663 * @declaredat ASTNode:147 664 */ 665 public ClassDecl treeCopy() { 666 doFullTraversal(); 667 return treeCopyNoTransform(); 668 } 669 /** 670 * @apilevel internal 671 * @declaredat ASTNode:154 672 */ 673 protected boolean is$Equal(ASTNode node) { 674 return super.is$Equal(node) && (tokenString_ID == ((ClassDecl)node).tokenString_ID); 675 } 676 /** 677 * Replaces the Modifiers child. 678 * @param node The new node to replace the Modifiers child. 679 * @apilevel high-level 680 */ 681 public void setModifiers(Modifiers node) { 682 setChild(node, 0); 683 } 684 /** 685 * Retrieves the Modifiers child. 686 * @return The current node used as the Modifiers child. 687 * @apilevel high-level 688 */ 689 @ASTNodeAnnotation.Child(name="Modifiers") 690 public Modifiers getModifiers() { 691 return (Modifiers) getChild(0); 692 } 693 /** 694 * Retrieves the Modifiers child. 695 * <p><em>This method does not invoke AST transformations.</em></p> 696 * @return The current node used as the Modifiers child. 697 * @apilevel low-level 698 */ 699 public Modifiers getModifiersNoTransform() { 700 return (Modifiers) getChildNoTransform(0); 701 } 702 /** 703 * Replaces the lexeme ID. 704 * @param value The new value for the lexeme ID. 705 * @apilevel high-level 706 */ 707 public void setID(String value) { 708 tokenString_ID = value; 709 } 710 /** 711 * JastAdd-internal setter for lexeme ID using the Beaver parser. 712 * @param symbol Symbol containing the new value for the lexeme ID 713 * @apilevel internal 714 */ 715 public void setID(beaver.Symbol symbol) { 716 if (symbol.value != null && !(symbol.value instanceof String)) 717 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 718 tokenString_ID = (String)symbol.value; 719 IDstart = symbol.getStart(); 720 IDend = symbol.getEnd(); 721 } 722 /** 723 * Retrieves the value for the lexeme ID. 724 * @return The value for the lexeme ID. 725 * @apilevel high-level 726 */ 727 @ASTNodeAnnotation.Token(name="ID") 728 public String getID() { 729 return tokenString_ID != null ? tokenString_ID : ""; 730 } 731 /** 732 * Replaces the optional node for the SuperClass child. This is the <code>Opt</code> 733 * node containing the child SuperClass, not the actual child! 734 * @param opt The new node to be used as the optional node for the SuperClass child. 735 * @apilevel low-level 736 */ 737 public void setSuperClassOpt(Opt<Access> opt) { 738 setChild(opt, 1); 739 } 740 /** 741 * Replaces the (optional) SuperClass child. 742 * @param node The new node to be used as the SuperClass child. 743 * @apilevel high-level 744 */ 745 public void setSuperClass(Access node) { 746 getSuperClassOpt().setChild(node, 0); 747 } 748 /** 749 * Check whether the optional SuperClass child exists. 750 * @return {@code true} if the optional SuperClass child exists, {@code false} if it does not. 751 * @apilevel high-level 752 */ 753 public boolean hasSuperClass() { 754 return getSuperClassOpt().getNumChild() != 0; 755 } 756 /** 757 * Retrieves the (optional) SuperClass child. 758 * @return The SuperClass child, if it exists. Returns {@code null} otherwise. 759 * @apilevel low-level 760 */ 761 public Access getSuperClass() { 762 return (Access) getSuperClassOpt().getChild(0); 763 } 764 /** 765 * Retrieves the optional node for the SuperClass child. This is the <code>Opt</code> node containing the child SuperClass, not the actual child! 766 * @return The optional node for child the SuperClass child. 767 * @apilevel low-level 768 */ 769 @ASTNodeAnnotation.OptChild(name="SuperClass") 770 public Opt<Access> getSuperClassOpt() { 771 return (Opt<Access>) getChild(1); 772 } 773 /** 774 * Retrieves the optional node for child SuperClass. This is the <code>Opt</code> node containing the child SuperClass, not the actual child! 775 * <p><em>This method does not invoke AST transformations.</em></p> 776 * @return The optional node for child SuperClass. 777 * @apilevel low-level 778 */ 779 public Opt<Access> getSuperClassOptNoTransform() { 780 return (Opt<Access>) getChildNoTransform(1); 781 } 782 /** 783 * Replaces the Implements list. 784 * @param list The new list node to be used as the Implements list. 785 * @apilevel high-level 786 */ 787 public void setImplementsList(List<Access> list) { 788 setChild(list, 2); 789 } 790 /** 791 * Retrieves the number of children in the Implements list. 792 * @return Number of children in the Implements list. 793 * @apilevel high-level 794 */ 795 public int getNumImplements() { 796 return getImplementsList().getNumChild(); 797 } 798 /** 799 * Retrieves the number of children in the Implements list. 800 * Calling this method will not trigger rewrites. 801 * @return Number of children in the Implements list. 802 * @apilevel low-level 803 */ 804 public int getNumImplementsNoTransform() { 805 return getImplementsListNoTransform().getNumChildNoTransform(); 806 } 807 /** 808 * Retrieves the element at index {@code i} in the Implements list. 809 * @param i Index of the element to return. 810 * @return The element at position {@code i} in the Implements list. 811 * @apilevel high-level 812 */ 813 public Access getImplements(int i) { 814 return (Access) getImplementsList().getChild(i); 815 } 816 /** 817 * Check whether the Implements list has any children. 818 * @return {@code true} if it has at least one child, {@code false} otherwise. 819 * @apilevel high-level 820 */ 821 public boolean hasImplements() { 822 return getImplementsList().getNumChild() != 0; 823 } 824 /** 825 * Append an element to the Implements list. 826 * @param node The element to append to the Implements list. 827 * @apilevel high-level 828 */ 829 public void addImplements(Access node) { 830 List<Access> list = (parent == null) ? getImplementsListNoTransform() : getImplementsList(); 831 list.addChild(node); 832 } 833 /** 834 * @apilevel low-level 835 */ 836 public void addImplementsNoTransform(Access node) { 837 List<Access> list = getImplementsListNoTransform(); 838 list.addChild(node); 839 } 840 /** 841 * Replaces the Implements list element at index {@code i} with the new node {@code node}. 842 * @param node The new node to replace the old list element. 843 * @param i The list index of the node to be replaced. 844 * @apilevel high-level 845 */ 846 public void setImplements(Access node, int i) { 847 List<Access> list = getImplementsList(); 848 list.setChild(node, i); 849 } 850 /** 851 * Retrieves the Implements list. 852 * @return The node representing the Implements list. 853 * @apilevel high-level 854 */ 855 @ASTNodeAnnotation.ListChild(name="Implements") 856 public List<Access> getImplementsList() { 857 List<Access> list = (List<Access>) getChild(2); 858 return list; 859 } 860 /** 861 * Retrieves the Implements list. 862 * <p><em>This method does not invoke AST transformations.</em></p> 863 * @return The node representing the Implements list. 864 * @apilevel low-level 865 */ 866 public List<Access> getImplementsListNoTransform() { 867 return (List<Access>) getChildNoTransform(2); 868 } 869 /** 870 * Retrieves the Implements list. 871 * @return The node representing the Implements list. 872 * @apilevel high-level 873 */ 874 public List<Access> getImplementss() { 875 return getImplementsList(); 876 } 877 /** 878 * Retrieves the Implements list. 879 * <p><em>This method does not invoke AST transformations.</em></p> 880 * @return The node representing the Implements list. 881 * @apilevel low-level 882 */ 883 public List<Access> getImplementssNoTransform() { 884 return getImplementsListNoTransform(); 885 } 886 /** 887 * Replaces the BodyDecl list. 888 * @param list The new list node to be used as the BodyDecl list. 889 * @apilevel high-level 890 */ 891 public void setBodyDeclList(List<BodyDecl> list) { 892 setChild(list, 3); 893 } 894 /** 895 * Retrieves the number of children in the BodyDecl list. 896 * @return Number of children in the BodyDecl list. 897 * @apilevel high-level 898 */ 899 public int getNumBodyDecl() { 900 return getBodyDeclList().getNumChild(); 901 } 902 /** 903 * Retrieves the number of children in the BodyDecl list. 904 * Calling this method will not trigger rewrites. 905 * @return Number of children in the BodyDecl list. 906 * @apilevel low-level 907 */ 908 public int getNumBodyDeclNoTransform() { 909 return getBodyDeclListNoTransform().getNumChildNoTransform(); 910 } 911 /** 912 * Retrieves the element at index {@code i} in the BodyDecl list. 913 * @param i Index of the element to return. 914 * @return The element at position {@code i} in the BodyDecl list. 915 * @apilevel high-level 916 */ 917 public BodyDecl getBodyDecl(int i) { 918 return (BodyDecl) getBodyDeclList().getChild(i); 919 } 920 /** 921 * Check whether the BodyDecl list has any children. 922 * @return {@code true} if it has at least one child, {@code false} otherwise. 923 * @apilevel high-level 924 */ 925 public boolean hasBodyDecl() { 926 return getBodyDeclList().getNumChild() != 0; 927 } 928 /** 929 * Append an element to the BodyDecl list. 930 * @param node The element to append to the BodyDecl list. 931 * @apilevel high-level 932 */ 933 public void addBodyDecl(BodyDecl node) { 934 List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList(); 935 list.addChild(node); 936 } 937 /** 938 * @apilevel low-level 939 */ 940 public void addBodyDeclNoTransform(BodyDecl node) { 941 List<BodyDecl> list = getBodyDeclListNoTransform(); 942 list.addChild(node); 943 } 944 /** 945 * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}. 946 * @param node The new node to replace the old list element. 947 * @param i The list index of the node to be replaced. 948 * @apilevel high-level 949 */ 950 public void setBodyDecl(BodyDecl node, int i) { 951 List<BodyDecl> list = getBodyDeclList(); 952 list.setChild(node, i); 953 } 954 /** 955 * Retrieves the BodyDecl list. 956 * @return The node representing the BodyDecl list. 957 * @apilevel high-level 958 */ 959 @ASTNodeAnnotation.ListChild(name="BodyDecl") 960 public List<BodyDecl> getBodyDeclList() { 961 List<BodyDecl> list = (List<BodyDecl>) getChild(3); 962 return list; 963 } 964 /** 965 * Retrieves the BodyDecl list. 966 * <p><em>This method does not invoke AST transformations.</em></p> 967 * @return The node representing the BodyDecl list. 968 * @apilevel low-level 969 */ 970 public List<BodyDecl> getBodyDeclListNoTransform() { 971 return (List<BodyDecl>) getChildNoTransform(3); 972 } 973 /** 974 * Retrieves the BodyDecl list. 975 * @return The node representing the BodyDecl list. 976 * @apilevel high-level 977 */ 978 public List<BodyDecl> getBodyDecls() { 979 return getBodyDeclList(); 980 } 981 /** 982 * Retrieves the BodyDecl list. 983 * <p><em>This method does not invoke AST transformations.</em></p> 984 * @return The node representing the BodyDecl list. 985 * @apilevel low-level 986 */ 987 public List<BodyDecl> getBodyDeclsNoTransform() { 988 return getBodyDeclListNoTransform(); 989 } 990 /** 991 * Replaces the (optional) ImplicitConstructor child. 992 * @param node The new node to be used as the ImplicitConstructor child. 993 * @apilevel high-level 994 */ 995 public void setImplicitConstructor(ConstructorDecl node) { 996 getImplicitConstructorOpt().setChild(node, 0); 997 } 998 /** 999 * Check whether the optional ImplicitConstructor child exists. 1000 * @return {@code true} if the optional ImplicitConstructor child exists, {@code false} if it does not. 1001 * @apilevel high-level 1002 */ 1003 public boolean hasImplicitConstructor() { 1004 return getImplicitConstructorOpt().getNumChild() != 0; 1005 } 1006 /** 1007 * Retrieves the (optional) ImplicitConstructor child. 1008 * @return The ImplicitConstructor child, if it exists. Returns {@code null} otherwise. 1009 * @apilevel low-level 1010 */ 1011 public ConstructorDecl getImplicitConstructor() { 1012 return (ConstructorDecl) getImplicitConstructorOpt().getChild(0); 1013 } 1014 /** 1015 * Retrieves the optional node for child ImplicitConstructor. This is the <code>Opt</code> node containing the child ImplicitConstructor, not the actual child! 1016 * <p><em>This method does not invoke AST transformations.</em></p> 1017 * @return The optional node for child ImplicitConstructor. 1018 * @apilevel low-level 1019 */ 1020 public Opt<ConstructorDecl> getImplicitConstructorOptNoTransform() { 1021 return (Opt<ConstructorDecl>) getChildNoTransform(4); 1022 } 1023 /** 1024 * Retrieves the child position of the optional child ImplicitConstructor. 1025 * @return The the child position of the optional child ImplicitConstructor. 1026 * @apilevel low-level 1027 */ 1028 protected int getImplicitConstructorOptChildPosition() { 1029 return 4; 1030 } 1031 /** 1032 * @aspect GenericsTypeCheck 1033 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:563 1034 */ 1035 1036 public void typeCheck() { 1037 refined_TypeHierarchyCheck_ClassDecl_typeCheck(); 1038 1039 if (hasSuperclass()) { 1040 // JLS SE7 8.4.8.4 1041 // check for duplicate methods inherited from parameterized supertype 1042 if (superclass().isParameterizedType()) { 1043 Map<String,SimpleSet> localMap = localMethodsSignatureMap(); 1044 Map<String,SimpleSet> methodMap = superclass().localMethodsSignatureMap(); 1045 for (Map.Entry<String,SimpleSet> entry: methodMap.entrySet()) { 1046 String signature = entry.getKey(); 1047 if (!localMap.containsKey(signature)) { 1048 // not locally overridden 1049 SimpleSet set = entry.getValue(); 1050 Iterator iter = set.iterator(); 1051 iter.next(); 1052 while (iter.hasNext()) { 1053 MethodDecl m = (MethodDecl) iter.next(); 1054 errorf("method with signature %s is multiply declared when inherited from %s", 1055 signature, superclass().typeName()); 1056 } 1057 } 1058 } 1059 } 1060 } 1061 } 1062 /** 1063 * @aspect Java8NameCheck 1064 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:311 1065 */ 1066 1067 public void nameCheck() { 1068 refined_TypeHierarchyCheck_ClassDecl_nameCheck(); 1069 for (Iterator<SimpleSet> iter = methodsSignatureMap().values().iterator(); iter.hasNext(); ) { 1070 SimpleSet set = iter.next(); 1071 if (set.size() > 1) { 1072 Iterator i2 = set.iterator(); 1073 boolean foundClassAbstract = false; 1074 MethodDecl foundNonAbstract = null; 1075 while (i2.hasNext()) { 1076 MethodDecl m = (MethodDecl) i2.next(); 1077 if (!m.isAbstract()) { 1078 foundNonAbstract = m; 1079 } else { 1080 if (m.hostType().isClassDecl() && m.hostType() != this) { 1081 foundClassAbstract = true; 1082 } 1083 } 1084 } 1085 // 8.4.8.1 1086 if (foundNonAbstract != null && !foundClassAbstract) { 1087 errorf("Method %s is multiply declared in %s", 1088 foundNonAbstract.fullSignature(), typeName()); 1089 } 1090 } 1091 } 1092 } 1093 /** 1094 * @aspect TypeConversion 1095 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:112 1096 */ 1097 private boolean refined_TypeConversion_ClassDecl_castingConversionTo_TypeDecl(TypeDecl type) 1098 { 1099 if (type.isArrayDecl()) { 1100 return isObject(); 1101 } else if (type.isClassDecl()) { 1102 return this == type || instanceOf(type) || type.instanceOf(this); 1103 } else if (type.isInterfaceDecl()) { 1104 return !isFinal() || instanceOf(type); 1105 } else return super.castingConversionTo(type); 1106 } 1107 /** 1108 * @aspect Generics 1109 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:81 1110 */ 1111 private boolean refined_Generics_ClassDecl_castingConversionTo_TypeDecl(TypeDecl type) 1112 { 1113 TypeDecl S = this; 1114 TypeDecl T = type; 1115 if (T instanceof TypeVariable) { 1116 TypeVariable t = (TypeVariable) T; 1117 if (t.getNumTypeBound() == 0) { 1118 return true; 1119 } 1120 for (int i = 0; i < t.getNumTypeBound(); i++) { 1121 if (castingConversionTo(t.getTypeBound(i).type())) { 1122 return true; 1123 } 1124 } 1125 return false; 1126 } 1127 if (T.isClassDecl() && (S.erasure() != S || T.erasure() != T)) { 1128 return S.erasure().castingConversionTo(T.erasure()); 1129 } 1130 return refined_TypeConversion_ClassDecl_castingConversionTo_TypeDecl(type); 1131 } 1132 /** 1133 * @attribute syn 1134 * @aspect ConstantExpression 1135 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:72 1136 */ 1137 @ASTNodeAnnotation.Attribute 1138 public Constant cast(Constant c) { 1139 Constant cast_Constant_value = Constant.create(c.stringValue()); 1140 1141 return cast_Constant_value; 1142 } 1143 /** 1144 * @attribute syn 1145 * @aspect ConstantExpression 1146 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:138 1147 */ 1148 @ASTNodeAnnotation.Attribute 1149 public Constant add(Constant c1, Constant c2) { 1150 Constant add_Constant_Constant_value = Constant.create(c1.stringValue() + c2.stringValue()); 1151 1152 return add_Constant_Constant_value; 1153 } 1154 /** 1155 * @attribute syn 1156 * @aspect ConstantExpression 1157 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:202 1158 */ 1159 @ASTNodeAnnotation.Attribute 1160 public Constant questionColon(Constant cond, Constant c1, Constant c2) { 1161 Constant questionColon_Constant_Constant_Constant_value = Constant.create(cond.booleanValue() ? c1.stringValue() : c2.stringValue()); 1162 1163 return questionColon_Constant_Constant_Constant_value; 1164 } 1165 /** 1166 * @attribute syn 1167 * @aspect ConstantExpression 1168 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:326 1169 */ 1170 @ASTNodeAnnotation.Attribute 1171 public boolean eqIsTrue(Expr left, Expr right) { 1172 boolean eqIsTrue_Expr_Expr_value = isString() && left.constant().stringValue().equals(right.constant().stringValue()); 1173 1174 return eqIsTrue_Expr_Expr_value; 1175 } 1176 /** 1177 * @attribute syn 1178 * @aspect ErrorCheck 1179 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:45 1180 */ 1181 @ASTNodeAnnotation.Attribute 1182 public int lineNumber() { 1183 int lineNumber_value = getLine(IDstart); 1184 1185 return lineNumber_value; 1186 } 1187 /** 1188 * @attribute syn 1189 * @aspect ConstructScope 1190 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:42 1191 */ 1192 @ASTNodeAnnotation.Attribute 1193 public Collection lookupSuperConstructor() { 1194 Collection lookupSuperConstructor_value = hasSuperclass() ? superclass().constructors() : Collections.EMPTY_LIST; 1195 1196 return lookupSuperConstructor_value; 1197 } 1198 /** 1199 * @apilevel internal 1200 */ 1201 protected boolean constructors_computed = false; 1202 /** 1203 * @apilevel internal 1204 */ 1205 protected Collection<ConstructorDecl> constructors_value; 1206 /** 1207 * @apilevel internal 1208 */ 1209 private void constructors_reset() { 1210 constructors_computed = false; 1211 constructors_value = null; 1212 } 1213 /** 1214 * @attribute syn 1215 * @aspect ConstructorLookup 1216 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:127 1217 */ 1218 @ASTNodeAnnotation.Attribute 1219 public Collection<ConstructorDecl> constructors() { 1220 ASTNode$State state = state(); 1221 if (constructors_computed) { 1222 return constructors_value; 1223 } 1224 boolean intermediate = state.INTERMEDIATE_VALUE; 1225 state.INTERMEDIATE_VALUE = false; 1226 int num = state.boundariesCrossed; 1227 boolean isFinal = this.is$Final(); 1228 constructors_value = constructors_compute(); 1229 if (isFinal && num == state().boundariesCrossed) { 1230 constructors_computed = true; 1231 } else { 1232 } 1233 state.INTERMEDIATE_VALUE |= intermediate; 1234 1235 return constructors_value; 1236 } 1237 /** 1238 * @apilevel internal 1239 */ 1240 private Collection<ConstructorDecl> constructors_compute() { 1241 Collection<ConstructorDecl> c = super.constructors(); 1242 if (hasImplicitConstructor()) { 1243 c.add(getImplicitConstructor()); 1244 } 1245 return c; 1246 } 1247 /** 1248 * A class declaration requires an implicit constructor if it has no 1249 * explicit constructor. 1250 * @return <code>true</code> if this class requires an implicit default 1251 * contstructor. 1252 * @attribute syn 1253 * @aspect ImplicitConstructor 1254 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:213 1255 */ 1256 @ASTNodeAnnotation.Attribute 1257 public boolean needsImplicitConstructor() { 1258 boolean needsImplicitConstructor_value = compilationUnit().fromSource() && !hasExplicitConstructor(); 1259 1260 return needsImplicitConstructor_value; 1261 } 1262 /** 1263 * @apilevel internal 1264 */ 1265 protected boolean getImplicitConstructorOpt_computed = false; 1266 /** 1267 * @apilevel internal 1268 */ 1269 protected Opt<ConstructorDecl> getImplicitConstructorOpt_value; 1270 /** 1271 * @apilevel internal 1272 */ 1273 private void getImplicitConstructorOpt_reset() { 1274 getImplicitConstructorOpt_computed = false; 1275 getImplicitConstructorOpt_value = null; 1276 } 1277 /** 1278 * @attribute syn nta 1279 * @aspect ImplicitConstructor 1280 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:236 1281 */ 1282 @ASTNodeAnnotation.Attribute 1283 public Opt<ConstructorDecl> getImplicitConstructorOpt() { 1284 ASTNode$State state = state(); 1285 if (getImplicitConstructorOpt_computed) { 1286 return (Opt<ConstructorDecl>) getChild(getImplicitConstructorOptChildPosition()); 1287 } 1288 boolean intermediate = state.INTERMEDIATE_VALUE; 1289 state.INTERMEDIATE_VALUE = false; 1290 int num = state.boundariesCrossed; 1291 boolean isFinal = this.is$Final(); 1292 getImplicitConstructorOpt_value = getImplicitConstructorOpt_compute(); 1293 setChild(getImplicitConstructorOpt_value, getImplicitConstructorOptChildPosition()); 1294 if (isFinal && num == state().boundariesCrossed) { 1295 getImplicitConstructorOpt_computed = true; 1296 } else { 1297 } 1298 state.INTERMEDIATE_VALUE |= intermediate; 1299 1300 Opt<ConstructorDecl> node = (Opt<ConstructorDecl>) this.getChild(getImplicitConstructorOptChildPosition()); 1301 return node; 1302 } 1303 /** 1304 * @apilevel internal 1305 */ 1306 private Opt<ConstructorDecl> getImplicitConstructorOpt_compute() { 1307 if (needsImplicitConstructor()) { 1308 Modifiers m = new Modifiers(); 1309 if (isPublic()) { 1310 m.addModifier(new Modifier("public")); 1311 } else if (isProtected()) { 1312 m.addModifier(new Modifier("protected")); 1313 } else if (isPrivate()) { 1314 m.addModifier(new Modifier("private")); 1315 } 1316 ConstructorDecl constructor = new ConstructorDecl( 1317 m, 1318 name(), 1319 new List(), 1320 new List(), 1321 new Opt(), 1322 new Block() 1323 ); 1324 constructor.setParsedConstructorInvocation( 1325 new ExprStmt( 1326 new SuperConstructorAccess("super", new List()) 1327 ) 1328 ); 1329 constructor.setImplicitConstructor(); 1330 return new Opt<ConstructorDecl>(constructor); 1331 } else { 1332 return new Opt<ConstructorDecl>(); 1333 } 1334 } 1335 /** 1336 * @attribute syn 1337 * @aspect ImplicitConstructor 1338 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:323 1339 */ 1340 @ASTNodeAnnotation.Attribute 1341 public boolean hasExplicitConstructor() { 1342 { 1343 for (int i = 0; i < getNumBodyDecl(); i++) { 1344 if (getBodyDecl(i) instanceof ConstructorDecl) { 1345 return true; 1346 } 1347 } 1348 return false; 1349 } 1350 } 1351 /** 1352 * @attribute syn 1353 * @aspect MemberMethods 1354 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:406 1355 */ 1356 @ASTNodeAnnotation.Attribute 1357 public SimpleSet interfacesMethodsSignature(String signature) { 1358 { 1359 SimpleSet set = interfacesMethodsSignatureMap().get(signature); 1360 if (set != null) { 1361 return set; 1362 } else { 1363 return SimpleSet.emptySet; 1364 } 1365 } 1366 } 1367 /** 1368 * @apilevel internal 1369 */ 1370 protected boolean methodsSignatureMap_computed = false; 1371 /** 1372 * @apilevel internal 1373 */ 1374 protected Map<String,SimpleSet> methodsSignatureMap_value; 1375 /** 1376 * @apilevel internal 1377 */ 1378 private void methodsSignatureMap_reset() { 1379 methodsSignatureMap_computed = false; 1380 methodsSignatureMap_value = null; 1381 } 1382 /** 1383 * @attribute syn 1384 * @aspect MemberMethods 1385 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:466 1386 */ 1387 @ASTNodeAnnotation.Attribute 1388 public Map<String,SimpleSet> methodsSignatureMap() { 1389 ASTNode$State state = state(); 1390 if (methodsSignatureMap_computed) { 1391 return methodsSignatureMap_value; 1392 } 1393 boolean intermediate = state.INTERMEDIATE_VALUE; 1394 state.INTERMEDIATE_VALUE = false; 1395 int num = state.boundariesCrossed; 1396 boolean isFinal = this.is$Final(); 1397 methodsSignatureMap_value = methodsSignatureMap_compute(); 1398 if (isFinal && num == state().boundariesCrossed) { 1399 methodsSignatureMap_computed = true; 1400 } else { 1401 } 1402 state.INTERMEDIATE_VALUE |= intermediate; 1403 1404 return methodsSignatureMap_value; 1405 } 1406 /** 1407 * @apilevel internal 1408 */ 1409 private Map<String,SimpleSet> methodsSignatureMap_compute() { 1410 Map<String,SimpleSet> localMap = localMethodsSignatureMap(); 1411 Map<String,SimpleSet> map = new HashMap<String,SimpleSet>(localMap); 1412 HashMap fromSuperClass = new HashMap(); 1413 if (hasSuperclass()) { 1414 for (Iterator<MethodDecl> iter = superclass().methodsIterator(); iter.hasNext(); ) { 1415 MethodDecl m = iter.next(); 1416 if (!m.isPrivate() && m.accessibleFrom(this) && !localMap.containsKey(m.signature())) { 1417 putSimpleSetElement(map, m.signature(), m); 1418 if (!m.isAbstract()) { 1419 putSimpleSetElement(fromSuperClass, m.signature(), m); 1420 } 1421 } 1422 } 1423 } 1424 for (Iterator<MethodDecl> iter = interfacesMethodsIterator(); iter.hasNext(); ) { 1425 MethodDecl m = iter.next(); 1426 if (!m.isStatic() 1427 && m.accessibleFrom(this) && !localMap.containsKey(m.signature()) 1428 && !hasOverridingMethodInSuper(m)) { 1429 if (!fromSuperClass.containsKey(m.signature())) { 1430 putSimpleSetElement(map, m.signature(), m); 1431 } 1432 } 1433 } 1434 return map; 1435 } 1436 /** 1437 * @apilevel internal 1438 */ 1439 protected java.util.Map ancestorMethods_String_values; 1440 /** 1441 * @apilevel internal 1442 */ 1443 private void ancestorMethods_String_reset() { 1444 ancestorMethods_String_values = null; 1445 } 1446 /** 1447 * @attribute syn 1448 * @aspect AncestorMethods 1449 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:536 1450 */ 1451 @ASTNodeAnnotation.Attribute 1452 public SimpleSet ancestorMethods(String signature) { 1453 Object _parameters = signature; 1454 if (ancestorMethods_String_values == null) ancestorMethods_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1455 ASTNode$State state = state(); 1456 if (ancestorMethods_String_values.containsKey(_parameters)) { 1457 return (SimpleSet) ancestorMethods_String_values.get(_parameters); 1458 } 1459 boolean intermediate = state.INTERMEDIATE_VALUE; 1460 state.INTERMEDIATE_VALUE = false; 1461 int num = state.boundariesCrossed; 1462 boolean isFinal = this.is$Final(); 1463 SimpleSet ancestorMethods_String_value = ancestorMethods_compute(signature); 1464 if (isFinal && num == state().boundariesCrossed) { 1465 ancestorMethods_String_values.put(_parameters, ancestorMethods_String_value); 1466 } else { 1467 } 1468 state.INTERMEDIATE_VALUE |= intermediate; 1469 1470 return ancestorMethods_String_value; 1471 } 1472 /** 1473 * @apilevel internal 1474 */ 1475 private SimpleSet ancestorMethods_compute(String signature) { 1476 SimpleSet set = SimpleSet.emptySet; 1477 if (hasSuperclass()) { 1478 for (Iterator iter = superclass().localMethodsSignature(signature).iterator(); iter.hasNext(); ) { 1479 MethodDecl m = (MethodDecl) iter.next(); 1480 if (!m.isPrivate()) { 1481 set = set.add(m); 1482 } 1483 } 1484 } 1485 // always add interface methods to the ancestorMethods set so that their 1486 // access modifiers are checked against local overriding methods 1487 for (Iterator iter = interfacesMethodsSignature(signature).iterator(); iter.hasNext(); ) { 1488 MethodDecl m = (MethodDecl) iter.next(); 1489 set = set.add(m); 1490 } 1491 if (!hasSuperclass()) { 1492 return set; 1493 } 1494 if (set.size() == 1) { 1495 MethodDecl m = (MethodDecl) set.iterator().next(); 1496 if (!m.isAbstract()) { 1497 boolean done = true; 1498 for (Iterator iter = superclass().ancestorMethods(signature).iterator(); iter.hasNext(); ) { 1499 MethodDecl n = (MethodDecl) iter.next(); 1500 if (n.isPrivate() || !n.accessibleFrom(m.hostType())) { 1501 done = false; 1502 } 1503 } 1504 if (done) { 1505 return set; 1506 } 1507 } 1508 } 1509 for (Iterator iter = superclass().ancestorMethods(signature).iterator(); iter.hasNext(); ) { 1510 MethodDecl m = (MethodDecl) iter.next(); 1511 set = set.add(m); 1512 } 1513 return set; 1514 } 1515 /** 1516 * @apilevel internal 1517 */ 1518 protected java.util.Map memberTypes_String_values; 1519 /** 1520 * @apilevel internal 1521 */ 1522 private void memberTypes_String_reset() { 1523 memberTypes_String_values = null; 1524 } 1525 /** 1526 * @attribute syn 1527 * @aspect TypeScopePropagation 1528 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:619 1529 */ 1530 @ASTNodeAnnotation.Attribute 1531 public SimpleSet memberTypes(String name) { 1532 Object _parameters = name; 1533 if (memberTypes_String_values == null) memberTypes_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1534 ASTNode$State state = state(); 1535 if (memberTypes_String_values.containsKey(_parameters)) { 1536 return (SimpleSet) memberTypes_String_values.get(_parameters); 1537 } 1538 boolean intermediate = state.INTERMEDIATE_VALUE; 1539 state.INTERMEDIATE_VALUE = false; 1540 int num = state.boundariesCrossed; 1541 boolean isFinal = this.is$Final(); 1542 SimpleSet memberTypes_String_value = memberTypes_compute(name); 1543 if (isFinal && num == state().boundariesCrossed) { 1544 memberTypes_String_values.put(_parameters, memberTypes_String_value); 1545 } else { 1546 } 1547 state.INTERMEDIATE_VALUE |= intermediate; 1548 1549 return memberTypes_String_value; 1550 } 1551 /** 1552 * @apilevel internal 1553 */ 1554 private SimpleSet memberTypes_compute(String name) { 1555 SimpleSet set = localTypeDecls(name); 1556 if (!set.isEmpty()) { 1557 return set; 1558 } 1559 for (Iterator<TypeDecl> outerIter = interfacesIterator(); outerIter.hasNext(); ) { 1560 TypeDecl type = outerIter.next(); 1561 for (Iterator iter = type.memberTypes(name).iterator(); iter.hasNext(); ) { 1562 TypeDecl decl = (TypeDecl) iter.next(); 1563 if (!decl.isPrivate() && decl.accessibleFrom(this)) { 1564 set = set.add(decl); 1565 } 1566 } 1567 } 1568 if (hasSuperclass()) { 1569 for (Iterator iter = superclass().memberTypes(name).iterator(); iter.hasNext(); ) { 1570 TypeDecl decl = (TypeDecl) iter.next(); 1571 if (!decl.isPrivate() && decl.accessibleFrom(this)) { 1572 set = set.add(decl); 1573 } 1574 } 1575 } 1576 return set; 1577 } 1578 /** 1579 * @apilevel internal 1580 */ 1581 protected boolean memberFieldsMap_computed = false; 1582 /** 1583 * @apilevel internal 1584 */ 1585 protected HashMap memberFieldsMap_value; 1586 /** 1587 * @apilevel internal 1588 */ 1589 private void memberFieldsMap_reset() { 1590 memberFieldsMap_computed = false; 1591 memberFieldsMap_value = null; 1592 } 1593 /** 1594 * @attribute syn 1595 * @aspect Fields 1596 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:383 1597 */ 1598 @ASTNodeAnnotation.Attribute 1599 public HashMap memberFieldsMap() { 1600 ASTNode$State state = state(); 1601 if (memberFieldsMap_computed) { 1602 return memberFieldsMap_value; 1603 } 1604 boolean intermediate = state.INTERMEDIATE_VALUE; 1605 state.INTERMEDIATE_VALUE = false; 1606 int num = state.boundariesCrossed; 1607 boolean isFinal = this.is$Final(); 1608 memberFieldsMap_value = memberFieldsMap_compute(); 1609 if (isFinal && num == state().boundariesCrossed) { 1610 memberFieldsMap_computed = true; 1611 } else { 1612 } 1613 state.INTERMEDIATE_VALUE |= intermediate; 1614 1615 return memberFieldsMap_value; 1616 } 1617 /** 1618 * @apilevel internal 1619 */ 1620 private HashMap memberFieldsMap_compute() { 1621 HashMap map = new HashMap(localFieldsMap()); 1622 if (hasSuperclass()) { 1623 for (Iterator iter = superclass().fieldsIterator(); iter.hasNext(); ) { 1624 FieldDeclaration decl = (FieldDeclaration) iter.next(); 1625 if (!decl.isPrivate() && decl.accessibleFrom(this) && !localFieldsMap().containsKey(decl.name())) { 1626 putSimpleSetElement(map, decl.name(), decl); 1627 } 1628 } 1629 } 1630 for (Iterator<TypeDecl> outerIter = interfacesIterator(); outerIter.hasNext(); ) { 1631 TypeDecl type = outerIter.next(); 1632 for (Iterator iter = type.fieldsIterator(); iter.hasNext(); ) { 1633 FieldDeclaration decl = (FieldDeclaration) iter.next(); 1634 if (!decl.isPrivate() && decl.accessibleFrom(this) && !localFieldsMap().containsKey(decl.name())) { 1635 putSimpleSetElement(map, decl.name(), decl); 1636 } 1637 } 1638 } 1639 return map; 1640 } 1641 /** 1642 * @apilevel internal 1643 */ 1644 protected java.util.Map memberFields_String_values; 1645 /** 1646 * @apilevel internal 1647 */ 1648 private void memberFields_String_reset() { 1649 memberFields_String_values = null; 1650 } 1651 /** 1652 * @attribute syn 1653 * @aspect Fields 1654 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:435 1655 */ 1656 @ASTNodeAnnotation.Attribute 1657 public SimpleSet memberFields(String name) { 1658 Object _parameters = name; 1659 if (memberFields_String_values == null) memberFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1660 ASTNode$State state = state(); 1661 if (memberFields_String_values.containsKey(_parameters)) { 1662 return (SimpleSet) memberFields_String_values.get(_parameters); 1663 } 1664 boolean intermediate = state.INTERMEDIATE_VALUE; 1665 state.INTERMEDIATE_VALUE = false; 1666 int num = state.boundariesCrossed; 1667 boolean isFinal = this.is$Final(); 1668 SimpleSet memberFields_String_value = memberFields_compute(name); 1669 if (isFinal && num == state().boundariesCrossed) { 1670 memberFields_String_values.put(_parameters, memberFields_String_value); 1671 } else { 1672 } 1673 state.INTERMEDIATE_VALUE |= intermediate; 1674 1675 return memberFields_String_value; 1676 } 1677 /** 1678 * @apilevel internal 1679 */ 1680 private SimpleSet memberFields_compute(String name) { 1681 SimpleSet fields = localFields(name); 1682 if (!fields.isEmpty()) { 1683 return fields; // this causes hiding of fields in superclass and interfaces 1684 } 1685 if (hasSuperclass()) { 1686 for (Iterator iter = superclass().memberFields(name).iterator(); iter.hasNext(); ) { 1687 FieldDeclaration decl = (FieldDeclaration) iter.next(); 1688 if (!decl.isPrivate() && decl.accessibleFrom(this)) { 1689 fields = fields.add(decl); 1690 } 1691 } 1692 } 1693 for (Iterator<TypeDecl> outerIter = interfacesIterator(); outerIter.hasNext(); ) { 1694 TypeDecl type = outerIter.next(); 1695 for (Iterator iter = type.memberFields(name).iterator(); iter.hasNext(); ) { 1696 FieldDeclaration decl = (FieldDeclaration) iter.next(); 1697 if (!decl.isPrivate() && decl.accessibleFrom(this)) { 1698 fields = fields.add(decl); 1699 } 1700 } 1701 } 1702 return fields; 1703 } 1704 /** 1705 * @apilevel internal 1706 */ 1707 protected boolean unimplementedMethods_computed = false; 1708 /** 1709 * @apilevel internal 1710 */ 1711 protected Collection unimplementedMethods_value; 1712 /** 1713 * @apilevel internal 1714 */ 1715 private void unimplementedMethods_reset() { 1716 unimplementedMethods_computed = false; 1717 unimplementedMethods_value = null; 1718 } 1719 /** 1720 * @attribute syn 1721 * @aspect Modifiers 1722 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:37 1723 */ 1724 @ASTNodeAnnotation.Attribute 1725 public Collection unimplementedMethods() { 1726 ASTNode$State state = state(); 1727 if (unimplementedMethods_computed) { 1728 return unimplementedMethods_value; 1729 } 1730 boolean intermediate = state.INTERMEDIATE_VALUE; 1731 state.INTERMEDIATE_VALUE = false; 1732 int num = state.boundariesCrossed; 1733 boolean isFinal = this.is$Final(); 1734 unimplementedMethods_value = unimplementedMethods_compute(); 1735 if (isFinal && num == state().boundariesCrossed) { 1736 unimplementedMethods_computed = true; 1737 } else { 1738 } 1739 state.INTERMEDIATE_VALUE |= intermediate; 1740 1741 return unimplementedMethods_value; 1742 } 1743 /** 1744 * @apilevel internal 1745 */ 1746 private Collection unimplementedMethods_compute() { 1747 Collection c = new ArrayList(); 1748 for (Iterator iter = interfacesMethodsIterator(); iter.hasNext(); ) { 1749 MethodDecl m = (MethodDecl) iter.next(); 1750 boolean implemented = false; 1751 SimpleSet set = (SimpleSet) localMethodsSignature(m.signature()); 1752 if (set.size() == 1) { 1753 MethodDecl n = (MethodDecl) set.iterator().next(); 1754 if (!n.isAbstract()) { 1755 implemented = true; 1756 } 1757 } 1758 if (!implemented) { 1759 set = ancestorMethods(m.signature()); 1760 for (Iterator i2 = set.iterator(); i2.hasNext(); ) { 1761 MethodDecl n = (MethodDecl) i2.next(); 1762 if (!n.isAbstract() && n.isPublic()) { 1763 implemented = true; 1764 break; 1765 } 1766 } 1767 } 1768 if (!implemented) { 1769 c.add(m); 1770 } 1771 } 1772 1773 if (hasSuperclass()) { 1774 for (Iterator iter = superclass().unimplementedMethods().iterator(); iter.hasNext(); ) { 1775 MethodDecl m = (MethodDecl) iter.next(); 1776 SimpleSet set = (SimpleSet) localMethodsSignature(m.signature()); 1777 if (set.size() == 1) { 1778 MethodDecl n = (MethodDecl) set.iterator().next(); 1779 if (n.isAbstract() || !n.overrides(m)) { 1780 c.add(m); 1781 } 1782 } else { 1783 c.add(m); 1784 } 1785 } 1786 } 1787 1788 for (Iterator iter = localMethodsIterator(); iter.hasNext(); ) { 1789 MethodDecl m = (MethodDecl) iter.next(); 1790 if (m.isAbstract()) { 1791 c.add(m); 1792 } 1793 } 1794 return c; 1795 } 1796 /** 1797 * @apilevel internal 1798 */ 1799 protected boolean hasAbstract_computed = false; 1800 /** 1801 * @apilevel internal 1802 */ 1803 protected boolean hasAbstract_value; 1804 /** 1805 * @apilevel internal 1806 */ 1807 private void hasAbstract_reset() { 1808 hasAbstract_computed = false; 1809 } 1810 /** 1811 * @attribute syn 1812 * @aspect Modifiers 1813 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:35 1814 */ 1815 @ASTNodeAnnotation.Attribute 1816 public boolean hasAbstract() { 1817 ASTNode$State state = state(); 1818 if (hasAbstract_computed) { 1819 return hasAbstract_value; 1820 } 1821 boolean intermediate = state.INTERMEDIATE_VALUE; 1822 state.INTERMEDIATE_VALUE = false; 1823 int num = state.boundariesCrossed; 1824 boolean isFinal = this.is$Final(); 1825 hasAbstract_value = !unimplementedMethods().isEmpty(); 1826 if (isFinal && num == state().boundariesCrossed) { 1827 hasAbstract_computed = true; 1828 } else { 1829 } 1830 state.INTERMEDIATE_VALUE |= intermediate; 1831 1832 return hasAbstract_value; 1833 } 1834 /** 1835 * @attribute syn 1836 * @aspect PrettyPrintUtil 1837 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:241 1838 */ 1839 @ASTNodeAnnotation.Attribute 1840 public boolean hasModifiers() { 1841 boolean hasModifiers_value = getModifiers().getNumModifier() > 0; 1842 1843 return hasModifiers_value; 1844 } 1845 /** 1846 * @apilevel internal 1847 */ 1848 protected java.util.Map castingConversionTo_TypeDecl_values; 1849 /** 1850 * @apilevel internal 1851 */ 1852 private void castingConversionTo_TypeDecl_reset() { 1853 castingConversionTo_TypeDecl_values = null; 1854 } 1855 /** 1856 * @attribute syn 1857 * @aspect TypeConversion 1858 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:109 1859 */ 1860 @ASTNodeAnnotation.Attribute 1861 public boolean castingConversionTo(TypeDecl type) { 1862 Object _parameters = type; 1863 if (castingConversionTo_TypeDecl_values == null) castingConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1864 ASTNode$State state = state(); 1865 if (castingConversionTo_TypeDecl_values.containsKey(_parameters)) { 1866 return (Boolean) castingConversionTo_TypeDecl_values.get(_parameters); 1867 } 1868 boolean intermediate = state.INTERMEDIATE_VALUE; 1869 state.INTERMEDIATE_VALUE = false; 1870 int num = state.boundariesCrossed; 1871 boolean isFinal = this.is$Final(); 1872 boolean castingConversionTo_TypeDecl_value = castingConversionTo_compute(type); 1873 if (isFinal && num == state().boundariesCrossed) { 1874 castingConversionTo_TypeDecl_values.put(_parameters, castingConversionTo_TypeDecl_value); 1875 } else { 1876 } 1877 state.INTERMEDIATE_VALUE |= intermediate; 1878 1879 return castingConversionTo_TypeDecl_value; 1880 } 1881 /** 1882 * @apilevel internal 1883 */ 1884 private boolean castingConversionTo_compute(TypeDecl type) { 1885 if (refined_Generics_ClassDecl_castingConversionTo_TypeDecl(type)) { 1886 return true; 1887 } 1888 boolean canUnboxThis = !unboxed().isUnknown(); 1889 boolean canUnboxType = !type.unboxed().isUnknown(); 1890 if (canUnboxThis && !canUnboxType) { 1891 return unboxed().wideningConversionTo(type); 1892 } 1893 return false; 1894 /* 1895 else if (unboxingConversionTo(type)) { 1896 return true; 1897 } 1898 return false; 1899 */ 1900 } 1901 /** 1902 * @attribute syn 1903 * @aspect TypeAnalysis 1904 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:231 1905 */ 1906 @ASTNodeAnnotation.Attribute 1907 public boolean isClassDecl() { 1908 boolean isClassDecl_value = true; 1909 1910 return isClassDecl_value; 1911 } 1912 /** 1913 * @apilevel internal 1914 */ 1915 protected boolean isString_computed = false; 1916 /** 1917 * @apilevel internal 1918 */ 1919 protected boolean isString_value; 1920 /** 1921 * @apilevel internal 1922 */ 1923 private void isString_reset() { 1924 isString_computed = false; 1925 } 1926 /** 1927 * @attribute syn 1928 * @aspect TypeAnalysis 1929 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:248 1930 */ 1931 @ASTNodeAnnotation.Attribute 1932 public boolean isString() { 1933 ASTNode$State state = state(); 1934 if (isString_computed) { 1935 return isString_value; 1936 } 1937 boolean intermediate = state.INTERMEDIATE_VALUE; 1938 state.INTERMEDIATE_VALUE = false; 1939 int num = state.boundariesCrossed; 1940 boolean isFinal = this.is$Final(); 1941 isString_value = fullName().equals("java.lang.String"); 1942 if (isFinal && num == state().boundariesCrossed) { 1943 isString_computed = true; 1944 } else { 1945 } 1946 state.INTERMEDIATE_VALUE |= intermediate; 1947 1948 return isString_value; 1949 } 1950 /** 1951 * @apilevel internal 1952 */ 1953 protected boolean isObject_computed = false; 1954 /** 1955 * @apilevel internal 1956 */ 1957 protected boolean isObject_value; 1958 /** 1959 * @apilevel internal 1960 */ 1961 private void isObject_reset() { 1962 isObject_computed = false; 1963 } 1964 /** 1965 * @attribute syn 1966 * @aspect TypeAnalysis 1967 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:251 1968 */ 1969 @ASTNodeAnnotation.Attribute 1970 public boolean isObject() { 1971 ASTNode$State state = state(); 1972 if (isObject_computed) { 1973 return isObject_value; 1974 } 1975 boolean intermediate = state.INTERMEDIATE_VALUE; 1976 state.INTERMEDIATE_VALUE = false; 1977 int num = state.boundariesCrossed; 1978 boolean isFinal = this.is$Final(); 1979 isObject_value = name().equals("Object") && packageName().equals("java.lang"); 1980 if (isFinal && num == state().boundariesCrossed) { 1981 isObject_computed = true; 1982 } else { 1983 } 1984 state.INTERMEDIATE_VALUE |= intermediate; 1985 1986 return isObject_value; 1987 } 1988 /** 1989 * @apilevel internal 1990 */ 1991 protected java.util.Map instanceOf_TypeDecl_values; 1992 /** 1993 * @apilevel internal 1994 */ 1995 private void instanceOf_TypeDecl_reset() { 1996 instanceOf_TypeDecl_values = null; 1997 } 1998 /** 1999 * @attribute syn 2000 * @aspect TypeWideningAndIdentity 2001 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442 2002 */ 2003 @ASTNodeAnnotation.Attribute 2004 public boolean instanceOf(TypeDecl type) { 2005 Object _parameters = type; 2006 if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2007 ASTNode$State state = state(); 2008 if (instanceOf_TypeDecl_values.containsKey(_parameters)) { 2009 return (Boolean) instanceOf_TypeDecl_values.get(_parameters); 2010 } 2011 boolean intermediate = state.INTERMEDIATE_VALUE; 2012 state.INTERMEDIATE_VALUE = false; 2013 int num = state.boundariesCrossed; 2014 boolean isFinal = this.is$Final(); 2015 boolean instanceOf_TypeDecl_value = instanceOf_compute(type); 2016 if (isFinal && num == state().boundariesCrossed) { 2017 instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value); 2018 } else { 2019 } 2020 state.INTERMEDIATE_VALUE |= intermediate; 2021 2022 return instanceOf_TypeDecl_value; 2023 } 2024 /** 2025 * @apilevel internal 2026 */ 2027 private boolean instanceOf_compute(TypeDecl type) { return subtype(type); } 2028 /** 2029 * @attribute syn 2030 * @aspect TypeWideningAndIdentity 2031 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:458 2032 */ 2033 @ASTNodeAnnotation.Attribute 2034 public boolean isSupertypeOfClassDecl(ClassDecl type) { 2035 { 2036 if (super.isSupertypeOfClassDecl(type)) { 2037 return true; 2038 } 2039 return type.hasSuperclass() && type.superclass().instanceOf(this); 2040 } 2041 } 2042 /** 2043 * @attribute syn 2044 * @aspect TypeWideningAndIdentity 2045 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:478 2046 */ 2047 @ASTNodeAnnotation.Attribute 2048 public boolean isSupertypeOfInterfaceDecl(InterfaceDecl type) { 2049 boolean isSupertypeOfInterfaceDecl_InterfaceDecl_value = isObject(); 2050 2051 return isSupertypeOfInterfaceDecl_InterfaceDecl_value; 2052 } 2053 /** 2054 * @attribute syn 2055 * @aspect TypeWideningAndIdentity 2056 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:493 2057 */ 2058 @ASTNodeAnnotation.Attribute 2059 public boolean isSupertypeOfArrayDecl(ArrayDecl type) { 2060 { 2061 if (super.isSupertypeOfArrayDecl(type)) { 2062 return true; 2063 } 2064 return type.hasSuperclass() && type.superclass().instanceOf(this); 2065 } 2066 } 2067 /** 2068 * @attribute syn 2069 * @aspect NestedTypes 2070 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:585 2071 */ 2072 @ASTNodeAnnotation.Attribute 2073 public boolean isInnerClass() { 2074 boolean isInnerClass_value = isNestedType() && !isStatic() && enclosingType().isClassDecl(); 2075 2076 return isInnerClass_value; 2077 } 2078 /** 2079 * @apilevel internal 2080 */ 2081 protected int isCircular_visited = -1; 2082 /** 2083 * @apilevel internal 2084 */ 2085 private void isCircular_reset() { 2086 isCircular_computed = false; 2087 isCircular_initialized = false; 2088 isCircular_visited = -1; 2089 } 2090 /** 2091 * @apilevel internal 2092 */ 2093 protected boolean isCircular_computed = false; 2094 /** 2095 * @apilevel internal 2096 */ 2097 protected boolean isCircular_initialized = false; 2098 /** 2099 * @apilevel internal 2100 */ 2101 protected boolean isCircular_value; 2102 @ASTNodeAnnotation.Attribute 2103 public boolean isCircular() { 2104 if (isCircular_computed) { 2105 return isCircular_value; 2106 } 2107 ASTNode$State state = state(); 2108 boolean new_isCircular_value; 2109 if (!isCircular_initialized) { 2110 isCircular_initialized = true; 2111 isCircular_value = true; 2112 } 2113 if (!state.IN_CIRCLE) { 2114 state.IN_CIRCLE = true; 2115 int num = state.boundariesCrossed; 2116 boolean isFinal = this.is$Final(); 2117 do { 2118 isCircular_visited = state.CIRCLE_INDEX; 2119 state.CHANGE = false; 2120 new_isCircular_value = isCircular_compute(); 2121 if (new_isCircular_value != isCircular_value) { 2122 state.CHANGE = true; 2123 } 2124 isCircular_value = new_isCircular_value; 2125 state.CIRCLE_INDEX++; 2126 } while (state.CHANGE); 2127 if (isFinal && num == state().boundariesCrossed) { 2128 isCircular_computed = true; 2129 } else { 2130 state.RESET_CYCLE = true; 2131 boolean $tmp = isCircular_compute(); 2132 state.RESET_CYCLE = false; 2133 isCircular_computed = false; 2134 isCircular_initialized = false; 2135 } 2136 state.IN_CIRCLE = false; 2137 state.INTERMEDIATE_VALUE = false; 2138 return isCircular_value; 2139 } 2140 if (isCircular_visited != state.CIRCLE_INDEX) { 2141 isCircular_visited = state.CIRCLE_INDEX; 2142 if (state.RESET_CYCLE) { 2143 isCircular_computed = false; 2144 isCircular_initialized = false; 2145 isCircular_visited = -1; 2146 return isCircular_value; 2147 } 2148 new_isCircular_value = isCircular_compute(); 2149 if (new_isCircular_value != isCircular_value) { 2150 state.CHANGE = true; 2151 } 2152 isCircular_value = new_isCircular_value; 2153 state.INTERMEDIATE_VALUE = true; 2154 return isCircular_value; 2155 } 2156 state.INTERMEDIATE_VALUE = true; 2157 return isCircular_value; 2158 } 2159 /** 2160 * @apilevel internal 2161 */ 2162 private boolean isCircular_compute() { 2163 if (hasSuperClass()) { 2164 Access a = getSuperClass().lastAccess(); 2165 while (a != null) { 2166 if (a.type().isCircular()) { 2167 return true; 2168 } 2169 a = (a.isQualified() && a.qualifier().isTypeAccess()) ? (Access) a.qualifier() : null; 2170 } 2171 } 2172 for (int i = 0; i < getNumImplements(); i++) { 2173 Access a = getImplements(i).lastAccess(); 2174 while (a != null) { 2175 if (a.type().isCircular()) { 2176 return true; 2177 } 2178 a = (a.isQualified() && a.qualifier().isTypeAccess()) ? (Access) a.qualifier() : null; 2179 } 2180 } 2181 return false; 2182 } 2183 /** 2184 * @apilevel internal 2185 */ 2186 protected boolean typeDescriptor_computed = false; 2187 /** 2188 * @apilevel internal 2189 */ 2190 protected String typeDescriptor_value; 2191 /** 2192 * @apilevel internal 2193 */ 2194 private void typeDescriptor_reset() { 2195 typeDescriptor_computed = false; 2196 typeDescriptor_value = null; 2197 } 2198 /** 2199 * @attribute syn 2200 * @aspect ConstantPoolNames 2201 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:77 2202 */ 2203 @ASTNodeAnnotation.Attribute 2204 public String typeDescriptor() { 2205 ASTNode$State state = state(); 2206 if (typeDescriptor_computed) { 2207 return typeDescriptor_value; 2208 } 2209 boolean intermediate = state.INTERMEDIATE_VALUE; 2210 state.INTERMEDIATE_VALUE = false; 2211 int num = state.boundariesCrossed; 2212 boolean isFinal = this.is$Final(); 2213 typeDescriptor_value = "L" + constantPoolName() + ";"; 2214 if (isFinal && num == state().boundariesCrossed) { 2215 typeDescriptor_computed = true; 2216 } else { 2217 } 2218 state.INTERMEDIATE_VALUE |= intermediate; 2219 2220 return typeDescriptor_value; 2221 } 2222 /** 2223 * @attribute syn 2224 * @aspect CreateBCode 2225 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:900 2226 */ 2227 @ASTNodeAnnotation.Attribute 2228 public String arrayTypeDescriptor() { 2229 String arrayTypeDescriptor_value = constantPoolName(); 2230 2231 return arrayTypeDescriptor_value; 2232 } 2233 /** 2234 * @attribute syn 2235 * @aspect GenerateClassfile 2236 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:328 2237 */ 2238 @ASTNodeAnnotation.Attribute 2239 public Collection bcMethods() { 2240 { 2241 Collection c = new ArrayList(); 2242 if (hasImplicitConstructor()) { 2243 c.add(getImplicitConstructor()); 2244 } 2245 c.addAll(super.bcMethods()); 2246 return c; 2247 } 2248 } 2249 /** 2250 * @attribute syn 2251 * @aspect InnerClasses 2252 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:499 2253 */ 2254 @ASTNodeAnnotation.Attribute 2255 public TypeDecl superEnclosing() { 2256 { 2257 return superclass().erasure().enclosing(); 2258 } 2259 } 2260 /** 2261 * @attribute syn 2262 * @aspect Annotations 2263 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:292 2264 */ 2265 @ASTNodeAnnotation.Attribute 2266 public Annotation annotation(TypeDecl typeDecl) { 2267 { 2268 Annotation a = super.annotation(typeDecl); 2269 if (a != null) { 2270 return a; 2271 } 2272 if (hasSuperclass()) { 2273 // If the queried annotation is itself annotation with @Inherited then 2274 // delegate the query to the superclass 2275 if (typeDecl.annotation(lookupType("java.lang.annotation", "Inherited")) != null) { 2276 return superclass().annotation(typeDecl); 2277 } 2278 } 2279 return null; 2280 } 2281 } 2282 /** 2283 * @apilevel internal 2284 */ 2285 protected boolean erasedAncestorMethodsMap_computed = false; 2286 /** 2287 * @apilevel internal 2288 */ 2289 protected Map<String,SimpleSet> erasedAncestorMethodsMap_value; 2290 /** 2291 * @apilevel internal 2292 */ 2293 private void erasedAncestorMethodsMap_reset() { 2294 erasedAncestorMethodsMap_computed = false; 2295 erasedAncestorMethodsMap_value = null; 2296 } 2297 /** 2298 * @attribute syn 2299 * @aspect GenericsTypeCheck 2300 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:496 2301 */ 2302 @ASTNodeAnnotation.Attribute 2303 public Map<String,SimpleSet> erasedAncestorMethodsMap() { 2304 ASTNode$State state = state(); 2305 if (erasedAncestorMethodsMap_computed) { 2306 return erasedAncestorMethodsMap_value; 2307 } 2308 boolean intermediate = state.INTERMEDIATE_VALUE; 2309 state.INTERMEDIATE_VALUE = false; 2310 int num = state.boundariesCrossed; 2311 boolean isFinal = this.is$Final(); 2312 erasedAncestorMethodsMap_value = erasedAncestorMethodsMap_compute(); 2313 if (isFinal && num == state().boundariesCrossed) { 2314 erasedAncestorMethodsMap_computed = true; 2315 } else { 2316 } 2317 state.INTERMEDIATE_VALUE |= intermediate; 2318 2319 return erasedAncestorMethodsMap_value; 2320 } 2321 /** 2322 * @apilevel internal 2323 */ 2324 private Map<String,SimpleSet> erasedAncestorMethodsMap_compute() { 2325 Map<String,SimpleSet> localMap = localMethodsSignatureMap(); 2326 Map<String,SimpleSet> map = new HashMap<String,SimpleSet>(); 2327 if (hasSuperclass()) { 2328 for (Iterator<MethodDecl> iter = superclass().localMethodsIterator(); iter.hasNext(); ) { 2329 MethodDecl m = iter.next(); 2330 if (!m.isPrivate() && m.accessibleFrom(this) && m.erasedMethod() != m) { 2331 // map erased signature to substituted method 2332 putSimpleSetElement(map, m.erasedMethod().signature(), m); 2333 } 2334 } 2335 mergeMap(map, superclass().erasedAncestorMethodsMap()); 2336 } 2337 for (Iterator<MethodDecl> iter = interfacesMethodsIterator(); iter.hasNext(); ) { 2338 MethodDecl m = iter.next(); 2339 if (m.accessibleFrom(this) && m.erasedMethod() != m) { 2340 String erasedSignature = m.erasedMethod().signature(); 2341 // map erased signature to substituted method 2342 putSimpleSetElement(map, erasedSignature, m); 2343 } 2344 } 2345 return map; 2346 } 2347 /** 2348 * @apilevel internal 2349 */ 2350 protected boolean implementedInterfaces_computed = false; 2351 /** 2352 * @apilevel internal 2353 */ 2354 protected HashSet<InterfaceDecl> implementedInterfaces_value; 2355 /** 2356 * @apilevel internal 2357 */ 2358 private void implementedInterfaces_reset() { 2359 implementedInterfaces_computed = false; 2360 implementedInterfaces_value = null; 2361 } 2362 /** 2363 * @attribute syn 2364 * @aspect GenericsTypeCheck 2365 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:614 2366 */ 2367 @ASTNodeAnnotation.Attribute 2368 public HashSet<InterfaceDecl> implementedInterfaces() { 2369 ASTNode$State state = state(); 2370 if (implementedInterfaces_computed) { 2371 return implementedInterfaces_value; 2372 } 2373 boolean intermediate = state.INTERMEDIATE_VALUE; 2374 state.INTERMEDIATE_VALUE = false; 2375 int num = state.boundariesCrossed; 2376 boolean isFinal = this.is$Final(); 2377 implementedInterfaces_value = implementedInterfaces_compute(); 2378 if (isFinal && num == state().boundariesCrossed) { 2379 implementedInterfaces_computed = true; 2380 } else { 2381 } 2382 state.INTERMEDIATE_VALUE |= intermediate; 2383 2384 return implementedInterfaces_value; 2385 } 2386 /** 2387 * @apilevel internal 2388 */ 2389 private HashSet<InterfaceDecl> implementedInterfaces_compute() { 2390 HashSet set = new HashSet(); 2391 if (hasSuperclass()) { 2392 set.addAll(superclass().implementedInterfaces()); 2393 } 2394 for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); ) { 2395 InterfaceDecl decl = (InterfaceDecl) iter.next(); 2396 set.add(decl); 2397 set.addAll(decl.implementedInterfaces()); 2398 } 2399 return set; 2400 } 2401 /** 2402 * @apilevel internal 2403 */ 2404 private void subtype_TypeDecl_reset() { 2405 subtype_TypeDecl_values = null; 2406 } 2407 protected java.util.Map subtype_TypeDecl_values; 2408 @ASTNodeAnnotation.Attribute 2409 public boolean subtype(TypeDecl type) { 2410 Object _parameters = type; 2411 if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2412 ASTNode$State.CircularValue _value; 2413 if (subtype_TypeDecl_values.containsKey(_parameters)) { 2414 Object _o = subtype_TypeDecl_values.get(_parameters); 2415 if (!(_o instanceof ASTNode$State.CircularValue)) { 2416 return (Boolean) _o; 2417 } else { 2418 _value = (ASTNode$State.CircularValue) _o; 2419 } 2420 } else { 2421 _value = new ASTNode$State.CircularValue(); 2422 subtype_TypeDecl_values.put(_parameters, _value); 2423 _value.value = true; 2424 } 2425 ASTNode$State state = state(); 2426 boolean new_subtype_TypeDecl_value; 2427 if (!state.IN_CIRCLE) { 2428 state.IN_CIRCLE = true; 2429 int num = state.boundariesCrossed; 2430 boolean isFinal = this.is$Final(); 2431 // TODO: fixme 2432 // state().CIRCLE_INDEX = 1; 2433 do { 2434 _value.visited = state.CIRCLE_INDEX; 2435 state.CHANGE = false; 2436 new_subtype_TypeDecl_value = type.supertypeClassDecl(this); 2437 if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 2438 state.CHANGE = true; 2439 _value.value = new_subtype_TypeDecl_value; 2440 } 2441 state.CIRCLE_INDEX++; 2442 } while (state.CHANGE); 2443 if (isFinal && num == state().boundariesCrossed) { 2444 subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value); 2445 } else { 2446 subtype_TypeDecl_values.remove(_parameters); 2447 state.RESET_CYCLE = true; 2448 boolean $tmp = type.supertypeClassDecl(this); 2449 state.RESET_CYCLE = false; 2450 } 2451 state.IN_CIRCLE = false; 2452 state.INTERMEDIATE_VALUE = false; 2453 return new_subtype_TypeDecl_value; 2454 } 2455 if (state.CIRCLE_INDEX != _value.visited) { 2456 _value.visited = state.CIRCLE_INDEX; 2457 new_subtype_TypeDecl_value = type.supertypeClassDecl(this); 2458 if (state.RESET_CYCLE) { 2459 subtype_TypeDecl_values.remove(_parameters); 2460 } 2461 else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 2462 state.CHANGE = true; 2463 _value.value = new_subtype_TypeDecl_value; 2464 } 2465 state.INTERMEDIATE_VALUE = true; 2466 return new_subtype_TypeDecl_value; 2467 } 2468 state.INTERMEDIATE_VALUE = true; 2469 return (Boolean) _value.value; 2470 } 2471 /** 2472 * @attribute syn 2473 * @aspect GenericsSubtype 2474 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:448 2475 */ 2476 @ASTNodeAnnotation.Attribute 2477 public boolean supertypeClassDecl(ClassDecl type) { 2478 boolean supertypeClassDecl_ClassDecl_value = super.supertypeClassDecl(type) || type.hasSuperclass() && type.superclass().subtype(this); 2479 2480 return supertypeClassDecl_ClassDecl_value; 2481 } 2482 /** 2483 * @attribute syn 2484 * @aspect GenericsSubtype 2485 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:465 2486 */ 2487 @ASTNodeAnnotation.Attribute 2488 public boolean supertypeInterfaceDecl(InterfaceDecl type) { 2489 boolean supertypeInterfaceDecl_InterfaceDecl_value = isObject(); 2490 2491 return supertypeInterfaceDecl_InterfaceDecl_value; 2492 } 2493 /** 2494 * @attribute syn 2495 * @aspect GenericsSubtype 2496 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:480 2497 */ 2498 @ASTNodeAnnotation.Attribute 2499 public boolean supertypeArrayDecl(ArrayDecl type) { 2500 { 2501 if (super.supertypeArrayDecl(type)) { 2502 return true; 2503 } 2504 return type.hasSuperclass() && type.superclass().subtype(this); 2505 } 2506 } 2507 /** 2508 * A type is reifiable if it either refers to a non-parameterized type, 2509 * is a raw type, is a parameterized type with only unbound wildcard 2510 * parameters or is an array type with a reifiable type parameter. 2511 * 2512 * @see "JLS SE7 §4.7" 2513 * @attribute syn 2514 * @aspect ReifiableTypes 2515 * @declaredat /home/jesper/git/extendj/java5/frontend/ReifiableTypes.jrag:39 2516 */ 2517 @ASTNodeAnnotation.Attribute 2518 public boolean isReifiable() { 2519 boolean isReifiable_value = !isInnerClass() || enclosingType().isReifiable(); 2520 2521 return isReifiable_value; 2522 } 2523 /** 2524 * @attribute syn 2525 * @aspect GenericsCodegen 2526 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:228 2527 */ 2528 @ASTNodeAnnotation.Attribute 2529 public SimpleSet bridgeCandidates(String signature) { 2530 { 2531 SimpleSet set = ancestorMethods(signature); 2532 for (Iterator iter = interfacesMethodsSignature(signature).iterator(); iter.hasNext(); ) { 2533 set = set.add(iter.next()); 2534 } 2535 return set; 2536 } 2537 } 2538 /** 2539 * @apilevel internal 2540 */ 2541 protected boolean needsSignatureAttribute_computed = false; 2542 /** 2543 * @apilevel internal 2544 */ 2545 protected boolean needsSignatureAttribute_value; 2546 /** 2547 * @apilevel internal 2548 */ 2549 private void needsSignatureAttribute_reset() { 2550 needsSignatureAttribute_computed = false; 2551 } 2552 /** 2553 * @attribute syn 2554 * @aspect GenericsCodegen 2555 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:345 2556 */ 2557 @ASTNodeAnnotation.Attribute 2558 public boolean needsSignatureAttribute() { 2559 ASTNode$State state = state(); 2560 if (needsSignatureAttribute_computed) { 2561 return needsSignatureAttribute_value; 2562 } 2563 boolean intermediate = state.INTERMEDIATE_VALUE; 2564 state.INTERMEDIATE_VALUE = false; 2565 int num = state.boundariesCrossed; 2566 boolean isFinal = this.is$Final(); 2567 needsSignatureAttribute_value = needsSignatureAttribute_compute(); 2568 if (isFinal && num == state().boundariesCrossed) { 2569 needsSignatureAttribute_computed = true; 2570 } else { 2571 } 2572 state.INTERMEDIATE_VALUE |= intermediate; 2573 2574 return needsSignatureAttribute_value; 2575 } 2576 /** 2577 * @apilevel internal 2578 */ 2579 private boolean needsSignatureAttribute_compute() { 2580 if (hasSuperclass() && superclass().needsSignatureAttribute()) { 2581 return true; 2582 } 2583 for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); ) { 2584 if (iter.next().needsSignatureAttribute()) { 2585 return true; 2586 } 2587 } 2588 return false; 2589 } 2590 /** 2591 * @apilevel internal 2592 */ 2593 protected boolean classSignature_computed = false; 2594 /** 2595 * @apilevel internal 2596 */ 2597 protected String classSignature_value; 2598 /** 2599 * @apilevel internal 2600 */ 2601 private void classSignature_reset() { 2602 classSignature_computed = false; 2603 classSignature_value = null; 2604 } 2605 /** 2606 * @attribute syn 2607 * @aspect GenericsCodegen 2608 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:401 2609 */ 2610 @ASTNodeAnnotation.Attribute 2611 public String classSignature() { 2612 ASTNode$State state = state(); 2613 if (classSignature_computed) { 2614 return classSignature_value; 2615 } 2616 boolean intermediate = state.INTERMEDIATE_VALUE; 2617 state.INTERMEDIATE_VALUE = false; 2618 int num = state.boundariesCrossed; 2619 boolean isFinal = this.is$Final(); 2620 classSignature_value = classSignature_compute(); 2621 if (isFinal && num == state().boundariesCrossed) { 2622 classSignature_computed = true; 2623 } else { 2624 } 2625 state.INTERMEDIATE_VALUE |= intermediate; 2626 2627 return classSignature_value; 2628 } 2629 /** 2630 * @apilevel internal 2631 */ 2632 private String classSignature_compute() { 2633 StringBuilder buf = new StringBuilder(); 2634 // SuperclassSignature 2635 if (hasSuperclass()) { 2636 buf.append(superclass().classTypeSignature()); 2637 } 2638 // SuperinterfaceSignature* 2639 for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); ) { 2640 buf.append(iter.next().classTypeSignature()); 2641 } 2642 return buf.toString(); 2643 } 2644 /** 2645 * @apilevel internal 2646 */ 2647 private void strictSubtype_TypeDecl_reset() { 2648 strictSubtype_TypeDecl_values = null; 2649 } 2650 protected java.util.Map strictSubtype_TypeDecl_values; 2651 @ASTNodeAnnotation.Attribute 2652 public boolean strictSubtype(TypeDecl type) { 2653 Object _parameters = type; 2654 if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2655 ASTNode$State.CircularValue _value; 2656 if (strictSubtype_TypeDecl_values.containsKey(_parameters)) { 2657 Object _o = strictSubtype_TypeDecl_values.get(_parameters); 2658 if (!(_o instanceof ASTNode$State.CircularValue)) { 2659 return (Boolean) _o; 2660 } else { 2661 _value = (ASTNode$State.CircularValue) _o; 2662 } 2663 } else { 2664 _value = new ASTNode$State.CircularValue(); 2665 strictSubtype_TypeDecl_values.put(_parameters, _value); 2666 _value.value = true; 2667 } 2668 ASTNode$State state = state(); 2669 boolean new_strictSubtype_TypeDecl_value; 2670 if (!state.IN_CIRCLE) { 2671 state.IN_CIRCLE = true; 2672 int num = state.boundariesCrossed; 2673 boolean isFinal = this.is$Final(); 2674 // TODO: fixme 2675 // state().CIRCLE_INDEX = 1; 2676 do { 2677 _value.visited = state.CIRCLE_INDEX; 2678 state.CHANGE = false; 2679 new_strictSubtype_TypeDecl_value = type.strictSupertypeClassDecl(this); 2680 if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 2681 state.CHANGE = true; 2682 _value.value = new_strictSubtype_TypeDecl_value; 2683 } 2684 state.CIRCLE_INDEX++; 2685 } while (state.CHANGE); 2686 if (isFinal && num == state().boundariesCrossed) { 2687 strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value); 2688 } else { 2689 strictSubtype_TypeDecl_values.remove(_parameters); 2690 state.RESET_CYCLE = true; 2691 boolean $tmp = type.strictSupertypeClassDecl(this); 2692 state.RESET_CYCLE = false; 2693 } 2694 state.IN_CIRCLE = false; 2695 state.INTERMEDIATE_VALUE = false; 2696 return new_strictSubtype_TypeDecl_value; 2697 } 2698 if (state.CIRCLE_INDEX != _value.visited) { 2699 _value.visited = state.CIRCLE_INDEX; 2700 new_strictSubtype_TypeDecl_value = type.strictSupertypeClassDecl(this); 2701 if (state.RESET_CYCLE) { 2702 strictSubtype_TypeDecl_values.remove(_parameters); 2703 } 2704 else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 2705 state.CHANGE = true; 2706 _value.value = new_strictSubtype_TypeDecl_value; 2707 } 2708 state.INTERMEDIATE_VALUE = true; 2709 return new_strictSubtype_TypeDecl_value; 2710 } 2711 state.INTERMEDIATE_VALUE = true; 2712 return (Boolean) _value.value; 2713 } 2714 /** 2715 * @attribute syn 2716 * @aspect StrictSubtype 2717 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:370 2718 */ 2719 @ASTNodeAnnotation.Attribute 2720 public boolean strictSupertypeClassDecl(ClassDecl type) { 2721 boolean strictSupertypeClassDecl_ClassDecl_value = super.strictSupertypeClassDecl(type) || type.hasSuperclass() 2722 && type.superclass() != null && type.superclass().strictSubtype(this); 2723 2724 return strictSupertypeClassDecl_ClassDecl_value; 2725 } 2726 /** 2727 * @attribute syn 2728 * @aspect StrictSubtype 2729 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:390 2730 */ 2731 @ASTNodeAnnotation.Attribute 2732 public boolean strictSupertypeInterfaceDecl(InterfaceDecl type) { 2733 boolean strictSupertypeInterfaceDecl_InterfaceDecl_value = isObject(); 2734 2735 return strictSupertypeInterfaceDecl_InterfaceDecl_value; 2736 } 2737 /** 2738 * @attribute syn 2739 * @aspect StrictSubtype 2740 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:407 2741 */ 2742 @ASTNodeAnnotation.Attribute 2743 public boolean strictSupertypeArrayDecl(ArrayDecl type) { 2744 { 2745 if (super.strictSupertypeArrayDecl(type)) { 2746 return true; 2747 } 2748 return type.hasSuperclass() && type.superclass() != null 2749 && type.superclass().strictSubtype(this); 2750 } 2751 } 2752 /** 2753 * @apilevel internal 2754 */ 2755 protected java.util.Map hasOverridingMethodInSuper_MethodDecl_values; 2756 /** 2757 * @apilevel internal 2758 */ 2759 private void hasOverridingMethodInSuper_MethodDecl_reset() { 2760 hasOverridingMethodInSuper_MethodDecl_values = null; 2761 } 2762 /** 2763 * @attribute syn 2764 * @aspect MethodSignature18 2765 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:1066 2766 */ 2767 @ASTNodeAnnotation.Attribute 2768 public boolean hasOverridingMethodInSuper(MethodDecl m) { 2769 Object _parameters = m; 2770 if (hasOverridingMethodInSuper_MethodDecl_values == null) hasOverridingMethodInSuper_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2771 ASTNode$State state = state(); 2772 if (hasOverridingMethodInSuper_MethodDecl_values.containsKey(_parameters)) { 2773 return (Boolean) hasOverridingMethodInSuper_MethodDecl_values.get(_parameters); 2774 } 2775 boolean intermediate = state.INTERMEDIATE_VALUE; 2776 state.INTERMEDIATE_VALUE = false; 2777 int num = state.boundariesCrossed; 2778 boolean isFinal = this.is$Final(); 2779 boolean hasOverridingMethodInSuper_MethodDecl_value = hasOverridingMethodInSuper_compute(m); 2780 if (isFinal && num == state().boundariesCrossed) { 2781 hasOverridingMethodInSuper_MethodDecl_values.put(_parameters, hasOverridingMethodInSuper_MethodDecl_value); 2782 } else { 2783 } 2784 state.INTERMEDIATE_VALUE |= intermediate; 2785 2786 return hasOverridingMethodInSuper_MethodDecl_value; 2787 } 2788 /** 2789 * @apilevel internal 2790 */ 2791 private boolean hasOverridingMethodInSuper_compute(MethodDecl m) { 2792 for (Iterator<MethodDecl> outerIter = interfacesMethodsIterator(); outerIter.hasNext(); ) { 2793 MethodDecl superMethod = outerIter.next(); 2794 if (m != superMethod && superMethod.overrides(m)) { 2795 return true; 2796 } 2797 2798 } 2799 if (hasSuperclass()) { 2800 for (Iterator iter = superclass().methodsIterator(); iter.hasNext(); ) { 2801 MethodDecl superMethod = (MethodDecl) iter.next(); 2802 if (m != superMethod && superMethod.overrides(m)) { 2803 return true; 2804 } 2805 } 2806 } 2807 2808 return false; 2809 } 2810 /** 2811 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197 2812 * @apilevel internal 2813 */ 2814 public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) { 2815 if (caller == getImplicitConstructorOptNoTransform()) { 2816 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:474 2817 return localLookupType(name); 2818 } 2819 else { 2820 return super.Define_lookupType(caller, child, name); 2821 } 2822 } 2823 protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) { 2824 return true; 2825 } 2826 /** 2827 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423 2828 * @apilevel internal 2829 */ 2830 public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) { 2831 if (caller == getModifiersNoTransform()) { 2832 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:300 2833 return true; 2834 } 2835 else { 2836 return super.Define_mayBeFinal(caller, child); 2837 } 2838 } 2839 protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) { 2840 return true; 2841 } 2842 /** 2843 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 2844 * @apilevel internal 2845 */ 2846 public NameType Define_nameType(ASTNode caller, ASTNode child) { 2847 if (caller == getImplementsListNoTransform()) { 2848 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:101 2849 int childIndex = caller.getIndexOfChild(child); 2850 return NameType.TYPE_NAME; 2851 } 2852 else if (caller == getSuperClassOptNoTransform()) { 2853 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:100 2854 return NameType.TYPE_NAME; 2855 } 2856 else { 2857 return super.Define_nameType(caller, child); 2858 } 2859 } 2860 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 2861 return true; 2862 } 2863 /** 2864 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:544 2865 * @apilevel internal 2866 */ 2867 public TypeDecl Define_enclosingType(ASTNode caller, ASTNode child) { 2868 if (caller == getImplicitConstructorOptNoTransform()) { 2869 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:542 2870 return this; 2871 } 2872 else { 2873 return super.Define_enclosingType(caller, child); 2874 } 2875 } 2876 protected boolean canDefine_enclosingType(ASTNode caller, ASTNode child) { 2877 return true; 2878 } 2879 /** 2880 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:71 2881 * @apilevel internal 2882 */ 2883 public TypeDecl Define_hostType(ASTNode caller, ASTNode child) { 2884 if (caller == getImplementsListNoTransform()) { 2885 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:631 2886 int childIndex = caller.getIndexOfChild(child); 2887 return hostType(); 2888 } 2889 else if (caller == getSuperClassOptNoTransform()) { 2890 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:630 2891 return hostType(); 2892 } 2893 else { 2894 return super.Define_hostType(caller, child); 2895 } 2896 } 2897 protected boolean canDefine_hostType(ASTNode caller, ASTNode child) { 2898 return true; 2899 } 2900 /** 2901 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:38 2902 * @apilevel internal 2903 */ 2904 public boolean Define_withinSuppressWarnings(ASTNode caller, ASTNode child, String annot) { 2905 if (caller == getImplementsListNoTransform()) { 2906 // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:349 2907 int childIndex = caller.getIndexOfChild(child); 2908 return hasAnnotationSuppressWarnings(annot) || withinSuppressWarnings(annot); 2909 } 2910 else if (caller == getSuperClassOptNoTransform()) { 2911 // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:347 2912 return hasAnnotationSuppressWarnings(annot) || withinSuppressWarnings(annot); 2913 } 2914 else { 2915 return getParent().Define_withinSuppressWarnings(this, caller, annot); 2916 } 2917 } 2918 protected boolean canDefine_withinSuppressWarnings(ASTNode caller, ASTNode child, String annot) { 2919 return true; 2920 } 2921 /** 2922 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:449 2923 * @apilevel internal 2924 */ 2925 public boolean Define_withinDeprecatedAnnotation(ASTNode caller, ASTNode child) { 2926 if (caller == getImplementsListNoTransform()) { 2927 // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:454 2928 int childIndex = caller.getIndexOfChild(child); 2929 return isDeprecated() || withinDeprecatedAnnotation(); 2930 } 2931 else if (caller == getSuperClassOptNoTransform()) { 2932 // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:453 2933 return isDeprecated() || withinDeprecatedAnnotation(); 2934 } 2935 else { 2936 return getParent().Define_withinDeprecatedAnnotation(this, caller); 2937 } 2938 } 2939 protected boolean canDefine_withinDeprecatedAnnotation(ASTNode caller, ASTNode child) { 2940 return true; 2941 } 2942 /** 2943 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:338 2944 * @apilevel internal 2945 */ 2946 public boolean Define_inExtendsOrImplements(ASTNode caller, ASTNode child) { 2947 if (caller == getImplementsListNoTransform()) { 2948 // @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:336 2949 int i = caller.getIndexOfChild(child); 2950 return true; 2951 } 2952 else if (caller == getSuperClassOptNoTransform()) { 2953 // @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:335 2954 return true; 2955 } 2956 else { 2957 return getParent().Define_inExtendsOrImplements(this, caller); 2958 } 2959 } 2960 protected boolean canDefine_inExtendsOrImplements(ASTNode caller, ASTNode child) { 2961 return true; 2962 } 2963 /** 2964 * @apilevel internal 2965 */ 2966 public ASTNode rewriteTo() { 2967 return super.rewriteTo(); 2968 } 2969 }