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:38 027 * @production TypeDecl : {@link ASTNode} ::= <span class="component">{@link Modifiers}</span> <span class="component"><ID:String></span> <span class="component">{@link BodyDecl}*</span>; 028 029 */ 030 public abstract class TypeDecl extends ASTNode<ASTNode> implements Cloneable, SimpleSet, Iterator, VariableScope { 031 /** 032 * @aspect AnonymousClasses 033 * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:50 034 */ 035 public int anonymousIndex = 0; 036 /** 037 * @aspect AnonymousClasses 038 * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:70 039 */ 040 public int nextAnonymousIndex() { 041 if (isNestedType()) { 042 return enclosingType().nextAnonymousIndex(); 043 } 044 return anonymousIndex++; 045 } 046 /** 047 * @aspect BoundNames 048 * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:45 049 */ 050 public MethodDecl addMemberMethod(MethodDecl m) { 051 addBodyDecl(m); 052 return (MethodDecl) getBodyDecl(getNumBodyDecl()-1); 053 /* 054 HashMap map = methodsNameMap(); 055 ArrayList list = (ArrayList) map.get(m.name()); 056 if (list == null) { 057 list = new ArrayList(4); 058 map.put(m.name(), list); 059 } 060 list.add(m); 061 if (!memberMethods(m.name()).contains(m)) { 062 throw new Error("The method " + m.signature() + " added to " + typeName() + " can not be found using lookupMemberMethod"); 063 } 064 */ 065 } 066 /** 067 * @aspect BoundNames 068 * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:62 069 */ 070 public ConstructorDecl addConstructor(ConstructorDecl c) { 071 addBodyDecl(c); 072 return (ConstructorDecl) getBodyDecl(getNumBodyDecl()-1); 073 } 074 /** 075 * @aspect BoundNames 076 * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:67 077 */ 078 public ClassDecl addMemberClass(ClassDecl c) { 079 addBodyDecl(new MemberClassDecl(c)); 080 return ((MemberClassDecl) getBodyDecl(getNumBodyDecl()-1)).getClassDecl(); 081 } 082 /** 083 * @aspect BoundNames 084 * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:74 085 */ 086 public FieldDeclaration addMemberField(FieldDeclaration f) { 087 addBodyDecl(f); 088 return (FieldDeclaration) getBodyDecl(getNumBodyDecl()-1); 089 } 090 /** 091 * @aspect BoundNames 092 * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:110 093 */ 094 public TypeAccess createBoundAccess() { 095 return new BoundTypeAccess("", name(), this); 096 } 097 /** 098 * @aspect DataStructures 099 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:159 100 */ 101 public SimpleSet add(Object o) { 102 return new SimpleSetImpl().add(this).add(o); 103 } 104 /** 105 * @aspect DataStructures 106 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:163 107 */ 108 public boolean isSingleton() { return true; } 109 /** 110 * @aspect DataStructures 111 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:164 112 */ 113 public boolean isSingleton(Object o) { return contains(o); } 114 /** 115 * @aspect DataStructures 116 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:167 117 */ 118 private TypeDecl iterElem; 119 /** 120 * @aspect DataStructures 121 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:168 122 */ 123 public Iterator iterator() { iterElem = this; return this; } 124 /** 125 * @aspect DataStructures 126 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:169 127 */ 128 public boolean hasNext() { return iterElem != null; } 129 /** 130 * @aspect DataStructures 131 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:170 132 */ 133 public Object next() { Object o = iterElem; iterElem = null; return o; } 134 /** 135 * @aspect DataStructures 136 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:171 137 */ 138 public void remove() { throw new UnsupportedOperationException(); } 139 /** 140 * @aspect DeclareBeforeUse 141 * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:53 142 */ 143 public boolean declaredBeforeUse(Variable decl, ASTNode use) { 144 int indexDecl = ((ASTNode) decl).varChildIndex(this); 145 int indexUse = use.varChildIndex(this); 146 return indexDecl < indexUse; 147 } 148 /** 149 * @aspect DeclareBeforeUse 150 * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:59 151 */ 152 public boolean declaredBeforeUse(Variable decl, int indexUse) { 153 int indexDecl = ((ASTNode) decl).varChildIndex(this); 154 return indexDecl < indexUse; 155 } 156 /** 157 * @aspect DocumentationComments 158 * @declaredat /home/jesper/git/extendj/java4/frontend/DocumentationComments.jadd:37 159 */ 160 public String docComment = ""; 161 /** 162 * @aspect ConstructorLookup 163 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:117 164 */ 165 public ConstructorDecl lookupConstructor(ConstructorDecl signature) { 166 for (Iterator iter = constructors().iterator(); iter.hasNext(); ) { 167 ConstructorDecl decl = (ConstructorDecl) iter.next(); 168 if (decl.sameSignature(signature)) { 169 return decl; 170 } 171 } 172 return null; 173 } 174 /** 175 * @return true if the method access may access the method 176 * @aspect MethodDecl 177 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:284 178 */ 179 public boolean mayAccess(MethodAccess access, MethodDecl method) { 180 if (instanceOf(method.hostType()) 181 && access.qualifier().type().instanceOf(this)) { 182 return true; 183 } 184 185 if (isNestedType()) { 186 return enclosingType().mayAccess(access, method); 187 } else { 188 return false; 189 } 190 } 191 /** 192 * Iterate over all local methods in the type. 193 * @return method iterator 194 * @aspect MemberMethods 195 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:346 196 */ 197 public Iterator<MethodDecl> localMethodsIterator() { 198 return new Iterator<MethodDecl>() { 199 private Iterator<SimpleSet> outer = localMethodsSignatureMap().values().iterator(); 200 private Iterator inner = null; 201 public boolean hasNext() { 202 if ((inner == null || !inner.hasNext()) && outer.hasNext()) { 203 inner = outer.next().iterator(); 204 } 205 return inner == null ? false : inner.hasNext(); 206 } 207 public MethodDecl next() { 208 return (MethodDecl) inner.next(); 209 } 210 public void remove() { throw new UnsupportedOperationException(); } 211 }; 212 } 213 /** 214 * @return iterator for iterating over all method declarations in implemented 215 * interfaces 216 * @aspect MemberMethods 217 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:389 218 */ 219 public Iterator<MethodDecl> interfacesMethodsIterator() { 220 return new Iterator<MethodDecl>() { 221 private Iterator<SimpleSet> outer = interfacesMethodsSignatureMap().values().iterator(); 222 private Iterator inner = null; 223 public boolean hasNext() { 224 if ((inner == null || !inner.hasNext()) && outer.hasNext()) { 225 inner = outer.next().iterator(); 226 } 227 return inner == null ? false : inner.hasNext(); 228 } 229 public MethodDecl next() { 230 return (MethodDecl) inner.next(); 231 } 232 public void remove() { throw new UnsupportedOperationException(); } 233 }; 234 } 235 /** 236 * Iterate over all member methods in the type. 237 * @return method iterator 238 * @aspect MemberMethods 239 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:440 240 */ 241 public Iterator<MethodDecl> methodsIterator() { 242 return new Iterator<MethodDecl>() { 243 private Iterator<SimpleSet> outer = methodsSignatureMap().values().iterator(); 244 private Iterator inner = null; 245 public boolean hasNext() { 246 if ((inner == null || !inner.hasNext()) && outer.hasNext()) { 247 inner = outer.next().iterator(); 248 } 249 return inner != null ? inner.hasNext() : false; 250 } 251 public MethodDecl next() { 252 return (MethodDecl) inner.next(); 253 } 254 public void remove() { throw new UnsupportedOperationException(); } 255 }; 256 } 257 /** 258 * @aspect MemberMethods 259 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:519 260 */ 261 protected boolean allMethodsAbstract(SimpleSet set) { 262 if (set == null) { 263 return true; 264 } 265 for (Iterator iter = set.iterator(); iter.hasNext(); ) { 266 MethodDecl m = (MethodDecl) iter.next(); 267 if (!m.isAbstract()) { 268 return false; 269 } 270 } 271 return true; 272 } 273 /** 274 * @return true if the expression may access the field 275 * @aspect VariableScope 276 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:307 277 */ 278 public boolean mayAccess(Expr expr, FieldDeclaration field) { 279 if (instanceOf(field.hostType())) { 280 if (!field.isInstanceVariable() 281 || expr.isSuperAccess() 282 || expr.type().instanceOf(this)) { 283 return true; 284 } 285 } 286 287 if (isNestedType()) { 288 return enclosingType().mayAccess(expr, field); 289 } else { 290 return false; 291 } 292 } 293 /** 294 * @aspect Fields 295 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:418 296 */ 297 public Iterator fieldsIterator() { 298 return new Iterator() { 299 private Iterator outer = memberFieldsMap().values().iterator(); 300 private Iterator inner = null; 301 public boolean hasNext() { 302 if ((inner == null || !inner.hasNext()) && outer.hasNext()) { 303 inner = ((SimpleSet) outer.next()).iterator(); 304 } 305 return inner != null ? inner.hasNext() : false; 306 } 307 public Object next() { 308 return inner.next(); 309 } 310 public void remove() { throw new UnsupportedOperationException(); } 311 }; 312 } 313 /** 314 * @aspect Modifiers 315 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:91 316 */ 317 public void refined_Modifiers_TypeDecl_checkModifiers() { 318 super.checkModifiers(); 319 // 8.1.1 320 if (isPublic() && !isTopLevelType() && !isMemberType()) { 321 error("public pertains only to top level types and member types"); 322 } 323 324 // 8.1.1 325 if ((isProtected() || isPrivate()) && !(isMemberType() && enclosingType().isClassDecl())) { 326 error("protected and private may only be used on member types within a directly enclosing class declaration"); 327 } 328 329 // 8.1.1 330 if (isStatic() && !isMemberType()) { 331 error("static pertains only to member types"); 332 } 333 334 335 // 8.4.3.1 336 // 8.1.1.1 337 if (!isAbstract() && hasAbstract()) { 338 StringBuilder sb = new StringBuilder(); 339 sb.append("" + name() + " is not declared abstract but contains abstract members: \n"); 340 for (Iterator iter = unimplementedMethods().iterator(); iter.hasNext(); ) { 341 MethodDecl m = (MethodDecl) iter.next(); 342 sb.append(" " + m.signature() + " in " + m.hostType().typeName() + "\n"); 343 } 344 error(sb.toString()); 345 } 346 } 347 /** 348 * @aspect NameCheck 349 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:316 350 */ 351 public void nameCheck() { 352 if (isTopLevelType() && lookupType(packageName(), name()) != this) { 353 errorf("duplicate type %s in package %s", name(), packageName()); 354 } 355 356 if (!isTopLevelType() && !isAnonymous() && !isLocalClass() && extractSingleType(enclosingType().memberTypes(name())) != this) { 357 errorf("duplicate member type %s in type %s", name(), enclosingType().typeName()); 358 } 359 360 // 14.3 361 if (isLocalClass()) { 362 TypeDecl typeDecl = extractSingleType(lookupType(name())); 363 if (typeDecl != null && typeDecl != this && typeDecl.isLocalClass() && enclosingBlock() == typeDecl.enclosingBlock()) { 364 errorf("local class named %s may not be redeclared as a local class in the same block", 365 name()); 366 } 367 } 368 369 if (!packageName().equals("") && hasPackage(fullName())) { 370 errorf("type name conflicts with a package using the same name: %s", name()); 371 } 372 373 // 8.1 & 9.1 374 if (hasEnclosingTypeDecl(name())) { 375 error("type may not have the same simple name as an enclosing type declaration"); 376 } 377 } 378 /** 379 * @aspect CreateQualifiedAccesses 380 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:110 381 */ 382 public Access createQualifiedAccess() { 383 if (isLocalClass() || isAnonymous()) { 384 return new TypeAccess(name()); 385 } else if (!isTopLevelType()) { 386 return enclosingType().createQualifiedAccess().qualifiesAccess(new TypeAccess(name())); 387 } else { 388 return new TypeAccess(packageName(), name()); 389 } 390 } 391 /** 392 * @aspect TypeAnalysis 393 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:258 394 */ 395 public FieldDeclaration findSingleVariable(String name) { 396 return (FieldDeclaration) memberFields(name).iterator().next(); 397 } 398 /** 399 * Iterate over interfaces which this type implements. 400 * @return interface iterator 401 * @aspect SuperClasses 402 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:671 403 */ 404 public Iterator<TypeDecl> interfacesIterator() { 405 return new Iterator<TypeDecl>() { 406 @Override 407 public boolean hasNext() { 408 return false; 409 } 410 @Override 411 public TypeDecl next() { 412 throw new NoSuchElementException("empty iterator"); 413 } 414 @Override 415 public void remove() { 416 throw new UnsupportedOperationException("empty iterator"); 417 } 418 }; 419 } 420 /** 421 * @aspect TypeHierarchyCheck 422 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:206 423 */ 424 public void refined_TypeHierarchyCheck_TypeDecl_typeCheck() { 425 // 8.4.6.4 & 9.4.1 426 for (Iterator iter1 = localMethodsIterator(); iter1.hasNext(); ) { 427 MethodDecl m = (MethodDecl) iter1.next(); 428 ASTNode target = m.hostType() == this ? (ASTNode) m : (ASTNode) this; 429 430 for (Iterator i2 = ancestorMethods(m.signature()).iterator(); i2.hasNext(); ) { 431 MethodDecl decl = (MethodDecl) i2.next(); 432 if (m.overrides(decl)) { 433 // 8.4.6.1 434 if (!m.isStatic() && decl.isStatic()) { 435 target.error("an instance method may not override a static method"); 436 } 437 438 // regardless of overriding 439 // 8.4.6.3 440 if (!m.mayOverride(decl)) { 441 target.errorf("the return type of method %s in %s does not match the return type of" 442 + " method %s in %s and may thus not be overridden", 443 m.fullSignature(), m.hostType().typeName(), decl.fullSignature(), 444 decl.hostType().typeName()); 445 } 446 447 // regardless of overriding 448 // 8.4.4 449 for (Access e: m.getExceptionList()) { 450 if (e.type().isCheckedException()) { 451 boolean found = false; 452 for (Access declException: decl.getExceptionList()) { 453 if (e.type().instanceOf(declException.type())) { 454 found = true; 455 break; 456 } 457 } 458 if (!found) { 459 target.errorf("%s in %s may not throw more checked exceptions than" 460 + " overridden method %s in %s", 461 m.fullSignature(), m.hostType().typeName(), decl.fullSignature(), 462 decl.hostType().typeName()); 463 } 464 } 465 } 466 467 // 8.4.6.3 468 if (decl.isPublic() && !m.isPublic()) { 469 target.error("overriding access modifier error"); 470 } 471 // 8.4.6.3 472 if (decl.isProtected() && !(m.isPublic() || m.isProtected())) { 473 target.error("overriding access modifier error"); 474 } 475 // 8.4.6.3 476 if ((!decl.isPrivate() && !decl.isProtected() && !decl.isPublic()) && m.isPrivate()) { 477 target.error("overriding access modifier error"); 478 } 479 // regardless of overriding 480 if (decl.isFinal()) { 481 target.errorf("method %s in %s can not override final method %s in %s", 482 m.fullSignature(), hostType().typeName(), decl.fullSignature(), 483 decl.hostType().typeName()); 484 } 485 } 486 if (m.hides(decl)) { 487 // 8.4.6.2 488 if (m.isStatic() && !decl.isStatic()) { 489 target.error("a static method may not hide an instance method"); 490 } 491 // 8.4.6.3 492 if (!m.mayOverride(decl)) { 493 target.error("can not hide a method with a different return type"); 494 } 495 // 8.4.4 496 for (int i = 0; i < m.getNumException(); i++) { 497 Access e = m.getException(i); 498 boolean found = false; 499 for (int j = 0; !found && j < decl.getNumException(); j++) { 500 if (e.type().instanceOf(decl.getException(j).type())) { 501 found = true; 502 } 503 } 504 if (!found) { 505 target.error("may not throw more checked exceptions than hidden method"); 506 } 507 } 508 // 8.4.6.3 509 if (decl.isPublic() && !m.isPublic()) { 510 target.errorf("hiding access modifier error:" 511 + " public method %s in %s is hidden by non public method %s in %s", 512 decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(), 513 m.hostType().typeName()); 514 } 515 // 8.4.6.3 516 if (decl.isProtected() && !(m.isPublic() || m.isProtected())) { 517 target.errorf("hiding access modifier error:" 518 + " protected method %s in %s is hidden by non (public|protected) method %s in %s", 519 decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(), 520 m.hostType().typeName()); 521 } 522 // 8.4.6.3 523 if ((!decl.isPrivate() && !decl.isProtected() && !decl.isPublic()) && m.isPrivate()) { 524 target.errorf("hiding access modifier error:" 525 + " default method %s in %s is hidden by private method %s in %s", 526 decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(), 527 m.hostType().typeName()); 528 } 529 if (decl.isFinal()) { 530 target.errorf("method %s in %s can not hide final method %s in %s", 531 m.fullSignature(), hostType().typeName(), decl.fullSignature(), 532 decl.hostType().typeName()); 533 } 534 } 535 } 536 } 537 } 538 /** 539 * Error-check two interface method declarations. 540 * @aspect TypeHierarchyCheck 541 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:486 542 */ 543 protected void refined_TypeHierarchyCheck_TypeDecl_checkAbstractMethodDecls(MethodDecl m1, MethodDecl m2) { 544 if (!m1.mayOverride(m2) && !m2.mayOverride(m1)) { 545 StringBuilder err = new StringBuilder(); 546 TypeDecl host1 = m1.hostType(); 547 TypeDecl host2 = m2.hostType(); 548 if (host1 != this || host2 != this) { 549 err.append("inherited "); 550 } 551 err.append("method " + m1.fullSignature() + " is multiply declared " 552 + "with incompatible return types in " + fullName()); 553 error(err.toString()); 554 } 555 } 556 /** 557 * @aspect Attributes 558 * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:80 559 */ 560 public int addConstant(ConstantPool p, Constant c) { 561 if (isString()) { 562 return p.addConstant(c.stringValue()); 563 } 564 throw new Error("Not supported"); 565 } 566 /** 567 * @aspect CodeGeneration 568 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:169 569 */ 570 public void emitPushConstant(CodeGeneration gen, int value) { } 571 /** 572 * @aspect CodeGeneration 573 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:240 574 */ 575 public void emitReturn(CodeGeneration gen) { error(); } 576 /** 577 * @aspect CodeGeneration 578 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:262 579 */ 580 public void emitLoadLocal(CodeGeneration gen, int pos) {error();} 581 /** 582 * @aspect CodeGeneration 583 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:405 584 */ 585 public void emitStoreLocal(CodeGeneration gen, int pos) {error();} 586 /** 587 * @aspect CodeGeneration 588 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:481 589 */ 590 public void emitDup(CodeGeneration gen) { gen.emit(Bytecode.DUP); } 591 /** 592 * @aspect CodeGeneration 593 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:486 594 */ 595 public void emitDup_x1(CodeGeneration gen) { gen.emit(Bytecode.DUP_X1); } 596 /** 597 * @aspect CodeGeneration 598 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:491 599 */ 600 public void emitDup_x2(CodeGeneration gen) { gen.emit(Bytecode.DUP_X2); } 601 /** 602 * @aspect CodeGeneration 603 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:496 604 */ 605 public void emitPop(CodeGeneration gen) { gen.emit(Bytecode.POP); } 606 /** 607 * @aspect CodeGeneration 608 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:567 609 */ 610 public void emitNew(CodeGeneration gen) { 611 int index = gen.constantPool().addClass(constantPoolName()); 612 gen.emit(Bytecode.NEW).add2(index); 613 } 614 /** 615 * @aspect CodeGenerationConversions 616 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:579 617 */ 618 void emitCastTo(CodeGeneration gen, TypeDecl type) { throw new Error("CastTo not implemented for " + getClass().getName()); } 619 /** 620 * @aspect CodeGenerationConversions 621 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:591 622 */ 623 void intToThis(CodeGeneration gen) { throw new Error("intToThis not implemented for " + getClass().getName()); } 624 /** 625 * @aspect CodeGenerationConversions 626 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:600 627 */ 628 void floatToThis(CodeGeneration gen) { throw new Error("floatToThis not implemented for " + getClass().getName()); } 629 /** 630 * @aspect CodeGenerationConversions 631 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:609 632 */ 633 void doubleToThis(CodeGeneration gen) { throw new Error("doubleToThis not implemented for " + getClass().getName()); } 634 /** 635 * @aspect CodeGenerationConversions 636 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:618 637 */ 638 void longToThis(CodeGeneration gen) { throw new Error("longToThis not implemented for " + getClass().getName()); } 639 /** 640 * @aspect CodeGenerationConversions 641 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:627 642 */ 643 void byteToThis(CodeGeneration gen) { throw new Error("byteToThis not implemented for " + getClass().getName()); } 644 /** 645 * @aspect CodeGenerationConversions 646 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:634 647 */ 648 void charToThis(CodeGeneration gen) { throw new Error("charToThis not implemented for " + getClass().getName()); } 649 /** 650 * @aspect CodeGenerationConversions 651 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:642 652 */ 653 void shortToThis(CodeGeneration gen) { throw new Error("shortToThis not implemented for " + getClass().getName()); } 654 /** 655 * @aspect CodeGenerationBinaryOperations 656 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:675 657 */ 658 void neg(CodeGeneration gen) { error(); } 659 /** 660 * @aspect CodeGenerationBinaryOperations 661 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:681 662 */ 663 void bitNot(CodeGeneration gen) { error(); } 664 /** 665 * @aspect CodeGenerationBinaryOperations 666 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:685 667 */ 668 void logNot(CodeGeneration gen) { error();} 669 /** 670 * @aspect CodeGenerationBinaryOperations 671 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:688 672 */ 673 void add(CodeGeneration gen) {error();} 674 /** 675 * @aspect CodeGenerationBinaryOperations 676 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:694 677 */ 678 void sub(CodeGeneration gen) {error();} 679 /** 680 * @aspect CodeGenerationBinaryOperations 681 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:700 682 */ 683 void mul(CodeGeneration gen) {error();} 684 /** 685 * @aspect CodeGenerationBinaryOperations 686 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:706 687 */ 688 void div(CodeGeneration gen) {error();} 689 /** 690 * @aspect CodeGenerationBinaryOperations 691 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:712 692 */ 693 void rem(CodeGeneration gen) {error();} 694 /** 695 * @aspect CodeGenerationBinaryOperations 696 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:718 697 */ 698 void shl(CodeGeneration gen) {error();} 699 /** 700 * @aspect CodeGenerationBinaryOperations 701 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:722 702 */ 703 void shr(CodeGeneration gen) {error();} 704 /** 705 * @aspect CodeGenerationBinaryOperations 706 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:726 707 */ 708 void ushr(CodeGeneration gen) {error();} 709 /** 710 * @aspect CodeGenerationBinaryOperations 711 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:730 712 */ 713 void bitand(CodeGeneration gen) {error();} 714 /** 715 * @aspect CodeGenerationBinaryOperations 716 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:735 717 */ 718 void bitor(CodeGeneration gen) {error();} 719 /** 720 * @aspect CodeGenerationBinaryOperations 721 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:740 722 */ 723 void bitxor(CodeGeneration gen) {error();} 724 /** 725 * @aspect CodeGenerationBranch 726 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:747 727 */ 728 public void branchLT(CodeGeneration gen, int label) { throw new Error("branchLT not supported for " + getClass().getName()); } 729 /** 730 * @aspect CodeGenerationBranch 731 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:753 732 */ 733 public void branchLTInv(CodeGeneration gen, int label) { branchLT(gen, label); } 734 /** 735 * @aspect CodeGenerationBranch 736 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:757 737 */ 738 public void branchLE(CodeGeneration gen, int label) { throw new Error("branchLE not supported for " + getClass().getName()); } 739 /** 740 * @aspect CodeGenerationBranch 741 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:763 742 */ 743 public void branchLEInv(CodeGeneration gen, int label) { branchLE(gen, label); } 744 /** 745 * @aspect CodeGenerationBranch 746 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:767 747 */ 748 public void branchGE(CodeGeneration gen, int label) { throw new Error("branchGE not supported for " + getClass().getName()); } 749 /** 750 * @aspect CodeGenerationBranch 751 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:773 752 */ 753 public void branchGEInv(CodeGeneration gen, int label) { branchGE(gen, label); } 754 /** 755 * @aspect CodeGenerationBranch 756 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:777 757 */ 758 public void branchGT(CodeGeneration gen, int label) { throw new Error("branchGT not supported for " + getClass().getName()); } 759 /** 760 * @aspect CodeGenerationBranch 761 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:783 762 */ 763 public void branchGTInv(CodeGeneration gen, int label) { branchGT(gen, label); } 764 /** 765 * @aspect CodeGenerationBranch 766 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:787 767 */ 768 public void branchEQ(CodeGeneration gen, int label) { throw new Error("branchEQ not supported for " + getClass().getName()); } 769 /** 770 * @aspect CodeGenerationBranch 771 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:796 772 */ 773 public void branchNE(CodeGeneration gen, int label) { throw new Error("branchNE not supported for " + getClass().getName()); } 774 /** 775 * @aspect CreateBCode 776 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:79 777 */ 778 private void generateBytecodes(CodeGeneration gen) { 779 for (int i = 0; i < getNumBodyDecl(); i++) { 780 BodyDecl b = getBodyDecl(i); 781 if (b instanceof FieldDeclaration && b.isBytecodeField()) { 782 FieldDeclaration f = (FieldDeclaration) b; 783 f.emitStaticInitializer(gen, this); 784 } else if (b instanceof StaticInitializer) { 785 b.createBCode(gen); 786 } 787 } 788 gen.emitReturn(); 789 } 790 /** 791 * @aspect Flags 792 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:49 793 */ 794 public int mangledFlags(int flags) { 795 boolean privateFlag = (flags & Modifiers.ACC_PRIVATE) != 0; 796 boolean protectedFlag = (flags & Modifiers.ACC_PROTECTED) != 0; 797 flags &= ~ Modifiers.ACC_PRIVATE; 798 flags &= ~ Modifiers.ACC_PROTECTED; 799 if (protectedFlag) { 800 flags |= Modifiers.ACC_PUBLIC; 801 } 802 return flags; 803 } 804 /** 805 * @aspect GenerateClassfile 806 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:48 807 */ 808 public void generateClassfile() { 809 for (Iterator iter = nestedTypes.iterator(); iter.hasNext(); ) { 810 TypeDecl typeDecl = (TypeDecl) iter.next(); 811 typeDecl.generateClassfile(); 812 } 813 } 814 /** 815 * @aspect GenerateClassfile 816 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:389 817 */ 818 public boolean clear() { 819 bytecodes(constantPool()).clearCodeGeneration(); 820 for (int i = 0; i < getNumBodyDecl(); i++) { 821 getBodyDecl(i).clear(); 822 } 823 attributes_computed = false; 824 attributes_value = null; 825 clinit_attributes_computed = false; 826 clinit_attributes_value = null; 827 constantPool_computed = false; 828 constantPool_value = null; 829 bytecodes_ConstantPool_values = null; 830 return false; 831 } 832 /** 833 * @aspect InnerClasses 834 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:33 835 */ 836 public boolean hasField(String name) { 837 if (!memberFields(name).isEmpty()) { 838 return true; 839 } 840 for (int i = 0; i < getNumBodyDecl(); i++) { 841 if (getBodyDecl(i) instanceof FieldDeclaration) { 842 FieldDeclaration decl = (FieldDeclaration) getBodyDecl(i); 843 if (decl.name().equals(name)) { 844 return true; 845 } 846 } 847 } 848 return false; 849 } 850 /** 851 * @aspect InnerClasses 852 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:62 853 */ 854 public boolean hasMethod(String id) { 855 if (!memberMethods(id).isEmpty()) { 856 return true; 857 } 858 for (int i = 0; i < getNumBodyDecl(); i++) { 859 if (getBodyDecl(i) instanceof MethodDecl) { 860 MethodDecl decl = (MethodDecl) getBodyDecl(i); 861 if (decl.name().equals(id)) { 862 return true; 863 } 864 } 865 } 866 return false; 867 } 868 /** 869 * @aspect InnerClasses 870 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:158 871 */ 872 public Collection<TypeDecl> nestedTypes = 873 new RobustLinkedList<TypeDecl>(); 874 /** 875 * @aspect InnerClasses 876 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:161 877 */ 878 public void addNestedType(TypeDecl typeDecl) { 879 if (typeDecl != this) { 880 nestedTypes.add(typeDecl); 881 } 882 } 883 /** 884 * @aspect InnerClasses 885 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:168 886 */ 887 public Collection<TypeDecl> usedNestedTypes = 888 new RobustLinkedList<TypeDecl>(); 889 /** 890 * @aspect InnerClasses 891 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:171 892 */ 893 public void addUsedNestedType(TypeDecl typeDecl) { 894 usedNestedTypes.add(typeDecl); 895 } 896 /** 897 * @aspect InnerClasses 898 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:206 899 */ 900 public int accessorCounter = 0; 901 /** 902 * @aspect InnerClasses 903 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:208 904 */ 905 private HashMap accessorMap = null; 906 /** 907 * @aspect InnerClasses 908 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:209 909 */ 910 public ASTNode getAccessor(ASTNode source, String name) { 911 ArrayList key = new ArrayList(2); 912 key.add(source); 913 key.add(name); 914 if (accessorMap == null || !accessorMap.containsKey(key)) { 915 return null; 916 } 917 return (ASTNode) accessorMap.get(key); 918 } 919 /** 920 * @aspect InnerClasses 921 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:219 922 */ 923 public void addAccessor(ASTNode source, String name, ASTNode accessor) { 924 ArrayList key = new ArrayList(2); 925 key.add(source); 926 key.add(name); 927 if (accessorMap == null) { 928 accessorMap = new HashMap(); 929 } 930 accessorMap.put(key, accessor); 931 } 932 /** 933 * @aspect InnerClasses 934 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:229 935 */ 936 public ASTNode getAccessorSource(ASTNode accessor) { 937 Iterator i = accessorMap.entrySet().iterator(); 938 while (i.hasNext()) { 939 Map.Entry entry = (Map.Entry) i.next(); 940 if (entry.getValue() == accessor) { 941 return (ASTNode) ((ArrayList) entry.getKey()).get(0); 942 } 943 } 944 return null; 945 } 946 /** 947 * @aspect InnerClasses 948 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:509 949 */ 950 private boolean addEnclosingVariables = true; 951 /** 952 * @aspect InnerClasses 953 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:510 954 */ 955 public void addEnclosingVariables() { 956 if (!addEnclosingVariables) { 957 return; 958 } 959 addEnclosingVariables = false; 960 for (Iterator iter = enclosingVariables().iterator(); iter.hasNext(); ) { 961 Variable v = (Variable) iter.next(); 962 Modifiers m = new Modifiers(); 963 m.addModifier(new Modifier("public")); 964 m.addModifier(new Modifier("synthetic")); 965 m.addModifier(new Modifier("final")); 966 addMemberField(new FieldDeclaration(m, v.type().createQualifiedAccess(), "val$" + v.name(), new Opt())); 967 } 968 } 969 /** 970 * @aspect Java2Rewrites 971 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:32 972 */ 973 int uniqueIndexCounter = 1; 974 /** 975 * @aspect Java2Rewrites 976 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:89 977 */ 978 private FieldDeclaration createAssertionsDisabled = null; 979 /** 980 * @aspect Java2Rewrites 981 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:90 982 */ 983 public FieldDeclaration createAssertionsDisabled() { 984 if (createAssertionsDisabled != null) { 985 return createAssertionsDisabled; 986 } 987 // static final boolean $assertionsDisabled = !TypeName.class.desiredAssertionStatus(); 988 createAssertionsDisabled = new FieldDeclaration( 989 new Modifiers(new List().add(new Modifier("public")).add(new Modifier("static")).add(new Modifier("final"))), 990 new PrimitiveTypeAccess("boolean"), 991 "$assertionsDisabled", 992 new Opt( 993 new LogNotExpr( 994 topLevelType().createQualifiedAccess().qualifiesAccess( 995 new ClassAccess().qualifiesAccess( 996 new MethodAccess( 997 "desiredAssertionStatus", 998 new List() 999 ) 1000 ) 1001 ) 1002 ) 1003 ) 1004 ); 1005 getBodyDeclList().insertChild(createAssertionsDisabled, 0); 1006 // TODO remove this! 1007 // explicit read to trigger possible rewrites 1008 createAssertionsDisabled = (FieldDeclaration) getBodyDeclList().getChild(0); 1009 // transform the generated initalization, e.g., the ClassAccess construct 1010 createAssertionsDisabled.transformation(); 1011 return createAssertionsDisabled; 1012 } 1013 /** 1014 * @aspect Java2Rewrites 1015 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:146 1016 */ 1017 private HashMap createStaticClassField = null; 1018 /** 1019 * @aspect Java2Rewrites 1020 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:147 1021 */ 1022 public FieldDeclaration createStaticClassField(String name) { 1023 if (createStaticClassField == null) { 1024 createStaticClassField = new HashMap(); 1025 } 1026 if (createStaticClassField.containsKey(name)) { 1027 return (FieldDeclaration) createStaticClassField.get(name); 1028 } 1029 // static synthetic Class class$java$lang$String; 1030 FieldDeclaration f = new FieldDeclaration( 1031 new Modifiers(new List().add(new Modifier("public")).add(new Modifier("static"))), 1032 lookupType("java.lang", "Class").createQualifiedAccess(), 1033 name, 1034 new Opt() 1035 ) { 1036 public boolean isConstant() { 1037 return true; 1038 } 1039 }; 1040 createStaticClassField.put(name, f); 1041 return addMemberField(f); 1042 } 1043 /** 1044 * @aspect Java2Rewrites 1045 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:170 1046 */ 1047 private MethodDecl createStaticClassMethod = null; 1048 /** 1049 * @aspect Java2Rewrites 1050 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:171 1051 */ 1052 public MethodDecl createStaticClassMethod() { 1053 if (createStaticClassMethod != null) { 1054 return createStaticClassMethod; 1055 } 1056 // static synthetic Class class$(String name) { 1057 // try { 1058 // return java.lang.Class.forName(name); 1059 // } catch(java.lang.ClassNotFoundException e) { 1060 // throw new java.lang.NoClassDefFoundError(e.getMessage()); 1061 // } 1062 // } 1063 createStaticClassMethod = new MethodDecl( 1064 new Modifiers(new List().add(new Modifier("public")).add(new Modifier("static"))), 1065 lookupType("java.lang", "Class").createQualifiedAccess(), 1066 "class$", 1067 new List().add( 1068 new ParameterDeclaration( 1069 new Modifiers(new List()), 1070 lookupType("java.lang", "String").createQualifiedAccess(), 1071 "name" 1072 ) 1073 ), 1074 new List(), 1075 new Opt( 1076 new Block( 1077 new List().add( 1078 new TryStmt( 1079 new Block( 1080 new List().add( 1081 new ReturnStmt( 1082 new Opt( 1083 lookupType("java.lang", "Class").createQualifiedAccess().qualifiesAccess( 1084 new MethodAccess( 1085 "forName", 1086 new List().add( 1087 new VarAccess("name") 1088 ) 1089 ) 1090 ) 1091 ) 1092 ) 1093 ) 1094 ), 1095 new List().add( 1096 new BasicCatch( 1097 new ParameterDeclaration( 1098 new Modifiers(new List()), 1099 lookupType("java.lang", "ClassNotFoundException").createQualifiedAccess(), 1100 "e" 1101 ), 1102 new Block( 1103 new List().add( 1104 new ThrowStmt( 1105 new ClassInstanceExpr( 1106 lookupType("java.lang", "NoClassDefFoundError").createQualifiedAccess(), 1107 new List().add( 1108 new VarAccess("e").qualifiesAccess( 1109 new MethodAccess( 1110 "getMessage", 1111 new List() 1112 ) 1113 ) 1114 ), 1115 new Opt() 1116 ) 1117 ) 1118 ) 1119 ) 1120 ) 1121 ), 1122 new Opt() 1123 ) 1124 ) 1125 ) 1126 ) 1127 ) { 1128 public boolean isConstant() { 1129 return true; 1130 } 1131 }; 1132 return addMemberMethod(createStaticClassMethod); 1133 } 1134 /** 1135 * @aspect Transformations 1136 * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:48 1137 */ 1138 public void transformation() { 1139 addEnclosingVariables(); 1140 super.transformation(); 1141 if (isNestedType()) { 1142 enclosingType().addNestedType(this); 1143 } 1144 } 1145 /** 1146 * @aspect Enums 1147 * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:511 1148 */ 1149 protected void checkEnum(EnumDecl enumDecl) { 1150 // non-EnumDecl TypeDecls should not check enum stuff 1151 } 1152 /** 1153 * @aspect Generics 1154 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:227 1155 */ 1156 public TypeDecl makeGeneric(Signatures.ClassSignature s) { 1157 return this; 1158 } 1159 /** 1160 * Merge the source map into the destination map. 1161 * @param dest destination map 1162 * @param src source map 1163 * @aspect GenericsTypeCheck 1164 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:554 1165 */ 1166 protected void mergeMap(Map<String,SimpleSet> dest, Map<String,SimpleSet> src) { 1167 for (Map.Entry<String,SimpleSet> entry: src.entrySet()) { 1168 String signature = entry.getKey(); 1169 for (Iterator iter = entry.getValue().iterator(); iter.hasNext(); ) { 1170 putSimpleSetElement(dest, signature, (SimpleSet) iter.next()); 1171 } 1172 } 1173 } 1174 /** 1175 * @aspect LookupParTypeDecl 1176 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:952 1177 */ 1178 public TypeDecl substitute(TypeVariable typeVariable) { 1179 if (isTopLevelType()) { 1180 return typeVariable; 1181 } 1182 return enclosingType().substitute(typeVariable); 1183 } 1184 /** 1185 * @aspect LookupParTypeDecl 1186 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1025 1187 */ 1188 public Access substitute(Parameterization parTypeDecl) { 1189 if (parTypeDecl instanceof ParTypeDecl && ((ParTypeDecl) parTypeDecl).genericDecl() == this) { 1190 return ((TypeDecl) parTypeDecl).createBoundAccess(); 1191 } 1192 if (isTopLevelType()) { 1193 return createBoundAccess(); 1194 } 1195 return enclosingType().substitute(parTypeDecl).qualifiesAccess(new TypeAccess(name())); 1196 } 1197 /** 1198 * @aspect LookupParTypeDecl 1199 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1084 1200 */ 1201 public Access substituteReturnType(Parameterization parTypeDecl) { 1202 return substitute(parTypeDecl); 1203 } 1204 /** 1205 * @aspect LookupParTypeDecl 1206 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1137 1207 */ 1208 public Access substituteParameterType(Parameterization parTypeDecl) { 1209 return substitute(parTypeDecl); 1210 } 1211 /** 1212 * Add an annotation parameter constant to the constant pool. 1213 * @see AST.TypeDecl#addConstant(ConstantPool, Constant) TypeDecl.addConstant(ConstantPool, Constant) 1214 * @aspect AnnotationsCodegen 1215 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:208 1216 */ 1217 public int addAnnotConstant(ConstantPool p, Constant c) { 1218 if (isString()) { 1219 return p.addUtf8(c.stringValue()); 1220 } 1221 throw new Error("Not supported"); 1222 } 1223 /** 1224 * @aspect AutoBoxingCodegen 1225 * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:115 1226 */ 1227 protected void emitBoxingOperation(CodeGeneration gen) { 1228 // Box the value on the stack into this Reference type 1229 String classname = constantPoolName(); 1230 String desc = "(" + unboxed().typeDescriptor() + ")" + typeDescriptor(); 1231 String name = "valueOf"; 1232 int index = gen.constantPool().addMethodref(classname, name, desc); 1233 gen.emit(Bytecode.INVOKESTATIC, variableSize() - unboxed().variableSize()).add2(index); 1234 } 1235 /** 1236 * @aspect AutoBoxingCodegen 1237 * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:133 1238 */ 1239 protected void emitUnboxingOperation(CodeGeneration gen) { 1240 // Unbox the value on the stack from this Reference type 1241 String classname = constantPoolName(); 1242 String desc = "(" + ")" + unboxed().typeDescriptor(); 1243 String name = unboxed().name() + "Value"; 1244 int index = gen.constantPool().addMethodref(classname, name, desc); 1245 gen.emit(Bytecode.INVOKEVIRTUAL, unboxed().variableSize() - 1).add2(index); 1246 } 1247 /** 1248 * @aspect EnumsCodegen 1249 * @declaredat /home/jesper/git/extendj/java5/backend/EnumsCodegen.jrag:106 1250 */ 1251 private HashMap createEnumIndexMap = null; 1252 /** 1253 * @aspect Java8NameCheck 1254 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:289 1255 */ 1256 protected void checkInterfaceMethodDecls(MethodDecl m1, MethodDecl m2) { 1257 if (m1.isAbstract() && m2.isAbstract()) { 1258 checkAbstractMethodDecls(m1, m2); 1259 return; 1260 } else { 1261 TypeDecl host1 = m1.hostType(); 1262 TypeDecl host2 = m2.hostType(); 1263 String inh1 = ""; 1264 String inh2 = ""; 1265 if (host1 != this) { 1266 inh1 = "inherited "; 1267 } 1268 if (host2 != this) { 1269 inh2 = "inherited "; 1270 } 1271 1272 //9.4 1273 errorf("%smethod %s and %smethod %s are multiply declared in %s", 1274 inh1, m1.fullSignature(), inh2, m2.fullSignature(), fullName()); 1275 } 1276 } 1277 /** 1278 * @declaredat ASTNode:1 1279 */ 1280 public TypeDecl() { 1281 super(); 1282 } 1283 /** 1284 * Initializes the child array to the correct size. 1285 * Initializes List and Opt nta children. 1286 * @apilevel internal 1287 * @ast method 1288 * @declaredat ASTNode:10 1289 */ 1290 public void init$Children() { 1291 children = new ASTNode[2]; 1292 setChild(new List(), 1); 1293 } 1294 /** 1295 * @declaredat ASTNode:14 1296 */ 1297 public TypeDecl(Modifiers p0, String p1, List<BodyDecl> p2) { 1298 setChild(p0, 0); 1299 setID(p1); 1300 setChild(p2, 1); 1301 } 1302 /** 1303 * @declaredat ASTNode:19 1304 */ 1305 public TypeDecl(Modifiers p0, beaver.Symbol p1, List<BodyDecl> p2) { 1306 setChild(p0, 0); 1307 setID(p1); 1308 setChild(p2, 1); 1309 } 1310 /** 1311 * @apilevel low-level 1312 * @declaredat ASTNode:27 1313 */ 1314 protected int numChildren() { 1315 return 2; 1316 } 1317 /** 1318 * @apilevel internal 1319 * @declaredat ASTNode:33 1320 */ 1321 public boolean mayHaveRewrite() { 1322 return false; 1323 } 1324 /** 1325 * @apilevel internal 1326 * @declaredat ASTNode:39 1327 */ 1328 public void flushAttrCache() { 1329 super.flushAttrCache(); 1330 accessibleFromPackage_String_reset(); 1331 accessibleFromExtend_TypeDecl_reset(); 1332 accessibleFrom_TypeDecl_reset(); 1333 dimension_reset(); 1334 elementType_reset(); 1335 arrayType_reset(); 1336 isException_reset(); 1337 isCheckedException_reset(); 1338 isUncheckedException_reset(); 1339 mayCatch_TypeDecl_reset(); 1340 constructors_reset(); 1341 unqualifiedLookupMethod_String_reset(); 1342 methodsNameMap_reset(); 1343 localMethodsSignatureMap_reset(); 1344 interfacesMethodsSignatureMap_reset(); 1345 methodsSignatureMap_reset(); 1346 ancestorMethods_String_reset(); 1347 localTypeDecls_String_reset(); 1348 memberTypes_String_reset(); 1349 localFields_String_reset(); 1350 localFieldsMap_reset(); 1351 memberFieldsMap_reset(); 1352 memberFields_String_reset(); 1353 hasAbstract_reset(); 1354 unimplementedMethods_reset(); 1355 isPublic_reset(); 1356 isStatic_reset(); 1357 fullName_reset(); 1358 typeName_reset(); 1359 narrowingConversionTo_TypeDecl_reset(); 1360 methodInvocationConversionTo_TypeDecl_reset(); 1361 castingConversionTo_TypeDecl_reset(); 1362 isString_reset(); 1363 isObject_reset(); 1364 instanceOf_TypeDecl_reset(); 1365 isCircular_reset(); 1366 innerClassesAttributeEntries_reset(); 1367 attributes_reset(); 1368 clinit_attributes_reset(); 1369 constantPool_reset(); 1370 constantPoolName_reset(); 1371 uniqueName_reset(); 1372 typeDescriptor_reset(); 1373 destinationPath_reset(); 1374 hasClinit_reset(); 1375 bytecodes_ConstantPool_reset(); 1376 flags_reset(); 1377 bcFields_reset(); 1378 enclosingVariables_reset(); 1379 needsEnclosing_reset(); 1380 needsSuperEnclosing_reset(); 1381 uniqueIndex_reset(); 1382 jvmName_reset(); 1383 boxed_reset(); 1384 unboxed_reset(); 1385 isIterable_reset(); 1386 involvesTypeParameters_reset(); 1387 erasure_reset(); 1388 erasedAncestorMethodsMap_reset(); 1389 implementedInterfaces_reset(); 1390 usesTypeVariable_reset(); 1391 sourceTypeDecl_reset(); 1392 containedIn_TypeDecl_reset(); 1393 sameStructure_TypeDecl_reset(); 1394 subtype_TypeDecl_reset(); 1395 createEnumMethod_TypeDecl_reset(); 1396 createEnumIndex_EnumConstant_reset(); 1397 createEnumArray_TypeDecl_reset(); 1398 needsSignatureAttribute_reset(); 1399 classSignature_reset(); 1400 fieldTypeSignature_reset(); 1401 classTypeSignature_reset(); 1402 isFunctionalInterface_reset(); 1403 strictContainedIn_TypeDecl_reset(); 1404 strictSubtype_TypeDecl_reset(); 1405 componentType_reset(); 1406 isDAbefore_Variable_reset(); 1407 isDUbefore_Variable_reset(); 1408 typeException_reset(); 1409 typeRuntimeException_reset(); 1410 typeError_reset(); 1411 lookupMethod_String_reset(); 1412 typeObject_reset(); 1413 lookupType_String_reset(); 1414 lookupVariable_String_reset(); 1415 packageName_reset(); 1416 isAnonymous_reset(); 1417 unknownType_reset(); 1418 inExplicitConstructorInvocation_reset(); 1419 inStaticContext_reset(); 1420 } 1421 /** 1422 * @apilevel internal 1423 * @declaredat ASTNode:135 1424 */ 1425 public void flushCollectionCache() { 1426 super.flushCollectionCache(); 1427 } 1428 /** 1429 * @apilevel internal 1430 * @declaredat ASTNode:141 1431 */ 1432 public void flushRewriteCache() { 1433 super.flushRewriteCache(); 1434 } 1435 /** 1436 * @apilevel internal 1437 * @declaredat ASTNode:147 1438 */ 1439 public TypeDecl clone() throws CloneNotSupportedException { 1440 TypeDecl node = (TypeDecl) super.clone(); 1441 return node; 1442 } 1443 /** 1444 * Create a deep copy of the AST subtree at this node. 1445 * The copy is dangling, i.e. has no parent. 1446 * @return dangling copy of the subtree at this node 1447 * @apilevel low-level 1448 * @deprecated Please use treeCopy or treeCopyNoTransform instead 1449 * @declaredat ASTNode:158 1450 */ 1451 @Deprecated 1452 public abstract TypeDecl fullCopy(); 1453 /** 1454 * Create a deep copy of the AST subtree at this node. 1455 * The copy is dangling, i.e. has no parent. 1456 * @return dangling copy of the subtree at this node 1457 * @apilevel low-level 1458 * @declaredat ASTNode:166 1459 */ 1460 public abstract TypeDecl treeCopyNoTransform(); 1461 /** 1462 * Create a deep copy of the AST subtree at this node. 1463 * The subtree of this node is traversed to trigger rewrites before copy. 1464 * The copy is dangling, i.e. has no parent. 1465 * @return dangling copy of the subtree at this node 1466 * @apilevel low-level 1467 * @declaredat ASTNode:174 1468 */ 1469 public abstract TypeDecl treeCopy(); 1470 /** 1471 * Replaces the Modifiers child. 1472 * @param node The new node to replace the Modifiers child. 1473 * @apilevel high-level 1474 */ 1475 public void setModifiers(Modifiers node) { 1476 setChild(node, 0); 1477 } 1478 /** 1479 * Retrieves the Modifiers child. 1480 * @return The current node used as the Modifiers child. 1481 * @apilevel high-level 1482 */ 1483 @ASTNodeAnnotation.Child(name="Modifiers") 1484 public Modifiers getModifiers() { 1485 return (Modifiers) getChild(0); 1486 } 1487 /** 1488 * Retrieves the Modifiers child. 1489 * <p><em>This method does not invoke AST transformations.</em></p> 1490 * @return The current node used as the Modifiers child. 1491 * @apilevel low-level 1492 */ 1493 public Modifiers getModifiersNoTransform() { 1494 return (Modifiers) getChildNoTransform(0); 1495 } 1496 /** 1497 * Replaces the lexeme ID. 1498 * @param value The new value for the lexeme ID. 1499 * @apilevel high-level 1500 */ 1501 public void setID(String value) { 1502 tokenString_ID = value; 1503 } 1504 /** 1505 * @apilevel internal 1506 */ 1507 protected String tokenString_ID; 1508 /** 1509 */ 1510 public int IDstart; 1511 /** 1512 */ 1513 public int IDend; 1514 /** 1515 * JastAdd-internal setter for lexeme ID using the Beaver parser. 1516 * @param symbol Symbol containing the new value for the lexeme ID 1517 * @apilevel internal 1518 */ 1519 public void setID(beaver.Symbol symbol) { 1520 if (symbol.value != null && !(symbol.value instanceof String)) 1521 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 1522 tokenString_ID = (String)symbol.value; 1523 IDstart = symbol.getStart(); 1524 IDend = symbol.getEnd(); 1525 } 1526 /** 1527 * Retrieves the value for the lexeme ID. 1528 * @return The value for the lexeme ID. 1529 * @apilevel high-level 1530 */ 1531 @ASTNodeAnnotation.Token(name="ID") 1532 public String getID() { 1533 return tokenString_ID != null ? tokenString_ID : ""; 1534 } 1535 /** 1536 * Replaces the BodyDecl list. 1537 * @param list The new list node to be used as the BodyDecl list. 1538 * @apilevel high-level 1539 */ 1540 public void setBodyDeclList(List<BodyDecl> list) { 1541 setChild(list, 1); 1542 } 1543 /** 1544 * Retrieves the number of children in the BodyDecl list. 1545 * @return Number of children in the BodyDecl list. 1546 * @apilevel high-level 1547 */ 1548 public int getNumBodyDecl() { 1549 return getBodyDeclList().getNumChild(); 1550 } 1551 /** 1552 * Retrieves the number of children in the BodyDecl list. 1553 * Calling this method will not trigger rewrites. 1554 * @return Number of children in the BodyDecl list. 1555 * @apilevel low-level 1556 */ 1557 public int getNumBodyDeclNoTransform() { 1558 return getBodyDeclListNoTransform().getNumChildNoTransform(); 1559 } 1560 /** 1561 * Retrieves the element at index {@code i} in the BodyDecl list. 1562 * @param i Index of the element to return. 1563 * @return The element at position {@code i} in the BodyDecl list. 1564 * @apilevel high-level 1565 */ 1566 public BodyDecl getBodyDecl(int i) { 1567 return (BodyDecl) getBodyDeclList().getChild(i); 1568 } 1569 /** 1570 * Check whether the BodyDecl list has any children. 1571 * @return {@code true} if it has at least one child, {@code false} otherwise. 1572 * @apilevel high-level 1573 */ 1574 public boolean hasBodyDecl() { 1575 return getBodyDeclList().getNumChild() != 0; 1576 } 1577 /** 1578 * Append an element to the BodyDecl list. 1579 * @param node The element to append to the BodyDecl list. 1580 * @apilevel high-level 1581 */ 1582 public void addBodyDecl(BodyDecl node) { 1583 List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList(); 1584 list.addChild(node); 1585 } 1586 /** 1587 * @apilevel low-level 1588 */ 1589 public void addBodyDeclNoTransform(BodyDecl node) { 1590 List<BodyDecl> list = getBodyDeclListNoTransform(); 1591 list.addChild(node); 1592 } 1593 /** 1594 * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}. 1595 * @param node The new node to replace the old list element. 1596 * @param i The list index of the node to be replaced. 1597 * @apilevel high-level 1598 */ 1599 public void setBodyDecl(BodyDecl node, int i) { 1600 List<BodyDecl> list = getBodyDeclList(); 1601 list.setChild(node, i); 1602 } 1603 /** 1604 * Retrieves the BodyDecl list. 1605 * @return The node representing the BodyDecl list. 1606 * @apilevel high-level 1607 */ 1608 @ASTNodeAnnotation.ListChild(name="BodyDecl") 1609 public List<BodyDecl> getBodyDeclList() { 1610 List<BodyDecl> list = (List<BodyDecl>) getChild(1); 1611 return list; 1612 } 1613 /** 1614 * Retrieves the BodyDecl list. 1615 * <p><em>This method does not invoke AST transformations.</em></p> 1616 * @return The node representing the BodyDecl list. 1617 * @apilevel low-level 1618 */ 1619 public List<BodyDecl> getBodyDeclListNoTransform() { 1620 return (List<BodyDecl>) getChildNoTransform(1); 1621 } 1622 /** 1623 * Retrieves the BodyDecl list. 1624 * @return The node representing the BodyDecl list. 1625 * @apilevel high-level 1626 */ 1627 public List<BodyDecl> getBodyDecls() { 1628 return getBodyDeclList(); 1629 } 1630 /** 1631 * Retrieves the BodyDecl list. 1632 * <p><em>This method does not invoke AST transformations.</em></p> 1633 * @return The node representing the BodyDecl list. 1634 * @apilevel low-level 1635 */ 1636 public List<BodyDecl> getBodyDeclsNoTransform() { 1637 return getBodyDeclListNoTransform(); 1638 } 1639 /** 1640 * @aspect Modifiers 1641 * @declaredat /home/jesper/git/extendj/java8/frontend/Modifiers.jrag:113 1642 */ 1643 1644 public void checkModifiers() { 1645 refined_Modifiers_TypeDecl_checkModifiers(); 1646 if (getModifiers().numModifier("default") != 0) { 1647 error("the default modifier is only legal for interface method declarations"); 1648 } 1649 } 1650 /** 1651 * @aspect AutoBoxingCodegen 1652 * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:339 1653 */ 1654 void emitAssignConvTo(CodeGeneration gen, TypeDecl type) { 1655 if (!type.isIntegralType() || !isIntegralType() || type.isLong() || type.isReferenceType() || isReferenceType()) { 1656 emitCastTo(gen, type); 1657 } 1658 } 1659 /** 1660 * @aspect GenericsTypeCheck 1661 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:456 1662 */ 1663 public void refined_GenericsTypeCheck_TypeDecl_typeCheck() { 1664 refined_TypeHierarchyCheck_TypeDecl_typeCheck(); 1665 ArrayList<InterfaceDecl> interfaceList = new ArrayList<InterfaceDecl>(); 1666 interfaceList.addAll(implementedInterfaces()); 1667 for (InterfaceDecl decl: interfaceList) { 1668 if (decl instanceof ParInterfaceDecl) { 1669 ParInterfaceDecl p = (ParInterfaceDecl) decl; 1670 for (InterfaceDecl decl2: interfaceList) { 1671 if (decl2 instanceof ParInterfaceDecl) { 1672 ParInterfaceDecl q = (ParInterfaceDecl) decl2; 1673 if (p != q && p.genericDecl() == q.genericDecl() && !p.sameArgument(q)) { 1674 errorf("%s cannot be inherited with different type arguments: %s and %s", 1675 p.genericDecl().name(), p.typeName(), q.typeName()); 1676 } 1677 } 1678 } 1679 } 1680 } 1681 1682 // Check if a method has same signature as another in a supertype but does not override it. 1683 Map<String,SimpleSet> map = erasedAncestorMethodsMap(); 1684 for (Iterator iter1 = localMethodsIterator(); iter1.hasNext(); ) { 1685 MethodDecl localMethod = (MethodDecl) iter1.next(); 1686 1687 String signature = localMethod.signature(); 1688 1689 SimpleSet set = map.get(signature); 1690 if (set != null) { 1691 for (Iterator i2 = set.iterator(); i2.hasNext(); ) { 1692 MethodDecl decl = (MethodDecl) i2.next(); 1693 if (!decl.signature().equals(signature)) { 1694 localMethod.errorf("method %s in %s has the same erased signature as" 1695 + " %s declared in %s but does not override it", 1696 signature, typeName(), decl.signature(), decl.hostType().typeName()); 1697 } 1698 } 1699 } 1700 } 1701 } 1702 /** 1703 * @aspect TypeCheck 1704 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:163 1705 */ 1706 protected void refined_TypeCheck_TypeDecl_checkAbstractMethodDecls(MethodDecl m1, MethodDecl m2) { 1707 1708 if (!m1.sameSignature(m2)) { 1709 errorf("method declarations %s and %s in interface %s are incompatible", 1710 m1.fullSignature(), m2.fullSignature(), fullName()); 1711 } else { 1712 refined_TypeHierarchyCheck_TypeDecl_checkAbstractMethodDecls(m1, m2); 1713 } 1714 } 1715 /** 1716 * @aspect Java8TypeHierarchyCheck 1717 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeHierarchyCheck.jrag:30 1718 */ 1719 1720 public void typeCheck() { 1721 // 8.4.6.4 & 9.4.1 1722 for (Iterator iter1 = localMethodsIterator(); iter1.hasNext(); ) { 1723 MethodDecl m = (MethodDecl)iter1.next(); 1724 ASTNode target = m.hostType() == this ? (ASTNode)m : (ASTNode)this; 1725 1726 for (Iterator i2 = ancestorMethods(m.signature()).iterator(); i2.hasNext(); ) { 1727 MethodDecl decl = (MethodDecl)i2.next(); 1728 if (m.overrides(decl)) { 1729 // 8.4.6.1 1730 if (!decl.hostType().isInterfaceDecl() && !m.isStatic() && decl.isStatic()) { 1731 target.error("an instance method may not override a static method"); 1732 } 1733 1734 // regardless of overriding 1735 // 8.4.6.3 1736 if (!m.mayOverride(decl)) { 1737 // 9.4.3 1738 if (m.isDefault() && decl.hostType() == m.type().typeObject() && !decl.isPrivate()) { 1739 target.error("default methods may not override methods in Object"); 1740 } else { 1741 target.errorf("the return type of method %s in %s does not match the return type of" 1742 + " method %s in %s and may thus not be overridden", 1743 m.fullSignature(), m.hostType().typeName(), decl.fullSignature(), 1744 decl.hostType().typeName()); 1745 } 1746 } 1747 1748 // regardless of overriding 1749 // 8.4.4 1750 for (Access e: m.getExceptionList()) { 1751 if (e.type().isCheckedException()) { 1752 boolean found = false; 1753 for (Access declException: decl.getExceptionList()) { 1754 if (e.type().instanceOf(declException.type())) { 1755 found = true; 1756 break; 1757 } 1758 } 1759 if (!found) { 1760 target.errorf("%s in %s may not throw more checked exceptions than" 1761 + " overridden method %s in %s", 1762 m.fullSignature(), m.hostType().typeName(), decl.fullSignature(), 1763 decl.hostType().typeName()); 1764 } 1765 } 1766 } 1767 1768 // 8.4.6.3 1769 if (decl.isPublic() && !m.isPublic()) { 1770 target.error("overriding access modifier error"); 1771 } 1772 // 8.4.6.3 1773 if (decl.isProtected() && !(m.isPublic() || m.isProtected())) { 1774 target.error("overriding access modifier error"); 1775 } 1776 // 8.4.6.3 1777 if ((!decl.isPrivate() && !decl.isProtected() && !decl.isPublic()) && m.isPrivate()) { 1778 target.error("overriding access modifier error"); 1779 } 1780 // regardless of overriding 1781 if (decl.isFinal()) { 1782 target.errorf("method %s in %s can not override final method %s in %s", 1783 m.fullSignature(), hostType().typeName(), decl.fullSignature(), 1784 decl.hostType().typeName()); 1785 } 1786 } 1787 if (m.hides(decl)) { 1788 // 8.4.6.2 1789 if (m.isStatic() && !decl.isStatic()) { 1790 target.error("a static method may not hide an instance method"); 1791 } 1792 // 8.4.6.3 1793 if (!m.mayOverride(decl)) { 1794 target.error("can not hide a method with a different return type"); 1795 } 1796 // 8.4.4 1797 for (int i = 0; i < m.getNumException(); i++) { 1798 Access e = m.getException(i); 1799 boolean found = false; 1800 for (int j = 0; !found && j < decl.getNumException(); j++) { 1801 if (e.type().instanceOf(decl.getException(j).type())) { 1802 found = true; 1803 } 1804 } 1805 if (!found) { 1806 target.error("may not throw more checked exceptions than hidden method"); 1807 } 1808 } 1809 // 8.4.6.3 1810 if (decl.isPublic() && !m.isPublic()) { 1811 target.errorf("hiding access modifier: public method %s in %s is hidden by" 1812 + " non public method %s in %s", 1813 decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(), 1814 m.hostType().typeName()); 1815 } 1816 // 8.4.6.3 1817 if (decl.isProtected() && !(m.isPublic() || m.isProtected())) { 1818 target.errorf("hiding access modifier: protected method %s in %s is hidden by" 1819 + " non (public|protected) method %s in %s", 1820 decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(), 1821 m.hostType().typeName()); 1822 } 1823 // 8.4.6.3 1824 if ((!decl.isPrivate() && !decl.isProtected() && !decl.isPublic()) && m.isPrivate()) { 1825 target.errorf("hiding access modifier: default method %s in %s is hidden by" 1826 + " private method %s in %s", 1827 decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(), 1828 m.hostType().typeName()); 1829 } 1830 if (decl.isFinal()) { 1831 target.errorf("method %s in %s can not hide final method %s in %s", 1832 m.fullSignature(), hostType().typeName(), decl.fullSignature(), 1833 decl.hostType().typeName()); 1834 } 1835 } 1836 } 1837 } 1838 1839 1840 // different parameterizations of the same generic interface may not be implemented 1841 ArrayList list = new ArrayList(); 1842 list.addAll(implementedInterfaces()); 1843 for (int i = 0; i < list.size(); i++) { 1844 InterfaceDecl decl = (InterfaceDecl)list.get(i); 1845 if (decl instanceof ParInterfaceDecl) { 1846 ParInterfaceDecl p = (ParInterfaceDecl)decl; 1847 for (Iterator i2 = list.listIterator(i); i2.hasNext(); ) { 1848 InterfaceDecl decl2 = (InterfaceDecl)i2.next(); 1849 if (decl2 instanceof ParInterfaceDecl) { 1850 ParInterfaceDecl q = (ParInterfaceDecl)decl2; 1851 if (p != q && p.genericDecl() == q.genericDecl() && !p.sameArgument(q)) { 1852 errorf("%s cannot be inherited with different type arguments: %s and %s", 1853 p.genericDecl().name(), p.typeName(), q.typeName()); 1854 } 1855 } 1856 } 1857 } 1858 } 1859 } 1860 /** 1861 * @aspect Java8NameCheck 1862 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:256 1863 */ 1864 1865 protected void checkAbstractMethodDecls(MethodDecl m1, MethodDecl m2) { 1866 if (!m1.subsignatureTo(m2) && !m2.subsignatureTo(m1)) { 1867 TypeDecl host1 = m1.hostType(); 1868 TypeDecl host2 = m2.hostType(); 1869 String inh1 = ""; 1870 String inh2 = ""; 1871 if (host1 != this) { 1872 inh1 = "inherited "; 1873 } 1874 if (host2 != this) { 1875 inh2 = "inherited "; 1876 } 1877 1878 //8.4.8.3 1879 errorf("%smethod %s and %smethod %s are multiply declared with" 1880 + " the same erasure but not override-equivalent signatures in %s", 1881 inh1, m1.fullSignature(), inh2, m2.fullSignature(), fullName()); 1882 } 1883 // DON'T FORGET TO CHECK THIS, REALLY OK TO CHECK BOTH WAYS??? 1884 if (!m1.returnTypeSubstitutableFor(m2) && !m2.returnTypeSubstitutableFor(m1)) { 1885 String inh1 = ""; 1886 TypeDecl host1 = m1.hostType(); 1887 TypeDecl host2 = m2.hostType(); 1888 if (host1 != this || host2 != this) { 1889 inh1 = "inherited "; 1890 } 1891 1892 errorf("%smethod %s is multiply declared with incompatible return types in %s", 1893 m1.fullSignature(), fullName()); 1894 } 1895 } 1896 /** 1897 * @aspect TypeConversion 1898 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:86 1899 */ 1900 private boolean refined_TypeConversion_TypeDecl_assignConversionTo_TypeDecl_Expr(TypeDecl type, Expr expr) 1901 { 1902 //System.out.println("@@@ " + fullName() + " assign conversion to " + type.fullName() + ", expr: " + expr); 1903 boolean sourceIsConstant = expr != null ? expr.isConstant() : false; 1904 //System.out.println("@@@ sourceIsConstant: " + sourceIsConstant); 1905 if (identityConversionTo(type) || wideningConversionTo(type)) { 1906 return true; 1907 } 1908 //System.out.println("@@@ narrowing conversion needed"); 1909 //System.out.println("@@@ value: " + expr.value()); 1910 if (sourceIsConstant && (isInt() || isChar() || isShort() || isByte()) && 1911 (type.isByte() || type.isShort() || type.isChar()) && 1912 narrowingConversionTo(type) && expr.representableIn(type)) 1913 return true; 1914 //System.out.println("@@@ false"); 1915 return false; 1916 } 1917 /** 1918 * @aspect TypeConversion 1919 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:104 1920 */ 1921 private boolean refined_TypeConversion_TypeDecl_methodInvocationConversionTo_TypeDecl(TypeDecl type) 1922 { 1923 return identityConversionTo(type) || wideningConversionTo(type); 1924 } 1925 /** 1926 * @aspect TypeConversion 1927 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:109 1928 */ 1929 private boolean refined_TypeConversion_TypeDecl_castingConversionTo_TypeDecl(TypeDecl type) 1930 { return identityConversionTo(type) || 1931 wideningConversionTo(type) || narrowingConversionTo(type); } 1932 /** 1933 * @aspect Attributes 1934 * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:191 1935 */ 1936 private Collection refined_Attributes_TypeDecl_attributes() 1937 { 1938 Collection c = new ArrayList(); 1939 if (!innerClassesAttributeEntries().isEmpty()) { 1940 c.add(new InnerClassesAttribute(this)); 1941 } 1942 if (isSynthetic()) { 1943 c.add(new SyntheticAttribute(constantPool())); 1944 } 1945 if (compilationUnit().fromSource()) { 1946 String relativeName = compilationUnit().relativeName(); 1947 if (relativeName != null) { 1948 String splitToken = java.io.File.separator; 1949 if (splitToken.equals("\\")) { 1950 splitToken = "\\\\"; 1951 } 1952 String[] strings = relativeName.split(splitToken); 1953 c.add(new SourceFileAttribute(constantPool(), strings[strings.length-1])); 1954 } 1955 } 1956 return c; 1957 } 1958 /** 1959 * @aspect AnnotationsCodegen 1960 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:32 1961 */ 1962 private Collection refined_AnnotationsCodegen_TypeDecl_attributes() 1963 { 1964 Collection c = refined_Attributes_TypeDecl_attributes(); 1965 getModifiers().addRuntimeVisibleAnnotationsAttribute(c); 1966 getModifiers().addRuntimeInvisibleAnnotationsAttribute(c); 1967 return c; 1968 } 1969 /** 1970 * @aspect GenericsCodegen 1971 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:313 1972 */ 1973 private Collection refined_GenericsCodegen_TypeDecl_attributes() 1974 { 1975 Collection c = refined_AnnotationsCodegen_TypeDecl_attributes(); 1976 if (needsSignatureAttribute()) { 1977 c.add(new SignatureAttribute(constantPool(), classSignature())); 1978 } 1979 return c; 1980 } 1981 /** 1982 * @apilevel internal 1983 */ 1984 protected java.util.Map accessibleFromPackage_String_values; 1985 /** 1986 * @apilevel internal 1987 */ 1988 private void accessibleFromPackage_String_reset() { 1989 accessibleFromPackage_String_values = null; 1990 } 1991 /** 1992 * @attribute syn 1993 * @aspect AccessControl 1994 * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:36 1995 */ 1996 @ASTNodeAnnotation.Attribute 1997 public boolean accessibleFromPackage(String packageName) { 1998 Object _parameters = packageName; 1999 if (accessibleFromPackage_String_values == null) accessibleFromPackage_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2000 ASTNode$State state = state(); 2001 if (accessibleFromPackage_String_values.containsKey(_parameters)) { 2002 return (Boolean) accessibleFromPackage_String_values.get(_parameters); 2003 } 2004 boolean intermediate = state.INTERMEDIATE_VALUE; 2005 state.INTERMEDIATE_VALUE = false; 2006 int num = state.boundariesCrossed; 2007 boolean isFinal = this.is$Final(); 2008 boolean accessibleFromPackage_String_value = !isPrivate() && (isPublic() || hostPackage().equals(packageName)); 2009 if (isFinal && num == state().boundariesCrossed) { 2010 accessibleFromPackage_String_values.put(_parameters, accessibleFromPackage_String_value); 2011 } else { 2012 } 2013 state.INTERMEDIATE_VALUE |= intermediate; 2014 2015 return accessibleFromPackage_String_value; 2016 } 2017 /** 2018 * @apilevel internal 2019 */ 2020 protected java.util.Map accessibleFromExtend_TypeDecl_values; 2021 /** 2022 * @apilevel internal 2023 */ 2024 private void accessibleFromExtend_TypeDecl_reset() { 2025 accessibleFromExtend_TypeDecl_values = null; 2026 } 2027 /** 2028 * @attribute syn 2029 * @aspect AccessControl 2030 * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:41 2031 */ 2032 @ASTNodeAnnotation.Attribute 2033 public boolean accessibleFromExtend(TypeDecl type) { 2034 Object _parameters = type; 2035 if (accessibleFromExtend_TypeDecl_values == null) accessibleFromExtend_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2036 ASTNode$State state = state(); 2037 if (accessibleFromExtend_TypeDecl_values.containsKey(_parameters)) { 2038 return (Boolean) accessibleFromExtend_TypeDecl_values.get(_parameters); 2039 } 2040 boolean intermediate = state.INTERMEDIATE_VALUE; 2041 state.INTERMEDIATE_VALUE = false; 2042 int num = state.boundariesCrossed; 2043 boolean isFinal = this.is$Final(); 2044 boolean accessibleFromExtend_TypeDecl_value = accessibleFromExtend_compute(type); 2045 if (isFinal && num == state().boundariesCrossed) { 2046 accessibleFromExtend_TypeDecl_values.put(_parameters, accessibleFromExtend_TypeDecl_value); 2047 } else { 2048 } 2049 state.INTERMEDIATE_VALUE |= intermediate; 2050 2051 return accessibleFromExtend_TypeDecl_value; 2052 } 2053 /** 2054 * @apilevel internal 2055 */ 2056 private boolean accessibleFromExtend_compute(TypeDecl type) { 2057 if (type == this) { 2058 return true; 2059 } 2060 if (isInnerType()) { 2061 if (!enclosingType().accessibleFrom(type)) { 2062 return false; 2063 } 2064 } 2065 if (isPublic()) { 2066 return true; 2067 } else if (isProtected()) { 2068 // isProtected implies a nested type 2069 if (hostPackage().equals(type.hostPackage())) { 2070 return true; 2071 } 2072 if (type.isNestedType() && type.enclosingType().withinBodyThatSubclasses(enclosingType()) != null) { 2073 return true; 2074 } 2075 return false; 2076 } else if (isPrivate()) { 2077 return topLevelType() == type.topLevelType(); 2078 } else { 2079 return hostPackage().equals(type.hostPackage()); 2080 } 2081 } 2082 /** 2083 * @apilevel internal 2084 */ 2085 protected java.util.Map accessibleFrom_TypeDecl_values; 2086 /** 2087 * @apilevel internal 2088 */ 2089 private void accessibleFrom_TypeDecl_reset() { 2090 accessibleFrom_TypeDecl_values = null; 2091 } 2092 /** 2093 * @attribute syn 2094 * @aspect AccessControl 2095 * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:68 2096 */ 2097 @ASTNodeAnnotation.Attribute 2098 public boolean accessibleFrom(TypeDecl type) { 2099 Object _parameters = type; 2100 if (accessibleFrom_TypeDecl_values == null) accessibleFrom_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2101 ASTNode$State state = state(); 2102 if (accessibleFrom_TypeDecl_values.containsKey(_parameters)) { 2103 return (Boolean) accessibleFrom_TypeDecl_values.get(_parameters); 2104 } 2105 boolean intermediate = state.INTERMEDIATE_VALUE; 2106 state.INTERMEDIATE_VALUE = false; 2107 int num = state.boundariesCrossed; 2108 boolean isFinal = this.is$Final(); 2109 boolean accessibleFrom_TypeDecl_value = accessibleFrom_compute(type); 2110 if (isFinal && num == state().boundariesCrossed) { 2111 accessibleFrom_TypeDecl_values.put(_parameters, accessibleFrom_TypeDecl_value); 2112 } else { 2113 } 2114 state.INTERMEDIATE_VALUE |= intermediate; 2115 2116 return accessibleFrom_TypeDecl_value; 2117 } 2118 /** 2119 * @apilevel internal 2120 */ 2121 private boolean accessibleFrom_compute(TypeDecl type) { 2122 if (type == this) { 2123 return true; 2124 } 2125 if (isInnerType()) { 2126 if (!enclosingType().accessibleFrom(type)) { 2127 return false; 2128 } 2129 } 2130 if (isPublic()) { 2131 return true; 2132 } else if (isProtected()) { 2133 if (hostPackage().equals(type.hostPackage())) { 2134 return true; 2135 } 2136 if (isMemberType()) { 2137 TypeDecl typeDecl = type; 2138 while (typeDecl != null && !typeDecl.instanceOf(enclosingType())) { 2139 typeDecl = typeDecl.enclosingType(); 2140 } 2141 if (typeDecl != null) { 2142 return true; 2143 } 2144 } 2145 return false; 2146 } else if (isPrivate()) { 2147 return topLevelType() == type.topLevelType(); 2148 } else { 2149 return hostPackage().equals(type.hostPackage()); 2150 } 2151 } 2152 /** 2153 * @apilevel internal 2154 */ 2155 protected boolean dimension_computed = false; 2156 /** 2157 * @apilevel internal 2158 */ 2159 protected int dimension_value; 2160 /** 2161 * @apilevel internal 2162 */ 2163 private void dimension_reset() { 2164 dimension_computed = false; 2165 } 2166 /** 2167 * @attribute syn 2168 * @aspect Arrays 2169 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:32 2170 */ 2171 @ASTNodeAnnotation.Attribute 2172 public int dimension() { 2173 ASTNode$State state = state(); 2174 if (dimension_computed) { 2175 return dimension_value; 2176 } 2177 boolean intermediate = state.INTERMEDIATE_VALUE; 2178 state.INTERMEDIATE_VALUE = false; 2179 int num = state.boundariesCrossed; 2180 boolean isFinal = this.is$Final(); 2181 dimension_value = 0; 2182 if (isFinal && num == state().boundariesCrossed) { 2183 dimension_computed = true; 2184 } else { 2185 } 2186 state.INTERMEDIATE_VALUE |= intermediate; 2187 2188 return dimension_value; 2189 } 2190 /** 2191 * @apilevel internal 2192 */ 2193 protected boolean elementType_computed = false; 2194 /** 2195 * @apilevel internal 2196 */ 2197 protected TypeDecl elementType_value; 2198 /** 2199 * @apilevel internal 2200 */ 2201 private void elementType_reset() { 2202 elementType_computed = false; 2203 elementType_value = null; 2204 } 2205 /** 2206 * @attribute syn 2207 * @aspect Arrays 2208 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:36 2209 */ 2210 @ASTNodeAnnotation.Attribute 2211 public TypeDecl elementType() { 2212 ASTNode$State state = state(); 2213 if (elementType_computed) { 2214 return elementType_value; 2215 } 2216 boolean intermediate = state.INTERMEDIATE_VALUE; 2217 state.INTERMEDIATE_VALUE = false; 2218 int num = state.boundariesCrossed; 2219 boolean isFinal = this.is$Final(); 2220 elementType_value = this; 2221 if (isFinal && num == state().boundariesCrossed) { 2222 elementType_computed = true; 2223 } else { 2224 } 2225 state.INTERMEDIATE_VALUE |= intermediate; 2226 2227 return elementType_value; 2228 } 2229 /** 2230 * @apilevel internal 2231 */ 2232 protected boolean arrayType_computed = false; 2233 /** 2234 * @apilevel internal 2235 */ 2236 protected TypeDecl arrayType_value; 2237 /** 2238 * @apilevel internal 2239 */ 2240 private void arrayType_reset() { 2241 arrayType_computed = false; 2242 arrayType_value = null; 2243 } 2244 /** 2245 * @attribute syn 2246 * @aspect Arrays 2247 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:44 2248 */ 2249 @ASTNodeAnnotation.Attribute 2250 public TypeDecl arrayType() { 2251 ASTNode$State state = state(); 2252 if (arrayType_computed) { 2253 return arrayType_value; 2254 } 2255 boolean intermediate = state.INTERMEDIATE_VALUE; 2256 state.INTERMEDIATE_VALUE = false; 2257 int num = state.boundariesCrossed; 2258 boolean isFinal = this.is$Final(); 2259 arrayType_value = arrayType_compute(); 2260 arrayType_value.setParent(this); 2261 arrayType_value.is$Final = true; 2262 if (true) { 2263 arrayType_computed = true; 2264 } else { 2265 } 2266 state.INTERMEDIATE_VALUE |= intermediate; 2267 2268 return arrayType_value; 2269 } 2270 /** 2271 * @apilevel internal 2272 */ 2273 private TypeDecl arrayType_compute() { 2274 String name = name() + "[]"; 2275 2276 List body = new List(); 2277 body.add( 2278 new FieldDeclaration( 2279 new Modifiers(new List().add(new Modifier("public")).add(new Modifier("final"))), 2280 new PrimitiveTypeAccess("int"), 2281 "length", 2282 new Opt() // [Init:Expr] 2283 ) 2284 ); 2285 MethodDecl clone = null; 2286 TypeDecl typeObject = typeObject(); 2287 for (int i = 0; clone == null && i < typeObject.getNumBodyDecl(); i++) { 2288 if (typeObject.getBodyDecl(i) instanceof MethodDecl) { 2289 MethodDecl m = (MethodDecl) typeObject.getBodyDecl(i); 2290 if (m.name().equals("clone")) { 2291 clone = m; 2292 } 2293 } 2294 } 2295 if (clone != null) { 2296 body.add( 2297 // we create a substituted method that substitutes the clone method in object 2298 // this has the following two consequences: the return value will be cast to the 2299 // expected return type rather than object, and the invoked method will be the 2300 // method in object rather in the array 2301 new MethodDeclSubstituted( 2302 new Modifiers(new List().add(new Modifier("public"))), 2303 new ArrayTypeAccess(createQualifiedAccess()), 2304 "clone", 2305 new List(), 2306 new List(), 2307 new Opt(new Block()), 2308 (MethodDecl) typeObject().memberMethods("clone").iterator().next() 2309 ) 2310 ); 2311 } 2312 TypeDecl typeDecl = new ArrayDecl( 2313 new Modifiers(new List().add(new Modifier("public"))), 2314 name, 2315 new Opt(typeObject().createQualifiedAccess()), // [SuperClass] 2316 new List().add(typeCloneable().createQualifiedAccess()).add(typeSerializable().createQualifiedAccess()), // Implements* 2317 body // BodyDecl* 2318 ); 2319 return typeDecl; 2320 } 2321 /** 2322 * @attribute syn 2323 * @aspect ConstantExpression 2324 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:72 2325 */ 2326 @ASTNodeAnnotation.Attribute 2327 public Constant cast(Constant c) { 2328 { 2329 throw new UnsupportedOperationException("ConstantExpression operation cast" 2330 + " not supported for type " + getClass().getName()); 2331 } 2332 } 2333 /** 2334 * @attribute syn 2335 * @aspect ConstantExpression 2336 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:86 2337 */ 2338 @ASTNodeAnnotation.Attribute 2339 public Constant plus(Constant c) { 2340 { 2341 throw new UnsupportedOperationException("ConstantExpression operation plus" 2342 + " not supported for type " + getClass().getName()); 2343 } 2344 } 2345 /** 2346 * @attribute syn 2347 * @aspect ConstantExpression 2348 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:95 2349 */ 2350 @ASTNodeAnnotation.Attribute 2351 public Constant minus(Constant c) { 2352 { 2353 throw new UnsupportedOperationException("ConstantExpression operation minus" 2354 + " not supported for type " + getClass().getName()); 2355 } 2356 } 2357 /** 2358 * @attribute syn 2359 * @aspect ConstantExpression 2360 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:104 2361 */ 2362 @ASTNodeAnnotation.Attribute 2363 public Constant bitNot(Constant c) { 2364 { 2365 throw new UnsupportedOperationException("ConstantExpression operation bitNot" 2366 + " not supported for type " + getClass().getName()); 2367 } 2368 } 2369 /** 2370 * @attribute syn 2371 * @aspect ConstantExpression 2372 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:111 2373 */ 2374 @ASTNodeAnnotation.Attribute 2375 public Constant mul(Constant c1, Constant c2) { 2376 { 2377 throw new UnsupportedOperationException("ConstantExpression operation mul" 2378 + " not supported for type " + getClass().getName()); 2379 } 2380 } 2381 /** 2382 * @attribute syn 2383 * @aspect ConstantExpression 2384 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:120 2385 */ 2386 @ASTNodeAnnotation.Attribute 2387 public Constant div(Constant c1, Constant c2) { 2388 { 2389 throw new UnsupportedOperationException("ConstantExpression operation div" 2390 + " not supported for type " + getClass().getName()); 2391 } 2392 } 2393 /** 2394 * @attribute syn 2395 * @aspect ConstantExpression 2396 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:129 2397 */ 2398 @ASTNodeAnnotation.Attribute 2399 public Constant mod(Constant c1, Constant c2) { 2400 { 2401 throw new UnsupportedOperationException("ConstantExpression operation mod" 2402 + " not supported for type " + getClass().getName()); 2403 } 2404 } 2405 /** 2406 * @attribute syn 2407 * @aspect ConstantExpression 2408 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:138 2409 */ 2410 @ASTNodeAnnotation.Attribute 2411 public Constant add(Constant c1, Constant c2) { 2412 { 2413 throw new UnsupportedOperationException("ConstantExpression operation add" 2414 + " not supported for type " + getClass().getName()); 2415 } 2416 } 2417 /** 2418 * @attribute syn 2419 * @aspect ConstantExpression 2420 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:148 2421 */ 2422 @ASTNodeAnnotation.Attribute 2423 public Constant sub(Constant c1, Constant c2) { 2424 { 2425 throw new UnsupportedOperationException("ConstantExpression operation sub" 2426 + " not supported for type " + getClass().getName()); 2427 } 2428 } 2429 /** 2430 * @attribute syn 2431 * @aspect ConstantExpression 2432 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:157 2433 */ 2434 @ASTNodeAnnotation.Attribute 2435 public Constant lshift(Constant c1, Constant c2) { 2436 { 2437 throw new UnsupportedOperationException("ConstantExpression operation lshift" 2438 + " not supported for type " + getClass().getName()); 2439 } 2440 } 2441 /** 2442 * @attribute syn 2443 * @aspect ConstantExpression 2444 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:164 2445 */ 2446 @ASTNodeAnnotation.Attribute 2447 public Constant rshift(Constant c1, Constant c2) { 2448 { 2449 throw new UnsupportedOperationException("ConstantExpression operation rshift" 2450 + " not supported for type " + getClass().getName()); 2451 } 2452 } 2453 /** 2454 * @attribute syn 2455 * @aspect ConstantExpression 2456 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:171 2457 */ 2458 @ASTNodeAnnotation.Attribute 2459 public Constant urshift(Constant c1, Constant c2) { 2460 { 2461 throw new UnsupportedOperationException("ConstantExpression operation urshift" 2462 + " not supported for type " + getClass().getName()); 2463 } 2464 } 2465 /** 2466 * @attribute syn 2467 * @aspect ConstantExpression 2468 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:178 2469 */ 2470 @ASTNodeAnnotation.Attribute 2471 public Constant andBitwise(Constant c1, Constant c2) { 2472 { 2473 throw new UnsupportedOperationException("ConstantExpression operation andBitwise" 2474 + " not supported for type " + getClass().getName()); 2475 } 2476 } 2477 /** 2478 * @attribute syn 2479 * @aspect ConstantExpression 2480 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:186 2481 */ 2482 @ASTNodeAnnotation.Attribute 2483 public Constant xorBitwise(Constant c1, Constant c2) { 2484 { 2485 throw new UnsupportedOperationException("ConstantExpression operation xorBitwise" 2486 + " not supported for type " + getClass().getName()); 2487 } 2488 } 2489 /** 2490 * @attribute syn 2491 * @aspect ConstantExpression 2492 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:194 2493 */ 2494 @ASTNodeAnnotation.Attribute 2495 public Constant orBitwise(Constant c1, Constant c2) { 2496 { 2497 throw new UnsupportedOperationException("ConstantExpression operation orBitwise" 2498 + " not supported for type " + getClass().getName()); 2499 } 2500 } 2501 /** 2502 * @attribute syn 2503 * @aspect ConstantExpression 2504 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:202 2505 */ 2506 @ASTNodeAnnotation.Attribute 2507 public Constant questionColon(Constant cond, Constant c1, Constant c2) { 2508 { 2509 throw new UnsupportedOperationException("ConstantExpression operation questionColon" 2510 + " not supported for type " + getClass().getName()); 2511 } 2512 } 2513 /** 2514 * @attribute syn 2515 * @aspect ConstantExpression 2516 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:326 2517 */ 2518 @ASTNodeAnnotation.Attribute 2519 public boolean eqIsTrue(Expr left, Expr right) { 2520 { 2521 System.err.println("Evaluation eqIsTrue for unknown type: " + getClass().getName()); 2522 return false; 2523 } 2524 } 2525 /** 2526 * @attribute syn 2527 * @aspect ConstantExpression 2528 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:337 2529 */ 2530 @ASTNodeAnnotation.Attribute 2531 public boolean ltIsTrue(Expr left, Expr right) { 2532 boolean ltIsTrue_Expr_Expr_value = false; 2533 2534 return ltIsTrue_Expr_Expr_value; 2535 } 2536 /** 2537 * @attribute syn 2538 * @aspect ConstantExpression 2539 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:343 2540 */ 2541 @ASTNodeAnnotation.Attribute 2542 public boolean leIsTrue(Expr left, Expr right) { 2543 boolean leIsTrue_Expr_Expr_value = false; 2544 2545 return leIsTrue_Expr_Expr_value; 2546 } 2547 /** 2548 * @attribute syn 2549 * @aspect DataStructures 2550 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:157 2551 */ 2552 @ASTNodeAnnotation.Attribute 2553 public int size() { 2554 int size_value = 1; 2555 2556 return size_value; 2557 } 2558 /** 2559 * @attribute syn 2560 * @aspect DataStructures 2561 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:158 2562 */ 2563 @ASTNodeAnnotation.Attribute 2564 public boolean isEmpty() { 2565 boolean isEmpty_value = false; 2566 2567 return isEmpty_value; 2568 } 2569 /** 2570 * @attribute syn 2571 * @aspect DataStructures 2572 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:162 2573 */ 2574 @ASTNodeAnnotation.Attribute 2575 public boolean contains(Object o) { 2576 boolean contains_Object_value = this == o; 2577 2578 return contains_Object_value; 2579 } 2580 /** 2581 * @attribute syn 2582 * @aspect DocumentationComments 2583 * @declaredat /home/jesper/git/extendj/java4/frontend/DocumentationComments.jadd:39 2584 */ 2585 @ASTNodeAnnotation.Attribute 2586 public String docComment() { 2587 String docComment_value = docComment; 2588 2589 return docComment_value; 2590 } 2591 /** 2592 * @attribute syn 2593 * @aspect DocumentationComments 2594 * @declaredat /home/jesper/git/extendj/java4/frontend/DocumentationComments.jadd:43 2595 */ 2596 @ASTNodeAnnotation.Attribute 2597 public boolean hasDocComment() { 2598 boolean hasDocComment_value = !docComment.isEmpty(); 2599 2600 return hasDocComment_value; 2601 } 2602 /** 2603 * @apilevel internal 2604 */ 2605 protected boolean isException_computed = false; 2606 /** 2607 * @apilevel internal 2608 */ 2609 protected boolean isException_value; 2610 /** 2611 * @apilevel internal 2612 */ 2613 private void isException_reset() { 2614 isException_computed = false; 2615 } 2616 /** 2617 * @attribute syn 2618 * @aspect ExceptionHandling 2619 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:51 2620 */ 2621 @ASTNodeAnnotation.Attribute 2622 public boolean isException() { 2623 ASTNode$State state = state(); 2624 if (isException_computed) { 2625 return isException_value; 2626 } 2627 boolean intermediate = state.INTERMEDIATE_VALUE; 2628 state.INTERMEDIATE_VALUE = false; 2629 int num = state.boundariesCrossed; 2630 boolean isFinal = this.is$Final(); 2631 isException_value = instanceOf(typeException()); 2632 if (isFinal && num == state().boundariesCrossed) { 2633 isException_computed = true; 2634 } else { 2635 } 2636 state.INTERMEDIATE_VALUE |= intermediate; 2637 2638 return isException_value; 2639 } 2640 /** 2641 * @apilevel internal 2642 */ 2643 protected boolean isCheckedException_computed = false; 2644 /** 2645 * @apilevel internal 2646 */ 2647 protected boolean isCheckedException_value; 2648 /** 2649 * @apilevel internal 2650 */ 2651 private void isCheckedException_reset() { 2652 isCheckedException_computed = false; 2653 } 2654 /** 2655 * Checked exceptions must be declared thrown or caught in 2656 * an enclosing try-statement. 2657 * 2658 * Note that this attribute is the opposite of isUncheckedException, i.e. 2659 * the type is not tested for being a subclass of java.lang.Exception. 2660 * 2661 * @return {@code true} if this type is not a subtype of java.lang.RuntimException 2662 * or java.lang.Error 2663 * @attribute syn 2664 * @aspect ExceptionHandling 2665 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:63 2666 */ 2667 @ASTNodeAnnotation.Attribute 2668 public boolean isCheckedException() { 2669 ASTNode$State state = state(); 2670 if (isCheckedException_computed) { 2671 return isCheckedException_value; 2672 } 2673 boolean intermediate = state.INTERMEDIATE_VALUE; 2674 state.INTERMEDIATE_VALUE = false; 2675 int num = state.boundariesCrossed; 2676 boolean isFinal = this.is$Final(); 2677 isCheckedException_value = !(instanceOf(typeRuntimeException()) || instanceOf(typeError())); 2678 if (isFinal && num == state().boundariesCrossed) { 2679 isCheckedException_computed = true; 2680 } else { 2681 } 2682 state.INTERMEDIATE_VALUE |= intermediate; 2683 2684 return isCheckedException_value; 2685 } 2686 /** 2687 * @apilevel internal 2688 */ 2689 protected boolean isUncheckedException_computed = false; 2690 /** 2691 * @apilevel internal 2692 */ 2693 protected boolean isUncheckedException_value; 2694 /** 2695 * @apilevel internal 2696 */ 2697 private void isUncheckedException_reset() { 2698 isUncheckedException_computed = false; 2699 } 2700 /** 2701 * Unchecked exceptions need not be declared thrown or caught in 2702 * an enclosing try-statement. 2703 * 2704 * @return {@code true} if this type is a subtype of java.lang.RuntimException 2705 * or java.lang.Error 2706 * @attribute syn 2707 * @aspect ExceptionHandling 2708 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:73 2709 */ 2710 @ASTNodeAnnotation.Attribute 2711 public boolean isUncheckedException() { 2712 ASTNode$State state = state(); 2713 if (isUncheckedException_computed) { 2714 return isUncheckedException_value; 2715 } 2716 boolean intermediate = state.INTERMEDIATE_VALUE; 2717 state.INTERMEDIATE_VALUE = false; 2718 int num = state.boundariesCrossed; 2719 boolean isFinal = this.is$Final(); 2720 isUncheckedException_value = instanceOf(typeRuntimeException()) || instanceOf(typeError()); 2721 if (isFinal && num == state().boundariesCrossed) { 2722 isUncheckedException_computed = true; 2723 } else { 2724 } 2725 state.INTERMEDIATE_VALUE |= intermediate; 2726 2727 return isUncheckedException_value; 2728 } 2729 /** 2730 * @apilevel internal 2731 */ 2732 protected java.util.Map mayCatch_TypeDecl_values; 2733 /** 2734 * @apilevel internal 2735 */ 2736 private void mayCatch_TypeDecl_reset() { 2737 mayCatch_TypeDecl_values = null; 2738 } 2739 /** 2740 * @attribute syn 2741 * @aspect ExceptionHandling 2742 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:305 2743 */ 2744 @ASTNodeAnnotation.Attribute 2745 public boolean mayCatch(TypeDecl thrownType) { 2746 Object _parameters = thrownType; 2747 if (mayCatch_TypeDecl_values == null) mayCatch_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2748 ASTNode$State state = state(); 2749 if (mayCatch_TypeDecl_values.containsKey(_parameters)) { 2750 return (Boolean) mayCatch_TypeDecl_values.get(_parameters); 2751 } 2752 boolean intermediate = state.INTERMEDIATE_VALUE; 2753 state.INTERMEDIATE_VALUE = false; 2754 int num = state.boundariesCrossed; 2755 boolean isFinal = this.is$Final(); 2756 boolean mayCatch_TypeDecl_value = thrownType.instanceOf(this) || this.instanceOf(thrownType); 2757 if (isFinal && num == state().boundariesCrossed) { 2758 mayCatch_TypeDecl_values.put(_parameters, mayCatch_TypeDecl_value); 2759 } else { 2760 } 2761 state.INTERMEDIATE_VALUE |= intermediate; 2762 2763 return mayCatch_TypeDecl_value; 2764 } 2765 /** 2766 * @attribute syn 2767 * @aspect ConstructScope 2768 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:42 2769 */ 2770 @ASTNodeAnnotation.Attribute 2771 public Collection lookupSuperConstructor() { 2772 Collection lookupSuperConstructor_value = Collections.EMPTY_LIST; 2773 2774 return lookupSuperConstructor_value; 2775 } 2776 /** 2777 * @apilevel internal 2778 */ 2779 protected boolean constructors_computed = false; 2780 /** 2781 * @apilevel internal 2782 */ 2783 protected Collection<ConstructorDecl> constructors_value; 2784 /** 2785 * @apilevel internal 2786 */ 2787 private void constructors_reset() { 2788 constructors_computed = false; 2789 constructors_value = null; 2790 } 2791 /** 2792 * @attribute syn 2793 * @aspect ConstructorLookup 2794 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:127 2795 */ 2796 @ASTNodeAnnotation.Attribute 2797 public Collection<ConstructorDecl> constructors() { 2798 ASTNode$State state = state(); 2799 if (constructors_computed) { 2800 return constructors_value; 2801 } 2802 boolean intermediate = state.INTERMEDIATE_VALUE; 2803 state.INTERMEDIATE_VALUE = false; 2804 int num = state.boundariesCrossed; 2805 boolean isFinal = this.is$Final(); 2806 constructors_value = constructors_compute(); 2807 if (isFinal && num == state().boundariesCrossed) { 2808 constructors_computed = true; 2809 } else { 2810 } 2811 state.INTERMEDIATE_VALUE |= intermediate; 2812 2813 return constructors_value; 2814 } 2815 /** 2816 * @apilevel internal 2817 */ 2818 private Collection<ConstructorDecl> constructors_compute() { 2819 Collection<ConstructorDecl> c = new ArrayList(); 2820 for (int i = 0; i < getNumBodyDecl(); i++) { 2821 if (getBodyDecl(i) instanceof ConstructorDecl) { 2822 c.add((ConstructorDecl) getBodyDecl(i)); 2823 } 2824 } 2825 return c; 2826 } 2827 /** 2828 * @apilevel internal 2829 */ 2830 protected java.util.Map unqualifiedLookupMethod_String_values; 2831 /** 2832 * @apilevel internal 2833 */ 2834 private void unqualifiedLookupMethod_String_reset() { 2835 unqualifiedLookupMethod_String_values = null; 2836 } 2837 /** 2838 * @attribute syn 2839 * @aspect LookupMethod 2840 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:58 2841 */ 2842 @ASTNodeAnnotation.Attribute 2843 public Collection unqualifiedLookupMethod(String name) { 2844 Object _parameters = name; 2845 if (unqualifiedLookupMethod_String_values == null) unqualifiedLookupMethod_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2846 ASTNode$State state = state(); 2847 if (unqualifiedLookupMethod_String_values.containsKey(_parameters)) { 2848 return (Collection) unqualifiedLookupMethod_String_values.get(_parameters); 2849 } 2850 boolean intermediate = state.INTERMEDIATE_VALUE; 2851 state.INTERMEDIATE_VALUE = false; 2852 int num = state.boundariesCrossed; 2853 boolean isFinal = this.is$Final(); 2854 Collection unqualifiedLookupMethod_String_value = unqualifiedLookupMethod_compute(name); 2855 if (isFinal && num == state().boundariesCrossed) { 2856 unqualifiedLookupMethod_String_values.put(_parameters, unqualifiedLookupMethod_String_value); 2857 } else { 2858 } 2859 state.INTERMEDIATE_VALUE |= intermediate; 2860 2861 return unqualifiedLookupMethod_String_value; 2862 } 2863 /** 2864 * @apilevel internal 2865 */ 2866 private Collection unqualifiedLookupMethod_compute(String name) { 2867 Collection c = memberMethods(name); 2868 if (!c.isEmpty()) { 2869 return c; 2870 } 2871 if (isInnerType()) { 2872 return lookupMethod(name); 2873 } 2874 return removeInstanceMethods(lookupMethod(name)); 2875 } 2876 /** 2877 * @attribute syn 2878 * @aspect MemberMethods 2879 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:317 2880 */ 2881 @ASTNodeAnnotation.Attribute 2882 public Collection<MethodDecl> memberMethods(String name) { 2883 { 2884 Collection<MethodDecl> c = methodsNameMap().get(name); 2885 if (c != null) { 2886 return c; 2887 } else { 2888 return Collections.emptyList(); 2889 } 2890 } 2891 } 2892 /** 2893 * @apilevel internal 2894 */ 2895 protected boolean methodsNameMap_computed = false; 2896 /** 2897 * @apilevel internal 2898 */ 2899 protected Map<String,Collection<MethodDecl>> methodsNameMap_value; 2900 /** 2901 * @apilevel internal 2902 */ 2903 private void methodsNameMap_reset() { 2904 methodsNameMap_computed = false; 2905 methodsNameMap_value = null; 2906 } 2907 /** 2908 * @return map from method name to method declarations 2909 * @attribute syn 2910 * @aspect MemberMethods 2911 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:328 2912 */ 2913 @ASTNodeAnnotation.Attribute 2914 public Map<String,Collection<MethodDecl>> methodsNameMap() { 2915 ASTNode$State state = state(); 2916 if (methodsNameMap_computed) { 2917 return methodsNameMap_value; 2918 } 2919 boolean intermediate = state.INTERMEDIATE_VALUE; 2920 state.INTERMEDIATE_VALUE = false; 2921 int num = state.boundariesCrossed; 2922 boolean isFinal = this.is$Final(); 2923 methodsNameMap_value = methodsNameMap_compute(); 2924 if (isFinal && num == state().boundariesCrossed) { 2925 methodsNameMap_computed = true; 2926 } else { 2927 } 2928 state.INTERMEDIATE_VALUE |= intermediate; 2929 2930 return methodsNameMap_value; 2931 } 2932 /** 2933 * @apilevel internal 2934 */ 2935 private Map<String,Collection<MethodDecl>> methodsNameMap_compute() { 2936 Map<String,Collection<MethodDecl>> map = new HashMap<String,Collection<MethodDecl>>(); 2937 for (Iterator<MethodDecl> iter = methodsIterator(); iter.hasNext(); ) { 2938 MethodDecl m = iter.next(); 2939 Collection<MethodDecl> methods = map.get(m.name()); 2940 if (methods == null) { 2941 methods = new ArrayList<MethodDecl>(4); 2942 map.put(m.name(), methods); 2943 } 2944 methods.add(m); 2945 } 2946 return map; 2947 } 2948 /** 2949 * @attribute syn 2950 * @aspect MemberMethods 2951 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:363 2952 */ 2953 @ASTNodeAnnotation.Attribute 2954 public SimpleSet localMethodsSignature(String signature) { 2955 { 2956 SimpleSet set = localMethodsSignatureMap().get(signature); 2957 if (set != null) { 2958 return set; 2959 } 2960 return SimpleSet.emptySet; 2961 } 2962 } 2963 /** 2964 * @apilevel internal 2965 */ 2966 protected boolean localMethodsSignatureMap_computed = false; 2967 /** 2968 * @apilevel internal 2969 */ 2970 protected Map<String,SimpleSet> localMethodsSignatureMap_value; 2971 /** 2972 * @apilevel internal 2973 */ 2974 private void localMethodsSignatureMap_reset() { 2975 localMethodsSignatureMap_computed = false; 2976 localMethodsSignatureMap_value = null; 2977 } 2978 /** 2979 * @return a mapping of method signature to method declaration 2980 * @attribute syn 2981 * @aspect MemberMethods 2982 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:374 2983 */ 2984 @ASTNodeAnnotation.Attribute 2985 public Map<String,SimpleSet> localMethodsSignatureMap() { 2986 ASTNode$State state = state(); 2987 if (localMethodsSignatureMap_computed) { 2988 return localMethodsSignatureMap_value; 2989 } 2990 boolean intermediate = state.INTERMEDIATE_VALUE; 2991 state.INTERMEDIATE_VALUE = false; 2992 int num = state.boundariesCrossed; 2993 boolean isFinal = this.is$Final(); 2994 localMethodsSignatureMap_value = localMethodsSignatureMap_compute(); 2995 if (isFinal && num == state().boundariesCrossed) { 2996 localMethodsSignatureMap_computed = true; 2997 } else { 2998 } 2999 state.INTERMEDIATE_VALUE |= intermediate; 3000 3001 return localMethodsSignatureMap_value; 3002 } 3003 /** 3004 * @apilevel internal 3005 */ 3006 private Map<String,SimpleSet> localMethodsSignatureMap_compute() { 3007 Map<String,SimpleSet> map = new HashMap<String,SimpleSet>(getNumBodyDecl()); 3008 for (int i = 0; i < getNumBodyDecl(); i++) { 3009 if (getBodyDecl(i) instanceof MethodDecl) { 3010 MethodDecl decl = (MethodDecl) getBodyDecl(i); 3011 putSimpleSetElement(map, decl.signature(), decl); 3012 } 3013 } 3014 return map; 3015 } 3016 /** 3017 * @apilevel internal 3018 */ 3019 protected boolean interfacesMethodsSignatureMap_computed = false; 3020 /** 3021 * @apilevel internal 3022 */ 3023 protected Map<String,SimpleSet> interfacesMethodsSignatureMap_value; 3024 /** 3025 * @apilevel internal 3026 */ 3027 private void interfacesMethodsSignatureMap_reset() { 3028 interfacesMethodsSignatureMap_computed = false; 3029 interfacesMethodsSignatureMap_value = null; 3030 } 3031 /** 3032 * Map signature to set of method declarations. 3033 * @attribute syn 3034 * @aspect MemberMethods 3035 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:418 3036 */ 3037 @ASTNodeAnnotation.Attribute 3038 public Map<String,SimpleSet> interfacesMethodsSignatureMap() { 3039 ASTNode$State state = state(); 3040 if (interfacesMethodsSignatureMap_computed) { 3041 return interfacesMethodsSignatureMap_value; 3042 } 3043 boolean intermediate = state.INTERMEDIATE_VALUE; 3044 state.INTERMEDIATE_VALUE = false; 3045 int num = state.boundariesCrossed; 3046 boolean isFinal = this.is$Final(); 3047 interfacesMethodsSignatureMap_value = interfacesMethodsSignatureMap_compute(); 3048 if (isFinal && num == state().boundariesCrossed) { 3049 interfacesMethodsSignatureMap_computed = true; 3050 } else { 3051 } 3052 state.INTERMEDIATE_VALUE |= intermediate; 3053 3054 return interfacesMethodsSignatureMap_value; 3055 } 3056 /** 3057 * @apilevel internal 3058 */ 3059 private Map<String,SimpleSet> interfacesMethodsSignatureMap_compute() { 3060 Map<String,SimpleSet> map = new HashMap<String,SimpleSet>(); 3061 for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); ) { 3062 InterfaceDecl iface = (InterfaceDecl) iter.next(); 3063 for (Iterator<MethodDecl> i2 = iface.localMethodsIterator(); i2.hasNext(); ) { 3064 MethodDecl m = i2.next(); 3065 putSimpleSetElement(map, m.signature(), m); 3066 } 3067 for (SimpleSet set: iface.interfacesMethodsSignatureMap().values()) { 3068 for (Iterator i2 = set.iterator(); i2.hasNext(); ) { 3069 MethodDecl m = (MethodDecl) i2.next(); 3070 putSimpleSetElement(map, m.signature(), m); 3071 } 3072 } 3073 } 3074 return map; 3075 } 3076 /** 3077 * @attribute syn 3078 * @aspect MemberMethods 3079 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:457 3080 */ 3081 @ASTNodeAnnotation.Attribute 3082 public SimpleSet methodsSignature(String signature) { 3083 { 3084 SimpleSet set = (SimpleSet) methodsSignatureMap().get(signature); 3085 if (set != null) { 3086 return set; 3087 } 3088 return SimpleSet.emptySet; 3089 } 3090 } 3091 /** 3092 * @apilevel internal 3093 */ 3094 protected boolean methodsSignatureMap_computed = false; 3095 /** 3096 * @apilevel internal 3097 */ 3098 protected Map<String,SimpleSet> methodsSignatureMap_value; 3099 /** 3100 * @apilevel internal 3101 */ 3102 private void methodsSignatureMap_reset() { 3103 methodsSignatureMap_computed = false; 3104 methodsSignatureMap_value = null; 3105 } 3106 /** 3107 * @attribute syn 3108 * @aspect MemberMethods 3109 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:466 3110 */ 3111 @ASTNodeAnnotation.Attribute 3112 public Map<String,SimpleSet> methodsSignatureMap() { 3113 ASTNode$State state = state(); 3114 if (methodsSignatureMap_computed) { 3115 return methodsSignatureMap_value; 3116 } 3117 boolean intermediate = state.INTERMEDIATE_VALUE; 3118 state.INTERMEDIATE_VALUE = false; 3119 int num = state.boundariesCrossed; 3120 boolean isFinal = this.is$Final(); 3121 methodsSignatureMap_value = localMethodsSignatureMap(); 3122 if (isFinal && num == state().boundariesCrossed) { 3123 methodsSignatureMap_computed = true; 3124 } else { 3125 } 3126 state.INTERMEDIATE_VALUE |= intermediate; 3127 3128 return methodsSignatureMap_value; 3129 } 3130 /** 3131 * @apilevel internal 3132 */ 3133 protected java.util.Map ancestorMethods_String_values; 3134 /** 3135 * @apilevel internal 3136 */ 3137 private void ancestorMethods_String_reset() { 3138 ancestorMethods_String_values = null; 3139 } 3140 /** 3141 * @attribute syn 3142 * @aspect AncestorMethods 3143 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:536 3144 */ 3145 @ASTNodeAnnotation.Attribute 3146 public SimpleSet ancestorMethods(String signature) { 3147 Object _parameters = signature; 3148 if (ancestorMethods_String_values == null) ancestorMethods_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 3149 ASTNode$State state = state(); 3150 if (ancestorMethods_String_values.containsKey(_parameters)) { 3151 return (SimpleSet) ancestorMethods_String_values.get(_parameters); 3152 } 3153 boolean intermediate = state.INTERMEDIATE_VALUE; 3154 state.INTERMEDIATE_VALUE = false; 3155 int num = state.boundariesCrossed; 3156 boolean isFinal = this.is$Final(); 3157 SimpleSet ancestorMethods_String_value = SimpleSet.emptySet; 3158 if (isFinal && num == state().boundariesCrossed) { 3159 ancestorMethods_String_values.put(_parameters, ancestorMethods_String_value); 3160 } else { 3161 } 3162 state.INTERMEDIATE_VALUE |= intermediate; 3163 3164 return ancestorMethods_String_value; 3165 } 3166 /** 3167 * @return a set containing this type, unless this is the unknown type in 3168 * which case an empty set is returned 3169 * @attribute syn 3170 * @aspect TypeScopePropagation 3171 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:300 3172 */ 3173 @ASTNodeAnnotation.Attribute 3174 public SimpleSet asSet() { 3175 SimpleSet asSet_value = this; 3176 3177 return asSet_value; 3178 } 3179 /** 3180 * @attribute syn 3181 * @aspect TypeScopePropagation 3182 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:476 3183 */ 3184 @ASTNodeAnnotation.Attribute 3185 public SimpleSet localLookupType(String name) { 3186 { 3187 SimpleSet c = memberTypes(name); 3188 if (!c.isEmpty()) { 3189 return c; 3190 } 3191 if (name().equals(name)) { 3192 return SimpleSet.emptySet.add(this); 3193 } 3194 3195 c = lookupType(name); 3196 // 8.5.2 3197 if (isClassDecl() && isStatic() && !isTopLevelType()) { 3198 SimpleSet newSet = SimpleSet.emptySet; 3199 for (Iterator iter = c.iterator(); iter.hasNext(); ) { 3200 TypeDecl d = (TypeDecl) iter.next(); 3201 //if (d.isStatic() || d.isTopLevelType() || this.instanceOf(d.enclosingType())) { 3202 newSet = newSet.add(d); 3203 //} 3204 } 3205 c = newSet; 3206 } 3207 return c; 3208 } 3209 } 3210 /** 3211 * @attribute syn 3212 * @aspect TypeScopePropagation 3213 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:598 3214 */ 3215 @ASTNodeAnnotation.Attribute 3216 public boolean hasType(String name) { 3217 boolean hasType_String_value = !memberTypes(name).isEmpty(); 3218 3219 return hasType_String_value; 3220 } 3221 /** 3222 * @apilevel internal 3223 */ 3224 protected java.util.Map localTypeDecls_String_values; 3225 /** 3226 * @apilevel internal 3227 */ 3228 private void localTypeDecls_String_reset() { 3229 localTypeDecls_String_values = null; 3230 } 3231 /** 3232 * @attribute syn 3233 * @aspect TypeScopePropagation 3234 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:609 3235 */ 3236 @ASTNodeAnnotation.Attribute 3237 public SimpleSet localTypeDecls(String name) { 3238 Object _parameters = name; 3239 if (localTypeDecls_String_values == null) localTypeDecls_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 3240 ASTNode$State state = state(); 3241 if (localTypeDecls_String_values.containsKey(_parameters)) { 3242 return (SimpleSet) localTypeDecls_String_values.get(_parameters); 3243 } 3244 boolean intermediate = state.INTERMEDIATE_VALUE; 3245 state.INTERMEDIATE_VALUE = false; 3246 int num = state.boundariesCrossed; 3247 boolean isFinal = this.is$Final(); 3248 SimpleSet localTypeDecls_String_value = localTypeDecls_compute(name); 3249 if (isFinal && num == state().boundariesCrossed) { 3250 localTypeDecls_String_values.put(_parameters, localTypeDecls_String_value); 3251 } else { 3252 } 3253 state.INTERMEDIATE_VALUE |= intermediate; 3254 3255 return localTypeDecls_String_value; 3256 } 3257 /** 3258 * @apilevel internal 3259 */ 3260 private SimpleSet localTypeDecls_compute(String name) { 3261 SimpleSet set = SimpleSet.emptySet; 3262 for (int i = 0; i < getNumBodyDecl(); i++) { 3263 if (getBodyDecl(i).declaresType(name)) { 3264 set = set.add(getBodyDecl(i).type(name)); 3265 } 3266 } 3267 return set; 3268 } 3269 /** 3270 * @apilevel internal 3271 */ 3272 protected java.util.Map memberTypes_String_values; 3273 /** 3274 * @apilevel internal 3275 */ 3276 private void memberTypes_String_reset() { 3277 memberTypes_String_values = null; 3278 } 3279 /** 3280 * @attribute syn 3281 * @aspect TypeScopePropagation 3282 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:619 3283 */ 3284 @ASTNodeAnnotation.Attribute 3285 public SimpleSet memberTypes(String name) { 3286 Object _parameters = name; 3287 if (memberTypes_String_values == null) memberTypes_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 3288 ASTNode$State state = state(); 3289 if (memberTypes_String_values.containsKey(_parameters)) { 3290 return (SimpleSet) memberTypes_String_values.get(_parameters); 3291 } 3292 boolean intermediate = state.INTERMEDIATE_VALUE; 3293 state.INTERMEDIATE_VALUE = false; 3294 int num = state.boundariesCrossed; 3295 boolean isFinal = this.is$Final(); 3296 SimpleSet memberTypes_String_value = SimpleSet.emptySet; 3297 if (isFinal && num == state().boundariesCrossed) { 3298 memberTypes_String_values.put(_parameters, memberTypes_String_value); 3299 } else { 3300 } 3301 state.INTERMEDIATE_VALUE |= intermediate; 3302 3303 return memberTypes_String_value; 3304 } 3305 /** 3306 * @apilevel internal 3307 */ 3308 protected java.util.Map localFields_String_values; 3309 /** 3310 * @apilevel internal 3311 */ 3312 private void localFields_String_reset() { 3313 localFields_String_values = null; 3314 } 3315 /** 3316 * @attribute syn 3317 * @aspect Fields 3318 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:363 3319 */ 3320 @ASTNodeAnnotation.Attribute 3321 public SimpleSet localFields(String name) { 3322 Object _parameters = name; 3323 if (localFields_String_values == null) localFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 3324 ASTNode$State state = state(); 3325 if (localFields_String_values.containsKey(_parameters)) { 3326 return (SimpleSet) localFields_String_values.get(_parameters); 3327 } 3328 boolean intermediate = state.INTERMEDIATE_VALUE; 3329 state.INTERMEDIATE_VALUE = false; 3330 int num = state.boundariesCrossed; 3331 boolean isFinal = this.is$Final(); 3332 SimpleSet localFields_String_value = localFieldsMap().containsKey(name) 3333 ? (SimpleSet) localFieldsMap().get(name) 3334 : SimpleSet.emptySet; 3335 if (isFinal && num == state().boundariesCrossed) { 3336 localFields_String_values.put(_parameters, localFields_String_value); 3337 } else { 3338 } 3339 state.INTERMEDIATE_VALUE |= intermediate; 3340 3341 return localFields_String_value; 3342 } 3343 /** 3344 * @apilevel internal 3345 */ 3346 protected boolean localFieldsMap_computed = false; 3347 /** 3348 * @apilevel internal 3349 */ 3350 protected HashMap localFieldsMap_value; 3351 /** 3352 * @apilevel internal 3353 */ 3354 private void localFieldsMap_reset() { 3355 localFieldsMap_computed = false; 3356 localFieldsMap_value = null; 3357 } 3358 /** 3359 * @attribute syn 3360 * @aspect Fields 3361 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:368 3362 */ 3363 @ASTNodeAnnotation.Attribute 3364 public HashMap localFieldsMap() { 3365 ASTNode$State state = state(); 3366 if (localFieldsMap_computed) { 3367 return localFieldsMap_value; 3368 } 3369 boolean intermediate = state.INTERMEDIATE_VALUE; 3370 state.INTERMEDIATE_VALUE = false; 3371 int num = state.boundariesCrossed; 3372 boolean isFinal = this.is$Final(); 3373 localFieldsMap_value = localFieldsMap_compute(); 3374 if (isFinal && num == state().boundariesCrossed) { 3375 localFieldsMap_computed = true; 3376 } else { 3377 } 3378 state.INTERMEDIATE_VALUE |= intermediate; 3379 3380 return localFieldsMap_value; 3381 } 3382 /** 3383 * @apilevel internal 3384 */ 3385 private HashMap localFieldsMap_compute() { 3386 HashMap map = new HashMap(); 3387 for (int i = 0; i < getNumBodyDecl(); i++) { 3388 if (getBodyDecl(i) instanceof FieldDeclaration) { 3389 FieldDeclaration decl = (FieldDeclaration) getBodyDecl(i); 3390 SimpleSet fields = (SimpleSet) map.get(decl.name()); 3391 if (fields == null) { 3392 fields = SimpleSet.emptySet; 3393 } 3394 fields = fields.add(decl); 3395 map.put(decl.name(), fields); 3396 } 3397 } 3398 return map; 3399 } 3400 /** 3401 * @apilevel internal 3402 */ 3403 protected boolean memberFieldsMap_computed = false; 3404 /** 3405 * @apilevel internal 3406 */ 3407 protected HashMap memberFieldsMap_value; 3408 /** 3409 * @apilevel internal 3410 */ 3411 private void memberFieldsMap_reset() { 3412 memberFieldsMap_computed = false; 3413 memberFieldsMap_value = null; 3414 } 3415 /** 3416 * @attribute syn 3417 * @aspect Fields 3418 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:383 3419 */ 3420 @ASTNodeAnnotation.Attribute 3421 public HashMap memberFieldsMap() { 3422 ASTNode$State state = state(); 3423 if (memberFieldsMap_computed) { 3424 return memberFieldsMap_value; 3425 } 3426 boolean intermediate = state.INTERMEDIATE_VALUE; 3427 state.INTERMEDIATE_VALUE = false; 3428 int num = state.boundariesCrossed; 3429 boolean isFinal = this.is$Final(); 3430 memberFieldsMap_value = localFieldsMap(); 3431 if (isFinal && num == state().boundariesCrossed) { 3432 memberFieldsMap_computed = true; 3433 } else { 3434 } 3435 state.INTERMEDIATE_VALUE |= intermediate; 3436 3437 return memberFieldsMap_value; 3438 } 3439 /** 3440 * @apilevel internal 3441 */ 3442 protected java.util.Map memberFields_String_values; 3443 /** 3444 * @apilevel internal 3445 */ 3446 private void memberFields_String_reset() { 3447 memberFields_String_values = null; 3448 } 3449 /** 3450 * @attribute syn 3451 * @aspect Fields 3452 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:435 3453 */ 3454 @ASTNodeAnnotation.Attribute 3455 public SimpleSet memberFields(String name) { 3456 Object _parameters = name; 3457 if (memberFields_String_values == null) memberFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 3458 ASTNode$State state = state(); 3459 if (memberFields_String_values.containsKey(_parameters)) { 3460 return (SimpleSet) memberFields_String_values.get(_parameters); 3461 } 3462 boolean intermediate = state.INTERMEDIATE_VALUE; 3463 state.INTERMEDIATE_VALUE = false; 3464 int num = state.boundariesCrossed; 3465 boolean isFinal = this.is$Final(); 3466 SimpleSet memberFields_String_value = localFields(name); 3467 if (isFinal && num == state().boundariesCrossed) { 3468 memberFields_String_values.put(_parameters, memberFields_String_value); 3469 } else { 3470 } 3471 state.INTERMEDIATE_VALUE |= intermediate; 3472 3473 return memberFields_String_value; 3474 } 3475 /** 3476 * @apilevel internal 3477 */ 3478 protected boolean hasAbstract_computed = false; 3479 /** 3480 * @apilevel internal 3481 */ 3482 protected boolean hasAbstract_value; 3483 /** 3484 * @apilevel internal 3485 */ 3486 private void hasAbstract_reset() { 3487 hasAbstract_computed = false; 3488 } 3489 /** 3490 * @attribute syn 3491 * @aspect Modifiers 3492 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:35 3493 */ 3494 @ASTNodeAnnotation.Attribute 3495 public boolean hasAbstract() { 3496 ASTNode$State state = state(); 3497 if (hasAbstract_computed) { 3498 return hasAbstract_value; 3499 } 3500 boolean intermediate = state.INTERMEDIATE_VALUE; 3501 state.INTERMEDIATE_VALUE = false; 3502 int num = state.boundariesCrossed; 3503 boolean isFinal = this.is$Final(); 3504 hasAbstract_value = false; 3505 if (isFinal && num == state().boundariesCrossed) { 3506 hasAbstract_computed = true; 3507 } else { 3508 } 3509 state.INTERMEDIATE_VALUE |= intermediate; 3510 3511 return hasAbstract_value; 3512 } 3513 /** 3514 * @apilevel internal 3515 */ 3516 protected boolean unimplementedMethods_computed = false; 3517 /** 3518 * @apilevel internal 3519 */ 3520 protected Collection unimplementedMethods_value; 3521 /** 3522 * @apilevel internal 3523 */ 3524 private void unimplementedMethods_reset() { 3525 unimplementedMethods_computed = false; 3526 unimplementedMethods_value = null; 3527 } 3528 /** 3529 * @attribute syn 3530 * @aspect Modifiers 3531 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:37 3532 */ 3533 @ASTNodeAnnotation.Attribute 3534 public Collection unimplementedMethods() { 3535 ASTNode$State state = state(); 3536 if (unimplementedMethods_computed) { 3537 return unimplementedMethods_value; 3538 } 3539 boolean intermediate = state.INTERMEDIATE_VALUE; 3540 state.INTERMEDIATE_VALUE = false; 3541 int num = state.boundariesCrossed; 3542 boolean isFinal = this.is$Final(); 3543 unimplementedMethods_value = Collections.EMPTY_LIST; 3544 if (isFinal && num == state().boundariesCrossed) { 3545 unimplementedMethods_computed = true; 3546 } else { 3547 } 3548 state.INTERMEDIATE_VALUE |= intermediate; 3549 3550 return unimplementedMethods_value; 3551 } 3552 /** 3553 * @apilevel internal 3554 */ 3555 protected boolean isPublic_computed = false; 3556 /** 3557 * @apilevel internal 3558 */ 3559 protected boolean isPublic_value; 3560 /** 3561 * @apilevel internal 3562 */ 3563 private void isPublic_reset() { 3564 isPublic_computed = false; 3565 } 3566 /** 3567 * @attribute syn 3568 * @aspect Modifiers 3569 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:241 3570 */ 3571 @ASTNodeAnnotation.Attribute 3572 public boolean isPublic() { 3573 ASTNode$State state = state(); 3574 if (isPublic_computed) { 3575 return isPublic_value; 3576 } 3577 boolean intermediate = state.INTERMEDIATE_VALUE; 3578 state.INTERMEDIATE_VALUE = false; 3579 int num = state.boundariesCrossed; 3580 boolean isFinal = this.is$Final(); 3581 isPublic_value = getModifiers().isPublic() || isMemberType() && enclosingType().isInterfaceDecl(); 3582 if (isFinal && num == state().boundariesCrossed) { 3583 isPublic_computed = true; 3584 } else { 3585 } 3586 state.INTERMEDIATE_VALUE |= intermediate; 3587 3588 return isPublic_value; 3589 } 3590 /** 3591 * @attribute syn 3592 * @aspect Modifiers 3593 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:243 3594 */ 3595 @ASTNodeAnnotation.Attribute 3596 public boolean isPrivate() { 3597 boolean isPrivate_value = getModifiers().isPrivate(); 3598 3599 return isPrivate_value; 3600 } 3601 /** 3602 * @attribute syn 3603 * @aspect Modifiers 3604 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:244 3605 */ 3606 @ASTNodeAnnotation.Attribute 3607 public boolean isProtected() { 3608 boolean isProtected_value = getModifiers().isProtected(); 3609 3610 return isProtected_value; 3611 } 3612 /** 3613 * @attribute syn 3614 * @aspect Modifiers 3615 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:245 3616 */ 3617 @ASTNodeAnnotation.Attribute 3618 public boolean isAbstract() { 3619 boolean isAbstract_value = getModifiers().isAbstract(); 3620 3621 return isAbstract_value; 3622 } 3623 /** 3624 * @apilevel internal 3625 */ 3626 protected boolean isStatic_computed = false; 3627 /** 3628 * @apilevel internal 3629 */ 3630 protected boolean isStatic_value; 3631 /** 3632 * @apilevel internal 3633 */ 3634 private void isStatic_reset() { 3635 isStatic_computed = false; 3636 } 3637 /** 3638 * @attribute syn 3639 * @aspect Modifiers 3640 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:247 3641 */ 3642 @ASTNodeAnnotation.Attribute 3643 public boolean isStatic() { 3644 ASTNode$State state = state(); 3645 if (isStatic_computed) { 3646 return isStatic_value; 3647 } 3648 boolean intermediate = state.INTERMEDIATE_VALUE; 3649 state.INTERMEDIATE_VALUE = false; 3650 int num = state.boundariesCrossed; 3651 boolean isFinal = this.is$Final(); 3652 isStatic_value = getModifiers().isStatic() || isMemberType() && enclosingType().isInterfaceDecl(); 3653 if (isFinal && num == state().boundariesCrossed) { 3654 isStatic_computed = true; 3655 } else { 3656 } 3657 state.INTERMEDIATE_VALUE |= intermediate; 3658 3659 return isStatic_value; 3660 } 3661 /** 3662 * @attribute syn 3663 * @aspect Modifiers 3664 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:250 3665 */ 3666 @ASTNodeAnnotation.Attribute 3667 public boolean isFinal() { 3668 boolean isFinal_value = getModifiers().isFinal(); 3669 3670 return isFinal_value; 3671 } 3672 /** 3673 * @attribute syn 3674 * @aspect Modifiers 3675 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:251 3676 */ 3677 @ASTNodeAnnotation.Attribute 3678 public boolean isStrictfp() { 3679 boolean isStrictfp_value = getModifiers().isStrictfp(); 3680 3681 return isStrictfp_value; 3682 } 3683 /** 3684 * @attribute syn 3685 * @aspect Modifiers 3686 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:253 3687 */ 3688 @ASTNodeAnnotation.Attribute 3689 public boolean isSynthetic() { 3690 boolean isSynthetic_value = getModifiers().isSynthetic(); 3691 3692 return isSynthetic_value; 3693 } 3694 /** 3695 * @attribute syn 3696 * @aspect NameCheck 3697 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:344 3698 */ 3699 @ASTNodeAnnotation.Attribute 3700 public boolean hasEnclosingTypeDecl(String name) { 3701 { 3702 TypeDecl enclosingType = enclosingType(); 3703 if (enclosingType != null) { 3704 return enclosingType.name().equals(name) || enclosingType.hasEnclosingTypeDecl(name); 3705 } 3706 return false; 3707 } 3708 } 3709 /** 3710 * @attribute syn 3711 * @aspect NameCheck 3712 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:508 3713 */ 3714 @ASTNodeAnnotation.Attribute 3715 public boolean assignableToInt() { 3716 boolean assignableToInt_value = false; 3717 3718 return assignableToInt_value; 3719 } 3720 /** 3721 * @attribute syn 3722 * @aspect TypeName 3723 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:78 3724 */ 3725 @ASTNodeAnnotation.Attribute 3726 public String name() { 3727 String name_value = getID(); 3728 3729 return name_value; 3730 } 3731 /** 3732 * @apilevel internal 3733 */ 3734 protected boolean fullName_computed = false; 3735 /** 3736 * @apilevel internal 3737 */ 3738 protected String fullName_value; 3739 /** 3740 * @apilevel internal 3741 */ 3742 private void fullName_reset() { 3743 fullName_computed = false; 3744 fullName_value = null; 3745 } 3746 /** 3747 * @attribute syn 3748 * @aspect TypeName 3749 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:80 3750 */ 3751 @ASTNodeAnnotation.Attribute 3752 public String fullName() { 3753 ASTNode$State state = state(); 3754 if (fullName_computed) { 3755 return fullName_value; 3756 } 3757 boolean intermediate = state.INTERMEDIATE_VALUE; 3758 state.INTERMEDIATE_VALUE = false; 3759 int num = state.boundariesCrossed; 3760 boolean isFinal = this.is$Final(); 3761 fullName_value = fullName_compute(); 3762 if (isFinal && num == state().boundariesCrossed) { 3763 fullName_computed = true; 3764 } else { 3765 } 3766 state.INTERMEDIATE_VALUE |= intermediate; 3767 3768 return fullName_value; 3769 } 3770 /** 3771 * @apilevel internal 3772 */ 3773 private String fullName_compute() { 3774 if (isNestedType()) { 3775 return enclosingType().fullName() + "." + name(); 3776 } 3777 String packageName = packageName(); 3778 if (packageName.equals("")) { 3779 return name(); 3780 } 3781 return packageName + "." + name(); 3782 } 3783 /** 3784 * @apilevel internal 3785 */ 3786 protected boolean typeName_computed = false; 3787 /** 3788 * @apilevel internal 3789 */ 3790 protected String typeName_value; 3791 /** 3792 * @apilevel internal 3793 */ 3794 private void typeName_reset() { 3795 typeName_computed = false; 3796 typeName_value = null; 3797 } 3798 /** 3799 * @attribute syn 3800 * @aspect TypeName 3801 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:91 3802 */ 3803 @ASTNodeAnnotation.Attribute 3804 public String typeName() { 3805 ASTNode$State state = state(); 3806 if (typeName_computed) { 3807 return typeName_value; 3808 } 3809 boolean intermediate = state.INTERMEDIATE_VALUE; 3810 state.INTERMEDIATE_VALUE = false; 3811 int num = state.boundariesCrossed; 3812 boolean isFinal = this.is$Final(); 3813 typeName_value = typeName_compute(); 3814 if (isFinal && num == state().boundariesCrossed) { 3815 typeName_computed = true; 3816 } else { 3817 } 3818 state.INTERMEDIATE_VALUE |= intermediate; 3819 3820 return typeName_value; 3821 } 3822 /** 3823 * @apilevel internal 3824 */ 3825 private String typeName_compute() { 3826 if (isNestedType()) { 3827 return enclosingType().typeName() + "." + name(); 3828 } 3829 String packageName = packageName(); 3830 if (packageName.equals("") || packageName.equals(PRIMITIVE_PACKAGE_NAME)) { 3831 return name(); 3832 } 3833 return packageName + "." + name(); 3834 } 3835 /** 3836 * @attribute syn 3837 * @aspect TypeConversion 3838 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:36 3839 */ 3840 @ASTNodeAnnotation.Attribute 3841 public boolean identityConversionTo(TypeDecl type) { 3842 boolean identityConversionTo_TypeDecl_value = this == type; 3843 3844 return identityConversionTo_TypeDecl_value; 3845 } 3846 /** 3847 * @attribute syn 3848 * @aspect TypeConversion 3849 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:38 3850 */ 3851 @ASTNodeAnnotation.Attribute 3852 public boolean wideningConversionTo(TypeDecl type) { 3853 boolean wideningConversionTo_TypeDecl_value = instanceOf(type); 3854 3855 return wideningConversionTo_TypeDecl_value; 3856 } 3857 /** 3858 * @apilevel internal 3859 */ 3860 protected java.util.Map narrowingConversionTo_TypeDecl_values; 3861 /** 3862 * @apilevel internal 3863 */ 3864 private void narrowingConversionTo_TypeDecl_reset() { 3865 narrowingConversionTo_TypeDecl_values = null; 3866 } 3867 /** 3868 * @attribute syn 3869 * @aspect TypeConversion 3870 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:39 3871 */ 3872 @ASTNodeAnnotation.Attribute 3873 public boolean narrowingConversionTo(TypeDecl type) { 3874 Object _parameters = type; 3875 if (narrowingConversionTo_TypeDecl_values == null) narrowingConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 3876 ASTNode$State state = state(); 3877 if (narrowingConversionTo_TypeDecl_values.containsKey(_parameters)) { 3878 return (Boolean) narrowingConversionTo_TypeDecl_values.get(_parameters); 3879 } 3880 boolean intermediate = state.INTERMEDIATE_VALUE; 3881 state.INTERMEDIATE_VALUE = false; 3882 int num = state.boundariesCrossed; 3883 boolean isFinal = this.is$Final(); 3884 boolean narrowingConversionTo_TypeDecl_value = instanceOf(type); 3885 if (isFinal && num == state().boundariesCrossed) { 3886 narrowingConversionTo_TypeDecl_values.put(_parameters, narrowingConversionTo_TypeDecl_value); 3887 } else { 3888 } 3889 state.INTERMEDIATE_VALUE |= intermediate; 3890 3891 return narrowingConversionTo_TypeDecl_value; 3892 } 3893 /** 3894 * @attribute syn 3895 * @aspect TypeConversion 3896 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:82 3897 */ 3898 @ASTNodeAnnotation.Attribute 3899 public boolean stringConversion() { 3900 boolean stringConversion_value = true; 3901 3902 return stringConversion_value; 3903 } 3904 /** 3905 * @attribute syn 3906 * @aspect TypeConversion 3907 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:86 3908 */ 3909 @ASTNodeAnnotation.Attribute 3910 public boolean assignConversionTo(TypeDecl type, Expr expr) { 3911 { 3912 if (refined_TypeConversion_TypeDecl_assignConversionTo_TypeDecl_Expr(type, expr)) { 3913 return true; 3914 } 3915 boolean canBoxThis = this instanceof PrimitiveType; 3916 boolean canBoxType = type instanceof PrimitiveType; 3917 boolean canUnboxThis = !unboxed().isUnknown(); 3918 boolean canUnboxType = !type.unboxed().isUnknown(); 3919 TypeDecl t = !canUnboxThis && canUnboxType ? type.unboxed() : type; 3920 boolean sourceIsConstant = expr != null ? expr.isConstant() : false; 3921 if (sourceIsConstant && (isInt() || isChar() || isShort() || isByte()) && 3922 (t.isByte() || t.isShort() || t.isChar()) && 3923 narrowingConversionTo(t) && expr.representableIn(t)) 3924 return true; 3925 if (canBoxThis && !canBoxType && boxed().wideningConversionTo(type)) { 3926 return true; 3927 } else if (canUnboxThis && !canUnboxType && unboxed().wideningConversionTo(type)) { 3928 return true; 3929 } 3930 3931 return false; 3932 } 3933 } 3934 /** 3935 * @apilevel internal 3936 */ 3937 protected java.util.Map methodInvocationConversionTo_TypeDecl_values; 3938 /** 3939 * @apilevel internal 3940 */ 3941 private void methodInvocationConversionTo_TypeDecl_reset() { 3942 methodInvocationConversionTo_TypeDecl_values = null; 3943 } 3944 /** 3945 * @attribute syn 3946 * @aspect TypeConversion 3947 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:104 3948 */ 3949 @ASTNodeAnnotation.Attribute 3950 public boolean methodInvocationConversionTo(TypeDecl type) { 3951 Object _parameters = type; 3952 if (methodInvocationConversionTo_TypeDecl_values == null) methodInvocationConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 3953 ASTNode$State state = state(); 3954 if (methodInvocationConversionTo_TypeDecl_values.containsKey(_parameters)) { 3955 return (Boolean) methodInvocationConversionTo_TypeDecl_values.get(_parameters); 3956 } 3957 boolean intermediate = state.INTERMEDIATE_VALUE; 3958 state.INTERMEDIATE_VALUE = false; 3959 int num = state.boundariesCrossed; 3960 boolean isFinal = this.is$Final(); 3961 boolean methodInvocationConversionTo_TypeDecl_value = methodInvocationConversionTo_compute(type); 3962 if (isFinal && num == state().boundariesCrossed) { 3963 methodInvocationConversionTo_TypeDecl_values.put(_parameters, methodInvocationConversionTo_TypeDecl_value); 3964 } else { 3965 } 3966 state.INTERMEDIATE_VALUE |= intermediate; 3967 3968 return methodInvocationConversionTo_TypeDecl_value; 3969 } 3970 /** 3971 * @apilevel internal 3972 */ 3973 private boolean methodInvocationConversionTo_compute(TypeDecl type) { 3974 if (refined_TypeConversion_TypeDecl_methodInvocationConversionTo_TypeDecl(type)) { 3975 return true; 3976 } 3977 boolean canBoxThis = this instanceof PrimitiveType; 3978 boolean canBoxType = type instanceof PrimitiveType; 3979 boolean canUnboxThis = !unboxed().isUnknown(); 3980 boolean canUnboxType = !type.unboxed().isUnknown(); 3981 if (canBoxThis && !canBoxType) { 3982 return boxed().wideningConversionTo(type); 3983 } else if (canUnboxThis && !canUnboxType) { 3984 return unboxed().wideningConversionTo(type); 3985 } 3986 return false; 3987 } 3988 /** 3989 * @apilevel internal 3990 */ 3991 protected java.util.Map castingConversionTo_TypeDecl_values; 3992 /** 3993 * @apilevel internal 3994 */ 3995 private void castingConversionTo_TypeDecl_reset() { 3996 castingConversionTo_TypeDecl_values = null; 3997 } 3998 /** 3999 * @attribute syn 4000 * @aspect TypeConversion 4001 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:109 4002 */ 4003 @ASTNodeAnnotation.Attribute 4004 public boolean castingConversionTo(TypeDecl type) { 4005 Object _parameters = type; 4006 if (castingConversionTo_TypeDecl_values == null) castingConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 4007 ASTNode$State state = state(); 4008 if (castingConversionTo_TypeDecl_values.containsKey(_parameters)) { 4009 return (Boolean) castingConversionTo_TypeDecl_values.get(_parameters); 4010 } 4011 boolean intermediate = state.INTERMEDIATE_VALUE; 4012 state.INTERMEDIATE_VALUE = false; 4013 int num = state.boundariesCrossed; 4014 boolean isFinal = this.is$Final(); 4015 boolean castingConversionTo_TypeDecl_value = castingConversionTo_compute(type); 4016 if (isFinal && num == state().boundariesCrossed) { 4017 castingConversionTo_TypeDecl_values.put(_parameters, castingConversionTo_TypeDecl_value); 4018 } else { 4019 } 4020 state.INTERMEDIATE_VALUE |= intermediate; 4021 4022 return castingConversionTo_TypeDecl_value; 4023 } 4024 /** 4025 * @apilevel internal 4026 */ 4027 private boolean castingConversionTo_compute(TypeDecl type) { 4028 if (refined_TypeConversion_TypeDecl_castingConversionTo_TypeDecl(type)) { 4029 return true; 4030 } 4031 boolean canBoxThis = this instanceof PrimitiveType; 4032 boolean canBoxType = type instanceof PrimitiveType; 4033 boolean canUnboxThis = !unboxed().isUnknown(); 4034 boolean canUnboxType = !type.unboxed().isUnknown(); 4035 if (canBoxThis && !canBoxType) { 4036 return boxed().wideningConversionTo(type); 4037 } else if (canUnboxThis && !canUnboxType) { 4038 return unboxed().wideningConversionTo(type); 4039 } 4040 return false; 4041 /* 4042 else if (boxingConversionTo(type)) { 4043 return true; 4044 } else if (unboxingConversionTo(type)) { 4045 return true; 4046 } 4047 return false; 4048 */ 4049 } 4050 /** 4051 * @attribute syn 4052 * @aspect NumericPromotion 4053 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:167 4054 */ 4055 @ASTNodeAnnotation.Attribute 4056 public TypeDecl unaryNumericPromotion() { 4057 TypeDecl unaryNumericPromotion_value = this; 4058 4059 return unaryNumericPromotion_value; 4060 } 4061 /** 4062 * @attribute syn 4063 * @aspect NumericPromotion 4064 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:175 4065 */ 4066 @ASTNodeAnnotation.Attribute 4067 public TypeDecl binaryNumericPromotion(TypeDecl type) { 4068 TypeDecl binaryNumericPromotion_TypeDecl_value = unknownType(); 4069 4070 return binaryNumericPromotion_TypeDecl_value; 4071 } 4072 /** 4073 * @attribute syn 4074 * @aspect TypeAnalysis 4075 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:187 4076 */ 4077 @ASTNodeAnnotation.Attribute 4078 public boolean isReferenceType() { 4079 boolean isReferenceType_value = false; 4080 4081 return isReferenceType_value; 4082 } 4083 /** 4084 * @attribute syn 4085 * @aspect TypeAnalysis 4086 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:190 4087 */ 4088 @ASTNodeAnnotation.Attribute 4089 public boolean isPrimitiveType() { 4090 boolean isPrimitiveType_value = false; 4091 4092 return isPrimitiveType_value; 4093 } 4094 /** 4095 * @attribute syn 4096 * @aspect TypeAnalysis 4097 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:195 4098 */ 4099 @ASTNodeAnnotation.Attribute 4100 public boolean isNumericType() { 4101 boolean isNumericType_value = false; 4102 4103 return isNumericType_value; 4104 } 4105 /** 4106 * @attribute syn 4107 * @aspect TypeAnalysis 4108 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:199 4109 */ 4110 @ASTNodeAnnotation.Attribute 4111 public boolean isIntegralType() { 4112 boolean isIntegralType_value = false; 4113 4114 return isIntegralType_value; 4115 } 4116 /** 4117 * @attribute syn 4118 * @aspect TypeAnalysis 4119 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:203 4120 */ 4121 @ASTNodeAnnotation.Attribute 4122 public boolean isBoolean() { 4123 boolean isBoolean_value = false; 4124 4125 return isBoolean_value; 4126 } 4127 /** 4128 * @attribute syn 4129 * @aspect TypeAnalysis 4130 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:207 4131 */ 4132 @ASTNodeAnnotation.Attribute 4133 public boolean isByte() { 4134 boolean isByte_value = false; 4135 4136 return isByte_value; 4137 } 4138 /** 4139 * @attribute syn 4140 * @aspect TypeAnalysis 4141 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:209 4142 */ 4143 @ASTNodeAnnotation.Attribute 4144 public boolean isChar() { 4145 boolean isChar_value = false; 4146 4147 return isChar_value; 4148 } 4149 /** 4150 * @attribute syn 4151 * @aspect TypeAnalysis 4152 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:211 4153 */ 4154 @ASTNodeAnnotation.Attribute 4155 public boolean isShort() { 4156 boolean isShort_value = false; 4157 4158 return isShort_value; 4159 } 4160 /** 4161 * @attribute syn 4162 * @aspect TypeAnalysis 4163 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:213 4164 */ 4165 @ASTNodeAnnotation.Attribute 4166 public boolean isInt() { 4167 boolean isInt_value = false; 4168 4169 return isInt_value; 4170 } 4171 /** 4172 * @attribute syn 4173 * @aspect TypeAnalysis 4174 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:217 4175 */ 4176 @ASTNodeAnnotation.Attribute 4177 public boolean isFloat() { 4178 boolean isFloat_value = false; 4179 4180 return isFloat_value; 4181 } 4182 /** 4183 * @attribute syn 4184 * @aspect TypeAnalysis 4185 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:219 4186 */ 4187 @ASTNodeAnnotation.Attribute 4188 public boolean isLong() { 4189 boolean isLong_value = false; 4190 4191 return isLong_value; 4192 } 4193 /** 4194 * @attribute syn 4195 * @aspect TypeAnalysis 4196 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:221 4197 */ 4198 @ASTNodeAnnotation.Attribute 4199 public boolean isDouble() { 4200 boolean isDouble_value = false; 4201 4202 return isDouble_value; 4203 } 4204 /** 4205 * @attribute syn 4206 * @aspect TypeAnalysis 4207 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:224 4208 */ 4209 @ASTNodeAnnotation.Attribute 4210 public boolean isVoid() { 4211 boolean isVoid_value = false; 4212 4213 return isVoid_value; 4214 } 4215 /** 4216 * @attribute syn 4217 * @aspect TypeAnalysis 4218 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:227 4219 */ 4220 @ASTNodeAnnotation.Attribute 4221 public boolean isNull() { 4222 boolean isNull_value = false; 4223 4224 return isNull_value; 4225 } 4226 /** 4227 * @attribute syn 4228 * @aspect TypeAnalysis 4229 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:231 4230 */ 4231 @ASTNodeAnnotation.Attribute 4232 public boolean isClassDecl() { 4233 boolean isClassDecl_value = false; 4234 4235 return isClassDecl_value; 4236 } 4237 /** 4238 * @attribute syn 4239 * @aspect TypeAnalysis 4240 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:235 4241 */ 4242 @ASTNodeAnnotation.Attribute 4243 public boolean isInterfaceDecl() { 4244 boolean isInterfaceDecl_value = false; 4245 4246 return isInterfaceDecl_value; 4247 } 4248 /** 4249 * @attribute syn 4250 * @aspect TypeAnalysis 4251 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:237 4252 */ 4253 @ASTNodeAnnotation.Attribute 4254 public boolean isArrayDecl() { 4255 boolean isArrayDecl_value = false; 4256 4257 return isArrayDecl_value; 4258 } 4259 /** 4260 * @attribute syn 4261 * @aspect TypeAnalysis 4262 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:245 4263 */ 4264 @ASTNodeAnnotation.Attribute 4265 public boolean isPrimitive() { 4266 boolean isPrimitive_value = false; 4267 4268 return isPrimitive_value; 4269 } 4270 /** 4271 * @apilevel internal 4272 */ 4273 protected boolean isString_computed = false; 4274 /** 4275 * @apilevel internal 4276 */ 4277 protected boolean isString_value; 4278 /** 4279 * @apilevel internal 4280 */ 4281 private void isString_reset() { 4282 isString_computed = false; 4283 } 4284 /** 4285 * @attribute syn 4286 * @aspect TypeAnalysis 4287 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:248 4288 */ 4289 @ASTNodeAnnotation.Attribute 4290 public boolean isString() { 4291 ASTNode$State state = state(); 4292 if (isString_computed) { 4293 return isString_value; 4294 } 4295 boolean intermediate = state.INTERMEDIATE_VALUE; 4296 state.INTERMEDIATE_VALUE = false; 4297 int num = state.boundariesCrossed; 4298 boolean isFinal = this.is$Final(); 4299 isString_value = false; 4300 if (isFinal && num == state().boundariesCrossed) { 4301 isString_computed = true; 4302 } else { 4303 } 4304 state.INTERMEDIATE_VALUE |= intermediate; 4305 4306 return isString_value; 4307 } 4308 /** 4309 * @apilevel internal 4310 */ 4311 protected boolean isObject_computed = false; 4312 /** 4313 * @apilevel internal 4314 */ 4315 protected boolean isObject_value; 4316 /** 4317 * @apilevel internal 4318 */ 4319 private void isObject_reset() { 4320 isObject_computed = false; 4321 } 4322 /** 4323 * @attribute syn 4324 * @aspect TypeAnalysis 4325 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:251 4326 */ 4327 @ASTNodeAnnotation.Attribute 4328 public boolean isObject() { 4329 ASTNode$State state = state(); 4330 if (isObject_computed) { 4331 return isObject_value; 4332 } 4333 boolean intermediate = state.INTERMEDIATE_VALUE; 4334 state.INTERMEDIATE_VALUE = false; 4335 int num = state.boundariesCrossed; 4336 boolean isFinal = this.is$Final(); 4337 isObject_value = false; 4338 if (isFinal && num == state().boundariesCrossed) { 4339 isObject_computed = true; 4340 } else { 4341 } 4342 state.INTERMEDIATE_VALUE |= intermediate; 4343 4344 return isObject_value; 4345 } 4346 /** 4347 * @attribute syn 4348 * @aspect TypeAnalysis 4349 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:254 4350 */ 4351 @ASTNodeAnnotation.Attribute 4352 public boolean isUnknown() { 4353 boolean isUnknown_value = false; 4354 4355 return isUnknown_value; 4356 } 4357 /** 4358 * @apilevel internal 4359 */ 4360 protected java.util.Map instanceOf_TypeDecl_values; 4361 /** 4362 * @apilevel internal 4363 */ 4364 private void instanceOf_TypeDecl_reset() { 4365 instanceOf_TypeDecl_values = null; 4366 } 4367 /** 4368 * @attribute syn 4369 * @aspect TypeWideningAndIdentity 4370 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442 4371 */ 4372 @ASTNodeAnnotation.Attribute 4373 public boolean instanceOf(TypeDecl type) { 4374 Object _parameters = type; 4375 if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 4376 ASTNode$State state = state(); 4377 if (instanceOf_TypeDecl_values.containsKey(_parameters)) { 4378 return (Boolean) instanceOf_TypeDecl_values.get(_parameters); 4379 } 4380 boolean intermediate = state.INTERMEDIATE_VALUE; 4381 state.INTERMEDIATE_VALUE = false; 4382 int num = state.boundariesCrossed; 4383 boolean isFinal = this.is$Final(); 4384 boolean instanceOf_TypeDecl_value = instanceOf_compute(type); 4385 if (isFinal && num == state().boundariesCrossed) { 4386 instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value); 4387 } else { 4388 } 4389 state.INTERMEDIATE_VALUE |= intermediate; 4390 4391 return instanceOf_TypeDecl_value; 4392 } 4393 /** 4394 * @apilevel internal 4395 */ 4396 private boolean instanceOf_compute(TypeDecl type) { return subtype(type); } 4397 /** 4398 * @attribute syn 4399 * @aspect TypeWideningAndIdentity 4400 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:458 4401 */ 4402 @ASTNodeAnnotation.Attribute 4403 public boolean isSupertypeOfClassDecl(ClassDecl type) { 4404 boolean isSupertypeOfClassDecl_ClassDecl_value = type == this; 4405 4406 return isSupertypeOfClassDecl_ClassDecl_value; 4407 } 4408 /** 4409 * @attribute syn 4410 * @aspect TypeWideningAndIdentity 4411 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:478 4412 */ 4413 @ASTNodeAnnotation.Attribute 4414 public boolean isSupertypeOfInterfaceDecl(InterfaceDecl type) { 4415 boolean isSupertypeOfInterfaceDecl_InterfaceDecl_value = type == this; 4416 4417 return isSupertypeOfInterfaceDecl_InterfaceDecl_value; 4418 } 4419 /** 4420 * @attribute syn 4421 * @aspect TypeWideningAndIdentity 4422 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:493 4423 */ 4424 @ASTNodeAnnotation.Attribute 4425 public boolean isSupertypeOfArrayDecl(ArrayDecl type) { 4426 boolean isSupertypeOfArrayDecl_ArrayDecl_value = this == type; 4427 4428 return isSupertypeOfArrayDecl_ArrayDecl_value; 4429 } 4430 /** 4431 * @attribute syn 4432 * @aspect TypeWideningAndIdentity 4433 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:519 4434 */ 4435 @ASTNodeAnnotation.Attribute 4436 public boolean isSupertypeOfPrimitiveType(PrimitiveType type) { 4437 boolean isSupertypeOfPrimitiveType_PrimitiveType_value = type == this; 4438 4439 return isSupertypeOfPrimitiveType_PrimitiveType_value; 4440 } 4441 /** 4442 * @attribute syn 4443 * @aspect TypeWideningAndIdentity 4444 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:527 4445 */ 4446 @ASTNodeAnnotation.Attribute 4447 public boolean isSupertypeOfNullType(NullType type) { 4448 boolean isSupertypeOfNullType_NullType_value = false; 4449 4450 return isSupertypeOfNullType_NullType_value; 4451 } 4452 /** 4453 * @attribute syn 4454 * @aspect TypeWideningAndIdentity 4455 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:531 4456 */ 4457 @ASTNodeAnnotation.Attribute 4458 public boolean isSupertypeOfVoidType(VoidType type) { 4459 boolean isSupertypeOfVoidType_VoidType_value = false; 4460 4461 return isSupertypeOfVoidType_VoidType_value; 4462 } 4463 /** 4464 * @attribute syn 4465 * @aspect NestedTypes 4466 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:545 4467 */ 4468 @ASTNodeAnnotation.Attribute 4469 public TypeDecl topLevelType() { 4470 { 4471 if (isTopLevelType()) { 4472 return this; 4473 } 4474 return enclosingType().topLevelType(); 4475 } 4476 } 4477 /** 4478 * @attribute syn 4479 * @aspect NestedTypes 4480 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:574 4481 */ 4482 @ASTNodeAnnotation.Attribute 4483 public boolean isTopLevelType() { 4484 boolean isTopLevelType_value = !isNestedType(); 4485 4486 return isTopLevelType_value; 4487 } 4488 /** 4489 * @attribute syn 4490 * @aspect NestedTypes 4491 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:585 4492 */ 4493 @ASTNodeAnnotation.Attribute 4494 public boolean isInnerClass() { 4495 boolean isInnerClass_value = false; 4496 4497 return isInnerClass_value; 4498 } 4499 /** 4500 * @attribute syn 4501 * @aspect NestedTypes 4502 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:587 4503 */ 4504 @ASTNodeAnnotation.Attribute 4505 public boolean isInnerType() { 4506 boolean isInnerType_value = (isLocalClass() || isAnonymous() || (isMemberType() && !isStatic())) && !inStaticContext(); 4507 4508 return isInnerType_value; 4509 } 4510 /** 4511 * @attribute syn 4512 * @aspect NestedTypes 4513 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:589 4514 */ 4515 @ASTNodeAnnotation.Attribute 4516 public boolean isInnerTypeOf(TypeDecl typeDecl) { 4517 boolean isInnerTypeOf_TypeDecl_value = typeDecl == this || (isInnerType() && enclosingType().isInnerTypeOf(typeDecl)); 4518 4519 return isInnerTypeOf_TypeDecl_value; 4520 } 4521 /** 4522 * @attribute syn 4523 * @aspect NestedTypes 4524 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:596 4525 */ 4526 @ASTNodeAnnotation.Attribute 4527 public TypeDecl withinBodyThatSubclasses(TypeDecl type) { 4528 { 4529 if (instanceOf(type)) { 4530 return this; 4531 } 4532 if (!isTopLevelType()) { 4533 return enclosingType().withinBodyThatSubclasses(type); 4534 } 4535 return null; 4536 } 4537 } 4538 /** 4539 * @attribute syn 4540 * @aspect NestedTypes 4541 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:606 4542 */ 4543 @ASTNodeAnnotation.Attribute 4544 public boolean encloses(TypeDecl type) { 4545 boolean encloses_TypeDecl_value = type.enclosedBy(this); 4546 4547 return encloses_TypeDecl_value; 4548 } 4549 /** 4550 * @attribute syn 4551 * @aspect NestedTypes 4552 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:608 4553 */ 4554 @ASTNodeAnnotation.Attribute 4555 public boolean enclosedBy(TypeDecl type) { 4556 { 4557 if (this == type) { 4558 return true; 4559 } 4560 if (isTopLevelType()) { 4561 return false; 4562 } 4563 return enclosingType().enclosedBy(type); 4564 } 4565 } 4566 /** 4567 * @attribute syn 4568 * @aspect NestedTypes 4569 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:624 4570 */ 4571 @ASTNodeAnnotation.Attribute 4572 public TypeDecl hostType() { 4573 TypeDecl hostType_value = this; 4574 4575 return hostType_value; 4576 } 4577 /** 4578 * @apilevel internal 4579 */ 4580 protected int isCircular_visited = -1; 4581 /** 4582 * @apilevel internal 4583 */ 4584 private void isCircular_reset() { 4585 isCircular_computed = false; 4586 isCircular_initialized = false; 4587 isCircular_visited = -1; 4588 } 4589 /** 4590 * @apilevel internal 4591 */ 4592 protected boolean isCircular_computed = false; 4593 /** 4594 * @apilevel internal 4595 */ 4596 protected boolean isCircular_initialized = false; 4597 /** 4598 * @apilevel internal 4599 */ 4600 protected boolean isCircular_value; 4601 @ASTNodeAnnotation.Attribute 4602 public boolean isCircular() { 4603 if (isCircular_computed) { 4604 return isCircular_value; 4605 } 4606 ASTNode$State state = state(); 4607 boolean new_isCircular_value; 4608 if (!isCircular_initialized) { 4609 isCircular_initialized = true; 4610 isCircular_value = true; 4611 } 4612 if (!state.IN_CIRCLE) { 4613 state.IN_CIRCLE = true; 4614 int num = state.boundariesCrossed; 4615 boolean isFinal = this.is$Final(); 4616 do { 4617 isCircular_visited = state.CIRCLE_INDEX; 4618 state.CHANGE = false; 4619 new_isCircular_value = false; 4620 if (new_isCircular_value != isCircular_value) { 4621 state.CHANGE = true; 4622 } 4623 isCircular_value = new_isCircular_value; 4624 state.CIRCLE_INDEX++; 4625 } while (state.CHANGE); 4626 if (isFinal && num == state().boundariesCrossed) { 4627 isCircular_computed = true; 4628 } else { 4629 state.RESET_CYCLE = true; 4630 boolean $tmp = false; 4631 state.RESET_CYCLE = false; 4632 isCircular_computed = false; 4633 isCircular_initialized = false; 4634 } 4635 state.IN_CIRCLE = false; 4636 state.INTERMEDIATE_VALUE = false; 4637 return isCircular_value; 4638 } 4639 if (isCircular_visited != state.CIRCLE_INDEX) { 4640 isCircular_visited = state.CIRCLE_INDEX; 4641 if (state.RESET_CYCLE) { 4642 isCircular_computed = false; 4643 isCircular_initialized = false; 4644 isCircular_visited = -1; 4645 return isCircular_value; 4646 } 4647 new_isCircular_value = false; 4648 if (new_isCircular_value != isCircular_value) { 4649 state.CHANGE = true; 4650 } 4651 isCircular_value = new_isCircular_value; 4652 state.INTERMEDIATE_VALUE = true; 4653 return isCircular_value; 4654 } 4655 state.INTERMEDIATE_VALUE = true; 4656 return isCircular_value; 4657 } 4658 /** 4659 * @apilevel internal 4660 */ 4661 protected boolean innerClassesAttributeEntries_computed = false; 4662 /** 4663 * @apilevel internal 4664 */ 4665 protected Collection innerClassesAttributeEntries_value; 4666 /** 4667 * @apilevel internal 4668 */ 4669 private void innerClassesAttributeEntries_reset() { 4670 innerClassesAttributeEntries_computed = false; 4671 innerClassesAttributeEntries_value = null; 4672 } 4673 /** 4674 * @attribute syn 4675 * @aspect Attributes 4676 * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:107 4677 */ 4678 @ASTNodeAnnotation.Attribute 4679 public Collection innerClassesAttributeEntries() { 4680 ASTNode$State state = state(); 4681 if (innerClassesAttributeEntries_computed) { 4682 return innerClassesAttributeEntries_value; 4683 } 4684 boolean intermediate = state.INTERMEDIATE_VALUE; 4685 state.INTERMEDIATE_VALUE = false; 4686 int num = state.boundariesCrossed; 4687 boolean isFinal = this.is$Final(); 4688 innerClassesAttributeEntries_value = innerClassesAttributeEntries_compute(); 4689 if (isFinal && num == state().boundariesCrossed) { 4690 innerClassesAttributeEntries_computed = true; 4691 } else { 4692 } 4693 state.INTERMEDIATE_VALUE |= intermediate; 4694 4695 return innerClassesAttributeEntries_value; 4696 } 4697 /** 4698 * @apilevel internal 4699 */ 4700 private Collection innerClassesAttributeEntries_compute() { 4701 HashSet list = new HashSet(); 4702 if (isNestedType()) { 4703 list.add(this); 4704 } 4705 for (Iterator iter = nestedTypes.iterator(); iter.hasNext(); ) { 4706 list.add(iter.next()); 4707 } 4708 for (Iterator iter = usedNestedTypes.iterator(); iter.hasNext(); ) { 4709 list.add(iter.next()); 4710 } 4711 return list; 4712 } 4713 /** 4714 * @apilevel internal 4715 */ 4716 protected boolean attributes_computed = false; 4717 /** 4718 * @apilevel internal 4719 */ 4720 protected Collection attributes_value; 4721 /** 4722 * @apilevel internal 4723 */ 4724 private void attributes_reset() { 4725 attributes_computed = false; 4726 attributes_value = null; 4727 } 4728 /** 4729 * @attribute syn 4730 * @aspect Attributes 4731 * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:191 4732 */ 4733 @ASTNodeAnnotation.Attribute 4734 public Collection attributes() { 4735 ASTNode$State state = state(); 4736 if (attributes_computed) { 4737 return attributes_value; 4738 } 4739 boolean intermediate = state.INTERMEDIATE_VALUE; 4740 state.INTERMEDIATE_VALUE = false; 4741 int num = state.boundariesCrossed; 4742 boolean isFinal = this.is$Final(); 4743 attributes_value = attributes_compute(); 4744 if (isFinal && num == state().boundariesCrossed) { 4745 attributes_computed = true; 4746 } else { 4747 } 4748 state.INTERMEDIATE_VALUE |= intermediate; 4749 4750 return attributes_value; 4751 } 4752 /** 4753 * @apilevel internal 4754 */ 4755 private Collection attributes_compute() { 4756 Collection c = refined_GenericsCodegen_TypeDecl_attributes(); 4757 if (isLocalClass() || isAnonymous()) { 4758 c.add(new EnclosingMethod(constantPool(), this)); 4759 } 4760 return c; 4761 } 4762 /** 4763 * @apilevel internal 4764 */ 4765 protected boolean clinit_attributes_computed = false; 4766 /** 4767 * @apilevel internal 4768 */ 4769 protected Collection clinit_attributes_value; 4770 /** 4771 * @apilevel internal 4772 */ 4773 private void clinit_attributes_reset() { 4774 clinit_attributes_computed = false; 4775 clinit_attributes_value = null; 4776 } 4777 /** 4778 * @attribute syn 4779 * @aspect Attributes 4780 * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:247 4781 */ 4782 @ASTNodeAnnotation.Attribute 4783 public Collection clinit_attributes() { 4784 ASTNode$State state = state(); 4785 if (clinit_attributes_computed) { 4786 return clinit_attributes_value; 4787 } 4788 boolean intermediate = state.INTERMEDIATE_VALUE; 4789 state.INTERMEDIATE_VALUE = false; 4790 int num = state.boundariesCrossed; 4791 boolean isFinal = this.is$Final(); 4792 clinit_attributes_value = clinit_attributes_compute(); 4793 if (isFinal && num == state().boundariesCrossed) { 4794 clinit_attributes_computed = true; 4795 } else { 4796 } 4797 state.INTERMEDIATE_VALUE |= intermediate; 4798 4799 return clinit_attributes_value; 4800 } 4801 /** 4802 * @apilevel internal 4803 */ 4804 private Collection clinit_attributes_compute() { 4805 ArrayList l = new ArrayList(); 4806 l.add(new CodeAttribute(bytecodes(constantPool()), null)); 4807 return l; 4808 } 4809 /** 4810 * @attribute syn 4811 * @aspect CodeGeneration 4812 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:249 4813 */ 4814 @ASTNodeAnnotation.Attribute 4815 public byte arrayLoad() { 4816 { 4817 throw new Error("Cannot create array load for TypeDecl"); 4818 } 4819 } 4820 /** 4821 * @attribute syn 4822 * @aspect CodeGeneration 4823 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:380 4824 */ 4825 @ASTNodeAnnotation.Attribute 4826 public byte arrayStore() { 4827 { 4828 throw new Error("Cannot create array load for TypeDecl"); 4829 } 4830 } 4831 /** 4832 * @apilevel internal 4833 */ 4834 protected boolean constantPool_computed = false; 4835 /** 4836 * @apilevel internal 4837 */ 4838 protected ConstantPool constantPool_value; 4839 /** 4840 * @apilevel internal 4841 */ 4842 private void constantPool_reset() { 4843 constantPool_computed = false; 4844 constantPool_value = null; 4845 } 4846 /** 4847 * @attribute syn 4848 * @aspect ConstantPool 4849 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPool.jrag:36 4850 */ 4851 @ASTNodeAnnotation.Attribute 4852 public ConstantPool constantPool() { 4853 ASTNode$State state = state(); 4854 if (constantPool_computed) { 4855 return constantPool_value; 4856 } 4857 boolean intermediate = state.INTERMEDIATE_VALUE; 4858 state.INTERMEDIATE_VALUE = false; 4859 int num = state.boundariesCrossed; 4860 boolean isFinal = this.is$Final(); 4861 constantPool_value = new ConstantPool(this); 4862 if (isFinal && num == state().boundariesCrossed) { 4863 constantPool_computed = true; 4864 } else { 4865 } 4866 state.INTERMEDIATE_VALUE |= intermediate; 4867 4868 return constantPool_value; 4869 } 4870 /** 4871 * @apilevel internal 4872 */ 4873 protected boolean constantPoolName_computed = false; 4874 /** 4875 * @apilevel internal 4876 */ 4877 protected String constantPoolName_value; 4878 /** 4879 * @apilevel internal 4880 */ 4881 private void constantPoolName_reset() { 4882 constantPoolName_computed = false; 4883 constantPoolName_value = null; 4884 } 4885 /** 4886 * For a top-level type the constant pool name of the type is the same as the 4887 * canonical name but with dots replaced by solidus. 4888 * 4889 * <p>For nested types the constant pool name is based on the enclosing top-level 4890 * types constant pool name followed by a dollar sign and a unique index and/or 4891 * the type name. 4892 * 4893 * @return constant pool name of this type 4894 * @attribute syn 4895 * @aspect ConstantPoolNames 4896 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:44 4897 */ 4898 @ASTNodeAnnotation.Attribute 4899 public String constantPoolName() { 4900 ASTNode$State state = state(); 4901 if (constantPoolName_computed) { 4902 return constantPoolName_value; 4903 } 4904 boolean intermediate = state.INTERMEDIATE_VALUE; 4905 state.INTERMEDIATE_VALUE = false; 4906 int num = state.boundariesCrossed; 4907 boolean isFinal = this.is$Final(); 4908 constantPoolName_value = constantPoolName_compute(); 4909 if (isFinal && num == state().boundariesCrossed) { 4910 constantPoolName_computed = true; 4911 } else { 4912 } 4913 state.INTERMEDIATE_VALUE |= intermediate; 4914 4915 return constantPoolName_value; 4916 } 4917 /** 4918 * @apilevel internal 4919 */ 4920 private String constantPoolName_compute() { 4921 String packageName = packageName(); 4922 if (!packageName.equals("")) { 4923 packageName = packageName.replace('.', '/') + "/"; 4924 } 4925 return packageName + uniqueName(); 4926 } 4927 /** 4928 * @apilevel internal 4929 */ 4930 protected boolean uniqueName_computed = false; 4931 /** 4932 * @apilevel internal 4933 */ 4934 protected String uniqueName_value; 4935 /** 4936 * @apilevel internal 4937 */ 4938 private void uniqueName_reset() { 4939 uniqueName_computed = false; 4940 uniqueName_value = null; 4941 } 4942 /** 4943 * Computes a unique name for this type in the enclosing package. 4944 * <p>For top-level types the unique name is just the type name. For nested 4945 * types it is the enclosing types unique name followed by a dollar sign and 4946 * a unique index and/or the type name. 4947 * 4948 * @return a name for this type that is unique in the enclosing package 4949 * @attribute syn 4950 * @aspect ConstantPoolNames 4951 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:60 4952 */ 4953 @ASTNodeAnnotation.Attribute 4954 public String uniqueName() { 4955 ASTNode$State state = state(); 4956 if (uniqueName_computed) { 4957 return uniqueName_value; 4958 } 4959 boolean intermediate = state.INTERMEDIATE_VALUE; 4960 state.INTERMEDIATE_VALUE = false; 4961 int num = state.boundariesCrossed; 4962 boolean isFinal = this.is$Final(); 4963 uniqueName_value = uniqueName_compute(); 4964 if (isFinal && num == state().boundariesCrossed) { 4965 uniqueName_computed = true; 4966 } else { 4967 } 4968 state.INTERMEDIATE_VALUE |= intermediate; 4969 4970 return uniqueName_value; 4971 } 4972 /** 4973 * @apilevel internal 4974 */ 4975 private String uniqueName_compute() { 4976 if (!isNestedType()) { 4977 return getID(); 4978 } else { 4979 String prefix = enclosingType().uniqueName(); 4980 if (isAnonymous()) { 4981 return prefix + "$" + uniqueIndex(); 4982 } else if (isLocalClass()) { 4983 return prefix + "$" + uniqueIndex() + getID(); 4984 } else { 4985 return prefix + "$" + getID(); 4986 } 4987 } 4988 } 4989 /** 4990 * @apilevel internal 4991 */ 4992 protected boolean typeDescriptor_computed = false; 4993 /** 4994 * @apilevel internal 4995 */ 4996 protected String typeDescriptor_value; 4997 /** 4998 * @apilevel internal 4999 */ 5000 private void typeDescriptor_reset() { 5001 typeDescriptor_computed = false; 5002 typeDescriptor_value = null; 5003 } 5004 /** 5005 * @attribute syn 5006 * @aspect ConstantPoolNames 5007 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:77 5008 */ 5009 @ASTNodeAnnotation.Attribute 5010 public String typeDescriptor() { 5011 ASTNode$State state = state(); 5012 if (typeDescriptor_computed) { 5013 return typeDescriptor_value; 5014 } 5015 boolean intermediate = state.INTERMEDIATE_VALUE; 5016 state.INTERMEDIATE_VALUE = false; 5017 int num = state.boundariesCrossed; 5018 boolean isFinal = this.is$Final(); 5019 typeDescriptor_value = typeDescriptor_compute(); 5020 if (isFinal && num == state().boundariesCrossed) { 5021 typeDescriptor_computed = true; 5022 } else { 5023 } 5024 state.INTERMEDIATE_VALUE |= intermediate; 5025 5026 return typeDescriptor_value; 5027 } 5028 /** 5029 * @apilevel internal 5030 */ 5031 private String typeDescriptor_compute() { 5032 throw new Error("Can not compute typeDescriptor for " + getClass().getName()); 5033 } 5034 /** 5035 * @apilevel internal 5036 */ 5037 protected boolean destinationPath_computed = false; 5038 /** 5039 * @apilevel internal 5040 */ 5041 protected String destinationPath_value; 5042 /** 5043 * @apilevel internal 5044 */ 5045 private void destinationPath_reset() { 5046 destinationPath_computed = false; 5047 destinationPath_value = null; 5048 } 5049 /** 5050 * @return The path to the classfiles that should be generated for this type. 5051 * @attribute syn 5052 * @aspect ConstantPoolNames 5053 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:158 5054 */ 5055 @ASTNodeAnnotation.Attribute 5056 public String destinationPath() { 5057 ASTNode$State state = state(); 5058 if (destinationPath_computed) { 5059 return destinationPath_value; 5060 } 5061 boolean intermediate = state.INTERMEDIATE_VALUE; 5062 state.INTERMEDIATE_VALUE = false; 5063 int num = state.boundariesCrossed; 5064 boolean isFinal = this.is$Final(); 5065 destinationPath_value = destinationPath_compute(); 5066 if (isFinal && num == state().boundariesCrossed) { 5067 destinationPath_computed = true; 5068 } else { 5069 } 5070 state.INTERMEDIATE_VALUE |= intermediate; 5071 5072 return destinationPath_value; 5073 } 5074 /** 5075 * @apilevel internal 5076 */ 5077 private String destinationPath_compute() { 5078 if (program().options().hasValueForOption("-d")) { 5079 return program().options().getValueForOption("-d") + File.separator 5080 + constantPoolName() + ".class"; 5081 } else { 5082 return compilationUnit().destinationPath() + File.separator 5083 + uniqueName() + ".class"; 5084 } 5085 } 5086 /** 5087 * @apilevel internal 5088 */ 5089 protected boolean hasClinit_computed = false; 5090 /** 5091 * @apilevel internal 5092 */ 5093 protected boolean hasClinit_value; 5094 /** 5095 * @apilevel internal 5096 */ 5097 private void hasClinit_reset() { 5098 hasClinit_computed = false; 5099 } 5100 /** 5101 * @attribute syn 5102 * @aspect CreateBCode 5103 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:50 5104 */ 5105 @ASTNodeAnnotation.Attribute 5106 public boolean hasClinit() { 5107 ASTNode$State state = state(); 5108 if (hasClinit_computed) { 5109 return hasClinit_value; 5110 } 5111 boolean intermediate = state.INTERMEDIATE_VALUE; 5112 state.INTERMEDIATE_VALUE = false; 5113 int num = state.boundariesCrossed; 5114 boolean isFinal = this.is$Final(); 5115 hasClinit_value = hasClinit_compute(); 5116 if (isFinal && num == state().boundariesCrossed) { 5117 hasClinit_computed = true; 5118 } else { 5119 } 5120 state.INTERMEDIATE_VALUE |= intermediate; 5121 5122 return hasClinit_value; 5123 } 5124 /** 5125 * @apilevel internal 5126 */ 5127 private boolean hasClinit_compute() { 5128 for (int i = 0; i < getNumBodyDecl(); i++) { 5129 BodyDecl b = getBodyDecl(i); 5130 if (b instanceof FieldDeclaration) { 5131 FieldDeclaration f = (FieldDeclaration) b; 5132 if (f.isStatic() && f.hasInit()) { 5133 return true; 5134 } 5135 } else if (b instanceof StaticInitializer) { 5136 return true; 5137 } 5138 } 5139 return false; 5140 } 5141 /** 5142 * @apilevel internal 5143 */ 5144 protected java.util.Map bytecodes_ConstantPool_values; 5145 /** 5146 * @apilevel internal 5147 */ 5148 private void bytecodes_ConstantPool_reset() { 5149 bytecodes_ConstantPool_values = null; 5150 } 5151 /** 5152 * @attribute syn 5153 * @aspect CreateBCode 5154 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:65 5155 */ 5156 @ASTNodeAnnotation.Attribute 5157 public CodeGeneration bytecodes(ConstantPool constantPool) { 5158 Object _parameters = constantPool; 5159 if (bytecodes_ConstantPool_values == null) bytecodes_ConstantPool_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 5160 ASTNode$State state = state(); 5161 if (bytecodes_ConstantPool_values.containsKey(_parameters)) { 5162 return (CodeGeneration) bytecodes_ConstantPool_values.get(_parameters); 5163 } 5164 boolean intermediate = state.INTERMEDIATE_VALUE; 5165 state.INTERMEDIATE_VALUE = false; 5166 int num = state.boundariesCrossed; 5167 boolean isFinal = this.is$Final(); 5168 CodeGeneration bytecodes_ConstantPool_value = bytecodes_compute(constantPool); 5169 if (isFinal && num == state().boundariesCrossed) { 5170 bytecodes_ConstantPool_values.put(_parameters, bytecodes_ConstantPool_value); 5171 } else { 5172 } 5173 state.INTERMEDIATE_VALUE |= intermediate; 5174 5175 return bytecodes_ConstantPool_value; 5176 } 5177 /** 5178 * @apilevel internal 5179 */ 5180 private CodeGeneration bytecodes_compute(ConstantPool constantPool) { 5181 CodeGeneration gen = new CodeGeneration(constantPool); 5182 generateBytecodes(gen); 5183 if (!gen.numberFormatError()) { 5184 return gen; 5185 } 5186 gen = new CodeGeneration(constantPool, true); 5187 generateBytecodes(gen); 5188 if (!gen.numberFormatError()) { 5189 return gen; 5190 } 5191 throw new Error("Could not generate code for initializers in " + hostType().typeName()); 5192 } 5193 /** 5194 * @attribute syn 5195 * @aspect CreateBCode 5196 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:550 5197 */ 5198 @ASTNodeAnnotation.Attribute 5199 public boolean needsAccessorFor(Variable v) { 5200 { 5201 if (!(v instanceof FieldDeclaration)) { 5202 return false; 5203 } 5204 FieldDeclaration f = (FieldDeclaration) v; 5205 if (f.isConstant() && (f.type().isPrimitive() || f.type().isString())) { 5206 return false; 5207 } 5208 return f.isPrivate() && !hasField(v.name()); 5209 } 5210 } 5211 /** 5212 * @attribute syn 5213 * @aspect CreateBCode 5214 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:900 5215 */ 5216 @ASTNodeAnnotation.Attribute 5217 public String arrayTypeDescriptor() { 5218 { throw new Error("Operation not supported"); } 5219 } 5220 /** 5221 * @attribute syn 5222 * @aspect CreateBCode 5223 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:905 5224 */ 5225 @ASTNodeAnnotation.Attribute 5226 public int arrayPrimitiveTypeDescriptor() { 5227 { error(); return -1; } 5228 } 5229 /** 5230 * @apilevel internal 5231 */ 5232 protected boolean flags_computed = false; 5233 /** 5234 * @apilevel internal 5235 */ 5236 protected int flags_value; 5237 /** 5238 * @apilevel internal 5239 */ 5240 private void flags_reset() { 5241 flags_computed = false; 5242 } 5243 /** 5244 * @attribute syn 5245 * @aspect Flags 5246 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:110 5247 */ 5248 @ASTNodeAnnotation.Attribute 5249 public int flags() { 5250 ASTNode$State state = state(); 5251 if (flags_computed) { 5252 return flags_value; 5253 } 5254 boolean intermediate = state.INTERMEDIATE_VALUE; 5255 state.INTERMEDIATE_VALUE = false; 5256 int num = state.boundariesCrossed; 5257 boolean isFinal = this.is$Final(); 5258 flags_value = flags_compute(); 5259 if (isFinal && num == state().boundariesCrossed) { 5260 flags_computed = true; 5261 } else { 5262 } 5263 state.INTERMEDIATE_VALUE |= intermediate; 5264 5265 return flags_value; 5266 } 5267 /** 5268 * @apilevel internal 5269 */ 5270 private int flags_compute() { 5271 int res = 0; 5272 if (isPublic()) { 5273 res |= Modifiers.ACC_PUBLIC; 5274 } 5275 if (isPrivate()) { 5276 res |= Modifiers.ACC_PRIVATE; 5277 } 5278 if (isProtected()) { 5279 res |= Modifiers.ACC_PROTECTED; 5280 } 5281 if (isStatic()) { 5282 res |= Modifiers.ACC_STATIC; 5283 } 5284 if (isFinal()) { 5285 res |= Modifiers.ACC_FINAL; 5286 } 5287 // ACC_INTERFACE handled in InterfaceDecl 5288 if (isAbstract()) { 5289 res |= Modifiers.ACC_ABSTRACT; 5290 } 5291 return res; 5292 } 5293 /** 5294 * @attribute syn 5295 * @aspect GenerateClassfile 5296 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:55 5297 */ 5298 @ASTNodeAnnotation.Attribute 5299 public int magicHeader() { 5300 int magicHeader_value = 0xCAFEBABE; 5301 5302 return magicHeader_value; 5303 } 5304 /** 5305 * @attribute syn 5306 * @aspect GenerateClassfile 5307 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:56 5308 */ 5309 @ASTNodeAnnotation.Attribute 5310 public int minorVersion() { 5311 int minorVersion_value = 0; 5312 5313 return minorVersion_value; 5314 } 5315 /** 5316 * @attribute syn 5317 * @aspect GenerateClassfile 5318 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:57 5319 */ 5320 @ASTNodeAnnotation.Attribute 5321 public int majorVersion() { 5322 { 5323 return 49; 5324 } 5325 } 5326 /** 5327 * @apilevel internal 5328 */ 5329 protected boolean bcFields_computed = false; 5330 /** 5331 * @apilevel internal 5332 */ 5333 protected Collection bcFields_value; 5334 /** 5335 * @apilevel internal 5336 */ 5337 private void bcFields_reset() { 5338 bcFields_computed = false; 5339 bcFields_value = null; 5340 } 5341 /** 5342 * @attribute syn 5343 * @aspect GenerateClassfile 5344 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:317 5345 */ 5346 @ASTNodeAnnotation.Attribute 5347 public Collection bcFields() { 5348 ASTNode$State state = state(); 5349 if (bcFields_computed) { 5350 return bcFields_value; 5351 } 5352 boolean intermediate = state.INTERMEDIATE_VALUE; 5353 state.INTERMEDIATE_VALUE = false; 5354 int num = state.boundariesCrossed; 5355 boolean isFinal = this.is$Final(); 5356 bcFields_value = new ArrayList(); 5357 if (isFinal && num == state().boundariesCrossed) { 5358 bcFields_computed = true; 5359 } else { 5360 } 5361 state.INTERMEDIATE_VALUE |= intermediate; 5362 5363 return bcFields_value; 5364 } 5365 /** 5366 * @attribute syn 5367 * @aspect GenerateClassfile 5368 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:379 5369 */ 5370 @ASTNodeAnnotation.Attribute 5371 public boolean flush() { 5372 boolean flush_value = false; 5373 5374 return flush_value; 5375 } 5376 /** 5377 * @attribute syn 5378 * @aspect InnerClasses 5379 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:113 5380 */ 5381 @ASTNodeAnnotation.Attribute 5382 public TypeDecl stringPromotion() { 5383 TypeDecl stringPromotion_value = this; 5384 5385 return stringPromotion_value; 5386 } 5387 /** 5388 * @attribute syn 5389 * @aspect InnerClasses 5390 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:125 5391 */ 5392 @ASTNodeAnnotation.Attribute 5393 public MethodDecl methodWithArgs(String name, TypeDecl[] args) { 5394 { 5395 for (Iterator iter = memberMethods(name).iterator(); iter.hasNext(); ) { 5396 MethodDecl m = (MethodDecl) iter.next(); 5397 if (m.getNumParameter() == args.length) { 5398 for (int i = 0; i < args.length; i++) { 5399 if (m.getParameter(i).type() == args[i]) { 5400 return m; 5401 } 5402 } 5403 } 5404 } 5405 return null; 5406 } 5407 } 5408 /** 5409 * @apilevel internal 5410 */ 5411 protected boolean enclosingVariables_computed = false; 5412 /** 5413 * @apilevel internal 5414 */ 5415 protected Collection enclosingVariables_value; 5416 /** 5417 * @apilevel internal 5418 */ 5419 private void enclosingVariables_reset() { 5420 enclosingVariables_computed = false; 5421 enclosingVariables_value = null; 5422 } 5423 /** 5424 * @attribute syn 5425 * @aspect InnerClasses 5426 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:176 5427 */ 5428 @ASTNodeAnnotation.Attribute 5429 public Collection enclosingVariables() { 5430 ASTNode$State state = state(); 5431 if (enclosingVariables_computed) { 5432 return enclosingVariables_value; 5433 } 5434 boolean intermediate = state.INTERMEDIATE_VALUE; 5435 state.INTERMEDIATE_VALUE = false; 5436 int num = state.boundariesCrossed; 5437 boolean isFinal = this.is$Final(); 5438 enclosingVariables_value = enclosingVariables_compute(); 5439 if (isFinal && num == state().boundariesCrossed) { 5440 enclosingVariables_computed = true; 5441 } else { 5442 } 5443 state.INTERMEDIATE_VALUE |= intermediate; 5444 5445 return enclosingVariables_value; 5446 } 5447 /** 5448 * @apilevel internal 5449 */ 5450 private Collection enclosingVariables_compute() { 5451 HashSet set = new HashSet(); 5452 for (TypeDecl e = this; e != null; e = e.enclosingType()) { 5453 if (e.isLocalClass() || e.isAnonymous()) { 5454 collectEnclosingVariables(set, e.enclosingType()); 5455 } 5456 } 5457 if (isClassDecl()) { 5458 ClassDecl classDecl = (ClassDecl) this; 5459 if (classDecl.isNestedType() && classDecl.hasSuperclass()) { 5460 set.addAll(classDecl.superclass().enclosingVariables()); 5461 } 5462 } 5463 return set; 5464 } 5465 /** 5466 * @attribute syn 5467 * @aspect InnerClasses 5468 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:456 5469 */ 5470 @ASTNodeAnnotation.Attribute 5471 public boolean isAnonymousInNonStaticContext() { 5472 { 5473 return isAnonymous() && 5474 !((ClassInstanceExpr) getParent().getParent()).unqualifiedScope().inStaticContext() 5475 && (!inExplicitConstructorInvocation() || enclosingBodyDecl().hostType().isInnerType()); 5476 } 5477 } 5478 /** 5479 * @apilevel internal 5480 */ 5481 protected boolean needsEnclosing_computed = false; 5482 /** 5483 * @apilevel internal 5484 */ 5485 protected boolean needsEnclosing_value; 5486 /** 5487 * @apilevel internal 5488 */ 5489 private void needsEnclosing_reset() { 5490 needsEnclosing_computed = false; 5491 } 5492 /** 5493 * @attribute syn 5494 * @aspect InnerClasses 5495 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:462 5496 */ 5497 @ASTNodeAnnotation.Attribute 5498 public boolean needsEnclosing() { 5499 ASTNode$State state = state(); 5500 if (needsEnclosing_computed) { 5501 return needsEnclosing_value; 5502 } 5503 boolean intermediate = state.INTERMEDIATE_VALUE; 5504 state.INTERMEDIATE_VALUE = false; 5505 int num = state.boundariesCrossed; 5506 boolean isFinal = this.is$Final(); 5507 needsEnclosing_value = needsEnclosing_compute(); 5508 if (isFinal && num == state().boundariesCrossed) { 5509 needsEnclosing_computed = true; 5510 } else { 5511 } 5512 state.INTERMEDIATE_VALUE |= intermediate; 5513 5514 return needsEnclosing_value; 5515 } 5516 /** 5517 * @apilevel internal 5518 */ 5519 private boolean needsEnclosing_compute() { 5520 if (isAnonymous()) { 5521 return isAnonymousInNonStaticContext(); 5522 } else if (isLocalClass()) { 5523 return !inStaticContext(); 5524 } else if (isInnerType()) { 5525 return true; 5526 } 5527 return false; 5528 } 5529 /** 5530 * @apilevel internal 5531 */ 5532 protected boolean needsSuperEnclosing_computed = false; 5533 /** 5534 * @apilevel internal 5535 */ 5536 protected boolean needsSuperEnclosing_value; 5537 /** 5538 * @apilevel internal 5539 */ 5540 private void needsSuperEnclosing_reset() { 5541 needsSuperEnclosing_computed = false; 5542 } 5543 /** 5544 * @attribute syn 5545 * @aspect InnerClasses 5546 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:473 5547 */ 5548 @ASTNodeAnnotation.Attribute 5549 public boolean needsSuperEnclosing() { 5550 ASTNode$State state = state(); 5551 if (needsSuperEnclosing_computed) { 5552 return needsSuperEnclosing_value; 5553 } 5554 boolean intermediate = state.INTERMEDIATE_VALUE; 5555 state.INTERMEDIATE_VALUE = false; 5556 int num = state.boundariesCrossed; 5557 boolean isFinal = this.is$Final(); 5558 needsSuperEnclosing_value = needsSuperEnclosing_compute(); 5559 if (isFinal && num == state().boundariesCrossed) { 5560 needsSuperEnclosing_computed = true; 5561 } else { 5562 } 5563 state.INTERMEDIATE_VALUE |= intermediate; 5564 5565 return needsSuperEnclosing_value; 5566 } 5567 /** 5568 * @apilevel internal 5569 */ 5570 private boolean needsSuperEnclosing_compute() { 5571 if (!isAnonymous()) { 5572 return false; 5573 } 5574 TypeDecl superClass = ((ClassDecl) this).superclass(); 5575 if (superClass.isLocalClass()) { 5576 return !superClass.inStaticContext(); 5577 } else if (superClass.isInnerType()) { 5578 return true; 5579 } if (needsEnclosing() && enclosing() == superEnclosing()) { 5580 return false; 5581 } 5582 return false; 5583 } 5584 /** 5585 * @attribute syn 5586 * @aspect InnerClasses 5587 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:488 5588 */ 5589 @ASTNodeAnnotation.Attribute 5590 public TypeDecl enclosing() { 5591 { 5592 if (!needsEnclosing()) { 5593 return null; 5594 } 5595 TypeDecl typeDecl = enclosingType(); 5596 if (isAnonymous() && inExplicitConstructorInvocation()) { 5597 typeDecl = typeDecl.enclosingType(); 5598 } 5599 return typeDecl; 5600 } 5601 } 5602 /** 5603 * @attribute syn 5604 * @aspect InnerClasses 5605 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:499 5606 */ 5607 @ASTNodeAnnotation.Attribute 5608 public TypeDecl superEnclosing() { 5609 TypeDecl superEnclosing_value = null; 5610 5611 return superEnclosing_value; 5612 } 5613 /** 5614 * @apilevel internal 5615 */ 5616 protected boolean uniqueIndex_computed = false; 5617 /** 5618 * @apilevel internal 5619 */ 5620 protected int uniqueIndex_value; 5621 /** 5622 * @apilevel internal 5623 */ 5624 private void uniqueIndex_reset() { 5625 uniqueIndex_computed = false; 5626 } 5627 /** 5628 * @attribute syn 5629 * @aspect Java2Rewrites 5630 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:33 5631 */ 5632 @ASTNodeAnnotation.Attribute 5633 public int uniqueIndex() { 5634 ASTNode$State state = state(); 5635 if (uniqueIndex_computed) { 5636 return uniqueIndex_value; 5637 } 5638 boolean intermediate = state.INTERMEDIATE_VALUE; 5639 state.INTERMEDIATE_VALUE = false; 5640 int num = state.boundariesCrossed; 5641 boolean isFinal = this.is$Final(); 5642 uniqueIndex_value = topLevelType().uniqueIndexCounter++; 5643 if (isFinal && num == state().boundariesCrossed) { 5644 uniqueIndex_computed = true; 5645 } else { 5646 } 5647 state.INTERMEDIATE_VALUE |= intermediate; 5648 5649 return uniqueIndex_value; 5650 } 5651 /** 5652 * @apilevel internal 5653 */ 5654 protected boolean jvmName_computed = false; 5655 /** 5656 * @apilevel internal 5657 */ 5658 protected String jvmName_value; 5659 /** 5660 * @apilevel internal 5661 */ 5662 private void jvmName_reset() { 5663 jvmName_computed = false; 5664 jvmName_value = null; 5665 } 5666 /** 5667 * @attribute syn 5668 * @aspect Java2Rewrites 5669 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:36 5670 */ 5671 @ASTNodeAnnotation.Attribute 5672 public String jvmName() { 5673 ASTNode$State state = state(); 5674 if (jvmName_computed) { 5675 return jvmName_value; 5676 } 5677 boolean intermediate = state.INTERMEDIATE_VALUE; 5678 state.INTERMEDIATE_VALUE = false; 5679 int num = state.boundariesCrossed; 5680 boolean isFinal = this.is$Final(); 5681 jvmName_value = jvmName_compute(); 5682 if (isFinal && num == state().boundariesCrossed) { 5683 jvmName_computed = true; 5684 } else { 5685 } 5686 state.INTERMEDIATE_VALUE |= intermediate; 5687 5688 return jvmName_value; 5689 } 5690 /** 5691 * @apilevel internal 5692 */ 5693 private String jvmName_compute() { 5694 throw new Error("Jvm name only supported for reference types and not " + getClass().getName()); 5695 } 5696 /** 5697 * @attribute syn 5698 * @aspect Java2Rewrites 5699 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:68 5700 */ 5701 @ASTNodeAnnotation.Attribute 5702 public String primitiveClassName() { 5703 { 5704 throw new Error("primitiveClassName not supported for " + name() + " of type " + getClass().getName()); 5705 } 5706 } 5707 /** 5708 * @attribute syn 5709 * @aspect Java2Rewrites 5710 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:81 5711 */ 5712 @ASTNodeAnnotation.Attribute 5713 public String referenceClassFieldName() { 5714 { 5715 throw new Error("referenceClassFieldName not supported for " + name() + " of type " + getClass().getName()); 5716 } 5717 } 5718 /** 5719 * @attribute syn 5720 * @aspect LocalNum 5721 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:199 5722 */ 5723 @ASTNodeAnnotation.Attribute 5724 public int variableSize() { 5725 int variableSize_value = 0; 5726 5727 return variableSize_value; 5728 } 5729 /** 5730 * @attribute syn 5731 * @aspect Annotations 5732 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:151 5733 */ 5734 @ASTNodeAnnotation.Attribute 5735 public boolean isValidAnnotationMethodReturnType() { 5736 boolean isValidAnnotationMethodReturnType_value = false; 5737 5738 return isValidAnnotationMethodReturnType_value; 5739 } 5740 /** 5741 * @attribute syn 5742 * @aspect Annotations 5743 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:289 5744 */ 5745 @ASTNodeAnnotation.Attribute 5746 public boolean isType(String packageName, String name) { 5747 boolean isType_String_String_value = getID().equals(name) && packageName().equals(packageName); 5748 5749 return isType_String_String_value; 5750 } 5751 /** 5752 * @attribute syn 5753 * @aspect Annotations 5754 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:292 5755 */ 5756 @ASTNodeAnnotation.Attribute 5757 public Annotation annotation(TypeDecl typeDecl) { 5758 Annotation annotation_TypeDecl_value = getModifiers().annotation(typeDecl); 5759 5760 return annotation_TypeDecl_value; 5761 } 5762 /** 5763 * @attribute syn 5764 * @aspect Annotations 5765 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:355 5766 */ 5767 @ASTNodeAnnotation.Attribute 5768 public boolean hasAnnotationSuppressWarnings(String annot) { 5769 boolean hasAnnotationSuppressWarnings_String_value = getModifiers().hasAnnotationSuppressWarnings(annot); 5770 5771 return hasAnnotationSuppressWarnings_String_value; 5772 } 5773 /** 5774 * @attribute syn 5775 * @aspect Annotations 5776 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:397 5777 */ 5778 @ASTNodeAnnotation.Attribute 5779 public boolean isDeprecated() { 5780 boolean isDeprecated_value = getModifiers().hasDeprecatedAnnotation(); 5781 5782 return isDeprecated_value; 5783 } 5784 /** 5785 * @attribute syn 5786 * @aspect Annotations 5787 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:557 5788 */ 5789 @ASTNodeAnnotation.Attribute 5790 public boolean commensurateWith(ElementValue value) { 5791 boolean commensurateWith_ElementValue_value = value.commensurateWithTypeDecl(this); 5792 5793 return commensurateWith_ElementValue_value; 5794 } 5795 /** 5796 * @attribute syn 5797 * @aspect Annotations 5798 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:642 5799 */ 5800 @ASTNodeAnnotation.Attribute 5801 public boolean isAnnotationDecl() { 5802 boolean isAnnotationDecl_value = false; 5803 5804 return isAnnotationDecl_value; 5805 } 5806 /** 5807 * @attribute syn 5808 * @aspect AutoBoxing 5809 * @declaredat /home/jesper/git/extendj/java5/frontend/AutoBoxing.jrag:52 5810 */ 5811 @ASTNodeAnnotation.Attribute 5812 public boolean boxingConversionTo(TypeDecl typeDecl) { 5813 boolean boxingConversionTo_TypeDecl_value = false; 5814 5815 return boxingConversionTo_TypeDecl_value; 5816 } 5817 /** 5818 * @apilevel internal 5819 */ 5820 protected boolean boxed_computed = false; 5821 /** 5822 * @apilevel internal 5823 */ 5824 protected TypeDecl boxed_value; 5825 /** 5826 * @apilevel internal 5827 */ 5828 private void boxed_reset() { 5829 boxed_computed = false; 5830 boxed_value = null; 5831 } 5832 /** 5833 * @attribute syn 5834 * @aspect AutoBoxing 5835 * @declaredat /home/jesper/git/extendj/java5/frontend/AutoBoxing.jrag:56 5836 */ 5837 @ASTNodeAnnotation.Attribute 5838 public TypeDecl boxed() { 5839 ASTNode$State state = state(); 5840 if (boxed_computed) { 5841 return boxed_value; 5842 } 5843 boolean intermediate = state.INTERMEDIATE_VALUE; 5844 state.INTERMEDIATE_VALUE = false; 5845 int num = state.boundariesCrossed; 5846 boolean isFinal = this.is$Final(); 5847 boxed_value = unknownType(); 5848 if (isFinal && num == state().boundariesCrossed) { 5849 boxed_computed = true; 5850 } else { 5851 } 5852 state.INTERMEDIATE_VALUE |= intermediate; 5853 5854 return boxed_value; 5855 } 5856 /** 5857 * @attribute syn 5858 * @aspect AutoBoxing 5859 * @declaredat /home/jesper/git/extendj/java5/frontend/AutoBoxing.jrag:68 5860 */ 5861 @ASTNodeAnnotation.Attribute 5862 public boolean unboxingConversionTo(TypeDecl typeDecl) { 5863 boolean unboxingConversionTo_TypeDecl_value = false; 5864 5865 return unboxingConversionTo_TypeDecl_value; 5866 } 5867 /** 5868 * @apilevel internal 5869 */ 5870 protected boolean unboxed_computed = false; 5871 /** 5872 * @apilevel internal 5873 */ 5874 protected TypeDecl unboxed_value; 5875 /** 5876 * @apilevel internal 5877 */ 5878 private void unboxed_reset() { 5879 unboxed_computed = false; 5880 unboxed_value = null; 5881 } 5882 /** 5883 * @attribute syn 5884 * @aspect AutoBoxing 5885 * @declaredat /home/jesper/git/extendj/java5/frontend/AutoBoxing.jrag:72 5886 */ 5887 @ASTNodeAnnotation.Attribute 5888 public TypeDecl unboxed() { 5889 ASTNode$State state = state(); 5890 if (unboxed_computed) { 5891 return unboxed_value; 5892 } 5893 boolean intermediate = state.INTERMEDIATE_VALUE; 5894 state.INTERMEDIATE_VALUE = false; 5895 int num = state.boundariesCrossed; 5896 boolean isFinal = this.is$Final(); 5897 unboxed_value = unknownType(); 5898 if (isFinal && num == state().boundariesCrossed) { 5899 unboxed_computed = true; 5900 } else { 5901 } 5902 state.INTERMEDIATE_VALUE |= intermediate; 5903 5904 return unboxed_value; 5905 } 5906 /** 5907 * @apilevel internal 5908 */ 5909 protected boolean isIterable_computed = false; 5910 /** 5911 * @apilevel internal 5912 */ 5913 protected boolean isIterable_value; 5914 /** 5915 * @apilevel internal 5916 */ 5917 private void isIterable_reset() { 5918 isIterable_computed = false; 5919 } 5920 /** 5921 * True if type is java.lang.Iterable or subtypeAs long as we use the 1.4 API we check for java.util.Collection instead. 5922 * @attribute syn 5923 * @aspect EnhancedFor 5924 * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:63 5925 */ 5926 @ASTNodeAnnotation.Attribute 5927 public boolean isIterable() { 5928 ASTNode$State state = state(); 5929 if (isIterable_computed) { 5930 return isIterable_value; 5931 } 5932 boolean intermediate = state.INTERMEDIATE_VALUE; 5933 state.INTERMEDIATE_VALUE = false; 5934 int num = state.boundariesCrossed; 5935 boolean isFinal = this.is$Final(); 5936 isIterable_value = instanceOf(lookupType("java.lang", "Iterable")); 5937 if (isFinal && num == state().boundariesCrossed) { 5938 isIterable_computed = true; 5939 } else { 5940 } 5941 state.INTERMEDIATE_VALUE |= intermediate; 5942 5943 return isIterable_value; 5944 } 5945 /** 5946 * @attribute syn 5947 * @aspect Enums 5948 * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:37 5949 */ 5950 @ASTNodeAnnotation.Attribute 5951 public boolean isEnumDecl() { 5952 boolean isEnumDecl_value = false; 5953 5954 return isEnumDecl_value; 5955 } 5956 /** 5957 * @param bound the bounded type variable 5958 * @param par a parameterization of the type for which the type variable 5959 * occurs in the type parameter list 5960 * @return {@code true} if this type is within the bounds of the parameter type 5961 * @attribute syn 5962 * @aspect GenericBoundCheck 5963 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:42 5964 */ 5965 @ASTNodeAnnotation.Attribute 5966 public boolean withinBounds(TypeDecl bound, Parameterization par) { 5967 boolean withinBounds_TypeDecl_Parameterization_value = bound.boundOf(this, par); 5968 5969 return withinBounds_TypeDecl_Parameterization_value; 5970 } 5971 /** 5972 * Check if a type is in the bound of this type, given a specific 5973 * parameterization of this type. 5974 * 5975 * See JLS SE7 $4.5 5976 * 5977 * @param argument argument type 5978 * @param par a parameterization 5979 * @return {@code true} if the argument type is in the bound of this type 5980 * @attribute syn 5981 * @aspect GenericBoundCheck 5982 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:63 5983 */ 5984 @ASTNodeAnnotation.Attribute 5985 public boolean boundOf(TypeDecl argument, Parameterization par) { 5986 boolean boundOf_TypeDecl_Parameterization_value = false; 5987 5988 return boundOf_TypeDecl_Parameterization_value; 5989 } 5990 /** 5991 * @attribute syn 5992 * @aspect GenericBoundCheck 5993 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:80 5994 */ 5995 @ASTNodeAnnotation.Attribute 5996 public boolean boundOfWildcard(WildcardType type) { 5997 boolean boundOfWildcard_WildcardType_value = false; 5998 5999 return boundOfWildcard_WildcardType_value; 6000 } 6001 /** 6002 * @attribute syn 6003 * @aspect GenericBoundCheck 6004 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:83 6005 */ 6006 @ASTNodeAnnotation.Attribute 6007 public boolean boundOfWildcardExtends(WildcardExtendsType type) { 6008 boolean boundOfWildcardExtends_WildcardExtendsType_value = false; 6009 6010 return boundOfWildcardExtends_WildcardExtendsType_value; 6011 } 6012 /** 6013 * @attribute syn 6014 * @aspect GenericBoundCheck 6015 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:87 6016 */ 6017 @ASTNodeAnnotation.Attribute 6018 public boolean boundOfWildcardSuper(WildcardSuperType type) { 6019 boolean boundOfWildcardSuper_WildcardSuperType_value = false; 6020 6021 return boundOfWildcardSuper_WildcardSuperType_value; 6022 } 6023 /** 6024 * @attribute syn 6025 * @aspect GenericMethodsInference 6026 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:34 6027 */ 6028 @ASTNodeAnnotation.Attribute 6029 public boolean isUnboxedPrimitive() { 6030 boolean isUnboxedPrimitive_value = this instanceof PrimitiveType && isPrimitive(); 6031 6032 return isUnboxedPrimitive_value; 6033 } 6034 /** 6035 * @apilevel internal 6036 */ 6037 protected int involvesTypeParameters_visited = -1; 6038 /** 6039 * @apilevel internal 6040 */ 6041 private void involvesTypeParameters_reset() { 6042 involvesTypeParameters_computed = false; 6043 involvesTypeParameters_initialized = false; 6044 involvesTypeParameters_visited = -1; 6045 } 6046 /** 6047 * @apilevel internal 6048 */ 6049 protected boolean involvesTypeParameters_computed = false; 6050 /** 6051 * @apilevel internal 6052 */ 6053 protected boolean involvesTypeParameters_initialized = false; 6054 /** 6055 * @apilevel internal 6056 */ 6057 protected boolean involvesTypeParameters_value; 6058 @ASTNodeAnnotation.Attribute 6059 public boolean involvesTypeParameters() { 6060 if (involvesTypeParameters_computed) { 6061 return involvesTypeParameters_value; 6062 } 6063 ASTNode$State state = state(); 6064 boolean new_involvesTypeParameters_value; 6065 if (!involvesTypeParameters_initialized) { 6066 involvesTypeParameters_initialized = true; 6067 involvesTypeParameters_value = false; 6068 } 6069 if (!state.IN_CIRCLE) { 6070 state.IN_CIRCLE = true; 6071 int num = state.boundariesCrossed; 6072 boolean isFinal = this.is$Final(); 6073 do { 6074 involvesTypeParameters_visited = state.CIRCLE_INDEX; 6075 state.CHANGE = false; 6076 new_involvesTypeParameters_value = false; 6077 if (new_involvesTypeParameters_value != involvesTypeParameters_value) { 6078 state.CHANGE = true; 6079 } 6080 involvesTypeParameters_value = new_involvesTypeParameters_value; 6081 state.CIRCLE_INDEX++; 6082 } while (state.CHANGE); 6083 if (isFinal && num == state().boundariesCrossed) { 6084 involvesTypeParameters_computed = true; 6085 } else { 6086 state.RESET_CYCLE = true; 6087 boolean $tmp = false; 6088 state.RESET_CYCLE = false; 6089 involvesTypeParameters_computed = false; 6090 involvesTypeParameters_initialized = false; 6091 } 6092 state.IN_CIRCLE = false; 6093 state.INTERMEDIATE_VALUE = false; 6094 return involvesTypeParameters_value; 6095 } 6096 if (involvesTypeParameters_visited != state.CIRCLE_INDEX) { 6097 involvesTypeParameters_visited = state.CIRCLE_INDEX; 6098 if (state.RESET_CYCLE) { 6099 involvesTypeParameters_computed = false; 6100 involvesTypeParameters_initialized = false; 6101 involvesTypeParameters_visited = -1; 6102 return involvesTypeParameters_value; 6103 } 6104 new_involvesTypeParameters_value = false; 6105 if (new_involvesTypeParameters_value != involvesTypeParameters_value) { 6106 state.CHANGE = true; 6107 } 6108 involvesTypeParameters_value = new_involvesTypeParameters_value; 6109 state.INTERMEDIATE_VALUE = true; 6110 return involvesTypeParameters_value; 6111 } 6112 state.INTERMEDIATE_VALUE = true; 6113 return involvesTypeParameters_value; 6114 } 6115 /** 6116 * @attribute syn 6117 * @aspect Generics 6118 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:221 6119 */ 6120 @ASTNodeAnnotation.Attribute 6121 public boolean isGenericType() { 6122 boolean isGenericType_value = false; 6123 6124 return isGenericType_value; 6125 } 6126 /** 6127 * @attribute syn 6128 * @aspect Generics 6129 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:316 6130 */ 6131 @ASTNodeAnnotation.Attribute 6132 public boolean isParameterizedType() { 6133 boolean isParameterizedType_value = false; 6134 6135 return isParameterizedType_value; 6136 } 6137 /** 6138 * @attribute syn 6139 * @aspect Generics 6140 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:319 6141 */ 6142 @ASTNodeAnnotation.Attribute 6143 public boolean isRawType() { 6144 boolean isRawType_value = isNestedType() && enclosingType().isRawType(); 6145 6146 return isRawType_value; 6147 } 6148 /** 6149 * @apilevel internal 6150 */ 6151 protected boolean erasure_computed = false; 6152 /** 6153 * @apilevel internal 6154 */ 6155 protected TypeDecl erasure_value; 6156 /** 6157 * @apilevel internal 6158 */ 6159 private void erasure_reset() { 6160 erasure_computed = false; 6161 erasure_value = null; 6162 } 6163 /** 6164 * @attribute syn 6165 * @aspect GenericsErasure 6166 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:422 6167 */ 6168 @ASTNodeAnnotation.Attribute 6169 public TypeDecl erasure() { 6170 ASTNode$State state = state(); 6171 if (erasure_computed) { 6172 return erasure_value; 6173 } 6174 boolean intermediate = state.INTERMEDIATE_VALUE; 6175 state.INTERMEDIATE_VALUE = false; 6176 int num = state.boundariesCrossed; 6177 boolean isFinal = this.is$Final(); 6178 erasure_value = erasure_compute(); 6179 if (isFinal && num == state().boundariesCrossed) { 6180 erasure_computed = true; 6181 } else { 6182 } 6183 state.INTERMEDIATE_VALUE |= intermediate; 6184 6185 return erasure_value; 6186 } 6187 /** 6188 * @apilevel internal 6189 */ 6190 private TypeDecl erasure_compute() { 6191 if (isAnonymous() || isLocalClass()) { 6192 return this; 6193 } 6194 if (!isNestedType()) { 6195 return this; 6196 } 6197 return extractSingleType(enclosingType().erasure().memberTypes(name())); 6198 } 6199 /** 6200 * @apilevel internal 6201 */ 6202 protected boolean erasedAncestorMethodsMap_computed = false; 6203 /** 6204 * @apilevel internal 6205 */ 6206 protected Map<String,SimpleSet> erasedAncestorMethodsMap_value; 6207 /** 6208 * @apilevel internal 6209 */ 6210 private void erasedAncestorMethodsMap_reset() { 6211 erasedAncestorMethodsMap_computed = false; 6212 erasedAncestorMethodsMap_value = null; 6213 } 6214 /** 6215 * @attribute syn 6216 * @aspect GenericsTypeCheck 6217 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:496 6218 */ 6219 @ASTNodeAnnotation.Attribute 6220 public Map<String,SimpleSet> erasedAncestorMethodsMap() { 6221 ASTNode$State state = state(); 6222 if (erasedAncestorMethodsMap_computed) { 6223 return erasedAncestorMethodsMap_value; 6224 } 6225 boolean intermediate = state.INTERMEDIATE_VALUE; 6226 state.INTERMEDIATE_VALUE = false; 6227 int num = state.boundariesCrossed; 6228 boolean isFinal = this.is$Final(); 6229 erasedAncestorMethodsMap_value = original().localMethodsSignatureMap(); 6230 if (isFinal && num == state().boundariesCrossed) { 6231 erasedAncestorMethodsMap_computed = true; 6232 } else { 6233 } 6234 state.INTERMEDIATE_VALUE |= intermediate; 6235 6236 return erasedAncestorMethodsMap_value; 6237 } 6238 /** 6239 * @apilevel internal 6240 */ 6241 protected boolean implementedInterfaces_computed = false; 6242 /** 6243 * @apilevel internal 6244 */ 6245 protected HashSet<InterfaceDecl> implementedInterfaces_value; 6246 /** 6247 * @apilevel internal 6248 */ 6249 private void implementedInterfaces_reset() { 6250 implementedInterfaces_computed = false; 6251 implementedInterfaces_value = null; 6252 } 6253 /** 6254 * @attribute syn 6255 * @aspect GenericsTypeCheck 6256 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:614 6257 */ 6258 @ASTNodeAnnotation.Attribute 6259 public HashSet<InterfaceDecl> implementedInterfaces() { 6260 ASTNode$State state = state(); 6261 if (implementedInterfaces_computed) { 6262 return implementedInterfaces_value; 6263 } 6264 boolean intermediate = state.INTERMEDIATE_VALUE; 6265 state.INTERMEDIATE_VALUE = false; 6266 int num = state.boundariesCrossed; 6267 boolean isFinal = this.is$Final(); 6268 implementedInterfaces_value = new HashSet<InterfaceDecl>(); 6269 if (isFinal && num == state().boundariesCrossed) { 6270 implementedInterfaces_computed = true; 6271 } else { 6272 } 6273 state.INTERMEDIATE_VALUE |= intermediate; 6274 6275 return implementedInterfaces_value; 6276 } 6277 /** 6278 * @attribute syn 6279 * @aspect LookupParTypeDecl 6280 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:806 6281 */ 6282 @ASTNodeAnnotation.Attribute 6283 public boolean sameSignature(Access a) { 6284 { 6285 if (a instanceof ParTypeAccess) { 6286 return false; 6287 } 6288 if (a instanceof AbstractWildcard) { 6289 return false; 6290 } 6291 return this == a.type(); 6292 } 6293 } 6294 /** 6295 * @apilevel internal 6296 */ 6297 protected int usesTypeVariable_visited = -1; 6298 /** 6299 * @apilevel internal 6300 */ 6301 private void usesTypeVariable_reset() { 6302 usesTypeVariable_computed = false; 6303 usesTypeVariable_initialized = false; 6304 usesTypeVariable_visited = -1; 6305 } 6306 /** 6307 * @apilevel internal 6308 */ 6309 protected boolean usesTypeVariable_computed = false; 6310 /** 6311 * @apilevel internal 6312 */ 6313 protected boolean usesTypeVariable_initialized = false; 6314 /** 6315 * @apilevel internal 6316 */ 6317 protected boolean usesTypeVariable_value; 6318 @ASTNodeAnnotation.Attribute 6319 public boolean usesTypeVariable() { 6320 if (usesTypeVariable_computed) { 6321 return usesTypeVariable_value; 6322 } 6323 ASTNode$State state = state(); 6324 boolean new_usesTypeVariable_value; 6325 if (!usesTypeVariable_initialized) { 6326 usesTypeVariable_initialized = true; 6327 usesTypeVariable_value = false; 6328 } 6329 if (!state.IN_CIRCLE) { 6330 state.IN_CIRCLE = true; 6331 int num = state.boundariesCrossed; 6332 boolean isFinal = this.is$Final(); 6333 do { 6334 usesTypeVariable_visited = state.CIRCLE_INDEX; 6335 state.CHANGE = false; 6336 new_usesTypeVariable_value = isNestedType() && enclosingType().usesTypeVariable(); 6337 if (new_usesTypeVariable_value != usesTypeVariable_value) { 6338 state.CHANGE = true; 6339 } 6340 usesTypeVariable_value = new_usesTypeVariable_value; 6341 state.CIRCLE_INDEX++; 6342 } while (state.CHANGE); 6343 if (isFinal && num == state().boundariesCrossed) { 6344 usesTypeVariable_computed = true; 6345 } else { 6346 state.RESET_CYCLE = true; 6347 boolean $tmp = isNestedType() && enclosingType().usesTypeVariable(); 6348 state.RESET_CYCLE = false; 6349 usesTypeVariable_computed = false; 6350 usesTypeVariable_initialized = false; 6351 } 6352 state.IN_CIRCLE = false; 6353 state.INTERMEDIATE_VALUE = false; 6354 return usesTypeVariable_value; 6355 } 6356 if (usesTypeVariable_visited != state.CIRCLE_INDEX) { 6357 usesTypeVariable_visited = state.CIRCLE_INDEX; 6358 if (state.RESET_CYCLE) { 6359 usesTypeVariable_computed = false; 6360 usesTypeVariable_initialized = false; 6361 usesTypeVariable_visited = -1; 6362 return usesTypeVariable_value; 6363 } 6364 new_usesTypeVariable_value = isNestedType() && enclosingType().usesTypeVariable(); 6365 if (new_usesTypeVariable_value != usesTypeVariable_value) { 6366 state.CHANGE = true; 6367 } 6368 usesTypeVariable_value = new_usesTypeVariable_value; 6369 state.INTERMEDIATE_VALUE = true; 6370 return usesTypeVariable_value; 6371 } 6372 state.INTERMEDIATE_VALUE = true; 6373 return usesTypeVariable_value; 6374 } 6375 /** 6376 * @attribute syn 6377 * @aspect LookupParTypeDecl 6378 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1417 6379 */ 6380 @ASTNodeAnnotation.Attribute 6381 public TypeDecl original() { 6382 TypeDecl original_value = this; 6383 6384 return original_value; 6385 } 6386 /** 6387 * @attribute syn 6388 * @aspect LookupParTypeDecl 6389 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1504 6390 */ 6391 @ASTNodeAnnotation.Attribute 6392 public TypeDecl asWildcardExtends() { 6393 TypeDecl asWildcardExtends_value = lookupWildcardExtends(this); 6394 6395 return asWildcardExtends_value; 6396 } 6397 /** 6398 * @attribute syn 6399 * @aspect LookupParTypeDecl 6400 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1518 6401 */ 6402 @ASTNodeAnnotation.Attribute 6403 public TypeDecl asWildcardSuper() { 6404 TypeDecl asWildcardSuper_value = lookupWildcardSuper(this); 6405 6406 return asWildcardSuper_value; 6407 } 6408 /** 6409 * @apilevel internal 6410 */ 6411 protected boolean sourceTypeDecl_computed = false; 6412 /** 6413 * @apilevel internal 6414 */ 6415 protected TypeDecl sourceTypeDecl_value; 6416 /** 6417 * @apilevel internal 6418 */ 6419 private void sourceTypeDecl_reset() { 6420 sourceTypeDecl_computed = false; 6421 sourceTypeDecl_value = null; 6422 } 6423 /** 6424 * @attribute syn 6425 * @aspect SourceDeclarations 6426 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1618 6427 */ 6428 @ASTNodeAnnotation.Attribute 6429 public TypeDecl sourceTypeDecl() { 6430 ASTNode$State state = state(); 6431 if (sourceTypeDecl_computed) { 6432 return sourceTypeDecl_value; 6433 } 6434 boolean intermediate = state.INTERMEDIATE_VALUE; 6435 state.INTERMEDIATE_VALUE = false; 6436 int num = state.boundariesCrossed; 6437 boolean isFinal = this.is$Final(); 6438 sourceTypeDecl_value = this; 6439 if (isFinal && num == state().boundariesCrossed) { 6440 sourceTypeDecl_computed = true; 6441 } else { 6442 } 6443 state.INTERMEDIATE_VALUE |= intermediate; 6444 6445 return sourceTypeDecl_value; 6446 } 6447 /** 6448 * @attribute syn 6449 * @aspect GenericsParTypeDecl 6450 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:96 6451 */ 6452 @ASTNodeAnnotation.Attribute 6453 public boolean isTypeVariable() { 6454 boolean isTypeVariable_value = false; 6455 6456 return isTypeVariable_value; 6457 } 6458 /** 6459 * @attribute syn 6460 * @aspect GenericsSubtype 6461 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:35 6462 */ 6463 @ASTNodeAnnotation.Attribute 6464 public boolean supertypeGenericClassDecl(GenericClassDecl type) { 6465 boolean supertypeGenericClassDecl_GenericClassDecl_value = supertypeClassDecl(type); 6466 6467 return supertypeGenericClassDecl_GenericClassDecl_value; 6468 } 6469 /** 6470 * @attribute syn 6471 * @aspect GenericsSubtype 6472 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:40 6473 */ 6474 @ASTNodeAnnotation.Attribute 6475 public boolean supertypeGenericInterfaceDecl(GenericInterfaceDecl type) { 6476 boolean supertypeGenericInterfaceDecl_GenericInterfaceDecl_value = this == type || supertypeInterfaceDecl(type); 6477 6478 return supertypeGenericInterfaceDecl_GenericInterfaceDecl_value; 6479 } 6480 /** 6481 * @attribute syn 6482 * @aspect GenericsSubtype 6483 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:46 6484 */ 6485 @ASTNodeAnnotation.Attribute 6486 public boolean supertypeRawClassDecl(RawClassDecl type) { 6487 boolean supertypeRawClassDecl_RawClassDecl_value = supertypeParClassDecl(type); 6488 6489 return supertypeRawClassDecl_RawClassDecl_value; 6490 } 6491 /** 6492 * @attribute syn 6493 * @aspect GenericsSubtype 6494 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:50 6495 */ 6496 @ASTNodeAnnotation.Attribute 6497 public boolean supertypeRawInterfaceDecl(RawInterfaceDecl type) { 6498 boolean supertypeRawInterfaceDecl_RawInterfaceDecl_value = supertypeParInterfaceDecl(type); 6499 6500 return supertypeRawInterfaceDecl_RawInterfaceDecl_value; 6501 } 6502 /** 6503 * @attribute syn 6504 * @aspect GenericsSubtype 6505 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:66 6506 */ 6507 @ASTNodeAnnotation.Attribute 6508 public boolean supertypeWildcard(WildcardType type) { 6509 boolean supertypeWildcard_WildcardType_value = false; 6510 6511 return supertypeWildcard_WildcardType_value; 6512 } 6513 /** 6514 * @attribute syn 6515 * @aspect GenericsSubtype 6516 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:73 6517 */ 6518 @ASTNodeAnnotation.Attribute 6519 public boolean supertypeWildcardExtends(WildcardExtendsType type) { 6520 boolean supertypeWildcardExtends_WildcardExtendsType_value = false; 6521 6522 return supertypeWildcardExtends_WildcardExtendsType_value; 6523 } 6524 /** 6525 * @attribute syn 6526 * @aspect GenericsSubtype 6527 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:81 6528 */ 6529 @ASTNodeAnnotation.Attribute 6530 public boolean supertypeWildcardSuper(WildcardSuperType type) { 6531 boolean supertypeWildcardSuper_WildcardSuperType_value = false; 6532 6533 return supertypeWildcardSuper_WildcardSuperType_value; 6534 } 6535 /** 6536 * @attribute syn 6537 * @aspect GenericsSubtype 6538 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:115 6539 */ 6540 @ASTNodeAnnotation.Attribute 6541 public boolean isWildcard() { 6542 boolean isWildcard_value = false; 6543 6544 return isWildcard_value; 6545 } 6546 /** 6547 * @attribute syn 6548 * @aspect GenericsSubtype 6549 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:134 6550 */ 6551 @ASTNodeAnnotation.Attribute 6552 public boolean supertypeParClassDecl(ParClassDecl type) { 6553 boolean supertypeParClassDecl_ParClassDecl_value = supertypeClassDecl(type); 6554 6555 return supertypeParClassDecl_ParClassDecl_value; 6556 } 6557 /** 6558 * @attribute syn 6559 * @aspect GenericsSubtype 6560 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:137 6561 */ 6562 @ASTNodeAnnotation.Attribute 6563 public boolean supertypeParInterfaceDecl(ParInterfaceDecl type) { 6564 boolean supertypeParInterfaceDecl_ParInterfaceDecl_value = supertypeInterfaceDecl(type); 6565 6566 return supertypeParInterfaceDecl_ParInterfaceDecl_value; 6567 } 6568 /** 6569 * @apilevel internal 6570 */ 6571 private void containedIn_TypeDecl_reset() { 6572 containedIn_TypeDecl_values = null; 6573 } 6574 protected java.util.Map containedIn_TypeDecl_values; 6575 @ASTNodeAnnotation.Attribute 6576 public boolean containedIn(TypeDecl type) { 6577 Object _parameters = type; 6578 if (containedIn_TypeDecl_values == null) containedIn_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 6579 ASTNode$State.CircularValue _value; 6580 if (containedIn_TypeDecl_values.containsKey(_parameters)) { 6581 Object _o = containedIn_TypeDecl_values.get(_parameters); 6582 if (!(_o instanceof ASTNode$State.CircularValue)) { 6583 return (Boolean) _o; 6584 } else { 6585 _value = (ASTNode$State.CircularValue) _o; 6586 } 6587 } else { 6588 _value = new ASTNode$State.CircularValue(); 6589 containedIn_TypeDecl_values.put(_parameters, _value); 6590 _value.value = true; 6591 } 6592 ASTNode$State state = state(); 6593 boolean new_containedIn_TypeDecl_value; 6594 if (!state.IN_CIRCLE) { 6595 state.IN_CIRCLE = true; 6596 int num = state.boundariesCrossed; 6597 boolean isFinal = this.is$Final(); 6598 // TODO: fixme 6599 // state().CIRCLE_INDEX = 1; 6600 do { 6601 _value.visited = state.CIRCLE_INDEX; 6602 state.CHANGE = false; 6603 new_containedIn_TypeDecl_value = containedIn_compute(type); 6604 if (new_containedIn_TypeDecl_value != ((Boolean)_value.value)) { 6605 state.CHANGE = true; 6606 _value.value = new_containedIn_TypeDecl_value; 6607 } 6608 state.CIRCLE_INDEX++; 6609 } while (state.CHANGE); 6610 if (isFinal && num == state().boundariesCrossed) { 6611 containedIn_TypeDecl_values.put(_parameters, new_containedIn_TypeDecl_value); 6612 } else { 6613 containedIn_TypeDecl_values.remove(_parameters); 6614 state.RESET_CYCLE = true; 6615 boolean $tmp = containedIn_compute(type); 6616 state.RESET_CYCLE = false; 6617 } 6618 state.IN_CIRCLE = false; 6619 state.INTERMEDIATE_VALUE = false; 6620 return new_containedIn_TypeDecl_value; 6621 } 6622 if (state.CIRCLE_INDEX != _value.visited) { 6623 _value.visited = state.CIRCLE_INDEX; 6624 new_containedIn_TypeDecl_value = containedIn_compute(type); 6625 if (state.RESET_CYCLE) { 6626 containedIn_TypeDecl_values.remove(_parameters); 6627 } 6628 else if (new_containedIn_TypeDecl_value != ((Boolean)_value.value)) { 6629 state.CHANGE = true; 6630 _value.value = new_containedIn_TypeDecl_value; 6631 } 6632 state.INTERMEDIATE_VALUE = true; 6633 return new_containedIn_TypeDecl_value; 6634 } 6635 state.INTERMEDIATE_VALUE = true; 6636 return (Boolean) _value.value; 6637 } 6638 /** 6639 * @apilevel internal 6640 */ 6641 private boolean containedIn_compute(TypeDecl type) { 6642 if (type == this || type instanceof WildcardType) { 6643 return true; 6644 } else if (type instanceof WildcardExtendsType) { 6645 return this.subtype(((WildcardExtendsType) type).extendsType()); 6646 } else if (type instanceof WildcardSuperType) { 6647 return ((WildcardSuperType) type).superType().subtype(this); 6648 } else if (type instanceof TypeVariable) { 6649 return subtype(type); 6650 } 6651 return sameStructure(type); 6652 //return false; 6653 } 6654 /** 6655 * @apilevel internal 6656 */ 6657 private void sameStructure_TypeDecl_reset() { 6658 sameStructure_TypeDecl_values = null; 6659 } 6660 protected java.util.Map sameStructure_TypeDecl_values; 6661 @ASTNodeAnnotation.Attribute 6662 public boolean sameStructure(TypeDecl t) { 6663 Object _parameters = t; 6664 if (sameStructure_TypeDecl_values == null) sameStructure_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 6665 ASTNode$State.CircularValue _value; 6666 if (sameStructure_TypeDecl_values.containsKey(_parameters)) { 6667 Object _o = sameStructure_TypeDecl_values.get(_parameters); 6668 if (!(_o instanceof ASTNode$State.CircularValue)) { 6669 return (Boolean) _o; 6670 } else { 6671 _value = (ASTNode$State.CircularValue) _o; 6672 } 6673 } else { 6674 _value = new ASTNode$State.CircularValue(); 6675 sameStructure_TypeDecl_values.put(_parameters, _value); 6676 _value.value = true; 6677 } 6678 ASTNode$State state = state(); 6679 boolean new_sameStructure_TypeDecl_value; 6680 if (!state.IN_CIRCLE) { 6681 state.IN_CIRCLE = true; 6682 int num = state.boundariesCrossed; 6683 boolean isFinal = this.is$Final(); 6684 // TODO: fixme 6685 // state().CIRCLE_INDEX = 1; 6686 do { 6687 _value.visited = state.CIRCLE_INDEX; 6688 state.CHANGE = false; 6689 new_sameStructure_TypeDecl_value = t == this; 6690 if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) { 6691 state.CHANGE = true; 6692 _value.value = new_sameStructure_TypeDecl_value; 6693 } 6694 state.CIRCLE_INDEX++; 6695 } while (state.CHANGE); 6696 if (isFinal && num == state().boundariesCrossed) { 6697 sameStructure_TypeDecl_values.put(_parameters, new_sameStructure_TypeDecl_value); 6698 } else { 6699 sameStructure_TypeDecl_values.remove(_parameters); 6700 state.RESET_CYCLE = true; 6701 boolean $tmp = t == this; 6702 state.RESET_CYCLE = false; 6703 } 6704 state.IN_CIRCLE = false; 6705 state.INTERMEDIATE_VALUE = false; 6706 return new_sameStructure_TypeDecl_value; 6707 } 6708 if (state.CIRCLE_INDEX != _value.visited) { 6709 _value.visited = state.CIRCLE_INDEX; 6710 new_sameStructure_TypeDecl_value = t == this; 6711 if (state.RESET_CYCLE) { 6712 sameStructure_TypeDecl_values.remove(_parameters); 6713 } 6714 else if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) { 6715 state.CHANGE = true; 6716 _value.value = new_sameStructure_TypeDecl_value; 6717 } 6718 state.INTERMEDIATE_VALUE = true; 6719 return new_sameStructure_TypeDecl_value; 6720 } 6721 state.INTERMEDIATE_VALUE = true; 6722 return (Boolean) _value.value; 6723 } 6724 /** 6725 * @attribute syn 6726 * @aspect GenericsSubtype 6727 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:321 6728 */ 6729 @ASTNodeAnnotation.Attribute 6730 public boolean supertypeTypeVariable(TypeVariable type) { 6731 { 6732 if (type == this) { 6733 return true; 6734 } 6735 for (int i = 0; i < type.getNumTypeBound(); i++) 6736 if (type.getTypeBound(i).type().subtype(this)) { 6737 return true; 6738 } 6739 return false; 6740 } 6741 } 6742 /** 6743 * @attribute syn 6744 * @aspect GenericsSubtype 6745 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:376 6746 */ 6747 @ASTNodeAnnotation.Attribute 6748 public boolean supertypeLUBType(LUBType type) { 6749 { 6750 for (int i = 0; i < type.getNumTypeBound(); i++) 6751 if (!type.getTypeBound(i).type().subtype(this)) { 6752 return false; 6753 } 6754 return true; 6755 } 6756 } 6757 /** 6758 * @attribute syn 6759 * @aspect GenericsSubtype 6760 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:394 6761 */ 6762 @ASTNodeAnnotation.Attribute 6763 public boolean supertypeGLBType(GLBType type) { 6764 { 6765 // T1 && .. && Tn <: this, if exists 0 < i <= n Ti <: this 6766 for (int i = 0; i < type.getNumTypeBound(); i++) 6767 if (type.getTypeBound(i).type().subtype(this)) { 6768 return true; 6769 } 6770 return false; 6771 } 6772 } 6773 /** 6774 * @apilevel internal 6775 */ 6776 private void subtype_TypeDecl_reset() { 6777 subtype_TypeDecl_values = null; 6778 } 6779 protected java.util.Map subtype_TypeDecl_values; 6780 @ASTNodeAnnotation.Attribute 6781 public boolean subtype(TypeDecl type) { 6782 Object _parameters = type; 6783 if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 6784 ASTNode$State.CircularValue _value; 6785 if (subtype_TypeDecl_values.containsKey(_parameters)) { 6786 Object _o = subtype_TypeDecl_values.get(_parameters); 6787 if (!(_o instanceof ASTNode$State.CircularValue)) { 6788 return (Boolean) _o; 6789 } else { 6790 _value = (ASTNode$State.CircularValue) _o; 6791 } 6792 } else { 6793 _value = new ASTNode$State.CircularValue(); 6794 subtype_TypeDecl_values.put(_parameters, _value); 6795 _value.value = true; 6796 } 6797 ASTNode$State state = state(); 6798 boolean new_subtype_TypeDecl_value; 6799 if (!state.IN_CIRCLE) { 6800 state.IN_CIRCLE = true; 6801 int num = state.boundariesCrossed; 6802 boolean isFinal = this.is$Final(); 6803 // TODO: fixme 6804 // state().CIRCLE_INDEX = 1; 6805 do { 6806 _value.visited = state.CIRCLE_INDEX; 6807 state.CHANGE = false; 6808 new_subtype_TypeDecl_value = type == this; 6809 if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 6810 state.CHANGE = true; 6811 _value.value = new_subtype_TypeDecl_value; 6812 } 6813 state.CIRCLE_INDEX++; 6814 } while (state.CHANGE); 6815 if (isFinal && num == state().boundariesCrossed) { 6816 subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value); 6817 } else { 6818 subtype_TypeDecl_values.remove(_parameters); 6819 state.RESET_CYCLE = true; 6820 boolean $tmp = type == this; 6821 state.RESET_CYCLE = false; 6822 } 6823 state.IN_CIRCLE = false; 6824 state.INTERMEDIATE_VALUE = false; 6825 return new_subtype_TypeDecl_value; 6826 } 6827 if (state.CIRCLE_INDEX != _value.visited) { 6828 _value.visited = state.CIRCLE_INDEX; 6829 new_subtype_TypeDecl_value = type == this; 6830 if (state.RESET_CYCLE) { 6831 subtype_TypeDecl_values.remove(_parameters); 6832 } 6833 else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 6834 state.CHANGE = true; 6835 _value.value = new_subtype_TypeDecl_value; 6836 } 6837 state.INTERMEDIATE_VALUE = true; 6838 return new_subtype_TypeDecl_value; 6839 } 6840 state.INTERMEDIATE_VALUE = true; 6841 return (Boolean) _value.value; 6842 } 6843 /** 6844 * @attribute syn 6845 * @aspect GenericsSubtype 6846 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:448 6847 */ 6848 @ASTNodeAnnotation.Attribute 6849 public boolean supertypeClassDecl(ClassDecl type) { 6850 boolean supertypeClassDecl_ClassDecl_value = type == this; 6851 6852 return supertypeClassDecl_ClassDecl_value; 6853 } 6854 /** 6855 * @attribute syn 6856 * @aspect GenericsSubtype 6857 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:465 6858 */ 6859 @ASTNodeAnnotation.Attribute 6860 public boolean supertypeInterfaceDecl(InterfaceDecl type) { 6861 boolean supertypeInterfaceDecl_InterfaceDecl_value = type == this; 6862 6863 return supertypeInterfaceDecl_InterfaceDecl_value; 6864 } 6865 /** 6866 * @attribute syn 6867 * @aspect GenericsSubtype 6868 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:480 6869 */ 6870 @ASTNodeAnnotation.Attribute 6871 public boolean supertypeArrayDecl(ArrayDecl type) { 6872 boolean supertypeArrayDecl_ArrayDecl_value = this == type; 6873 6874 return supertypeArrayDecl_ArrayDecl_value; 6875 } 6876 /** 6877 * @attribute syn 6878 * @aspect GenericsSubtype 6879 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:506 6880 */ 6881 @ASTNodeAnnotation.Attribute 6882 public boolean supertypePrimitiveType(PrimitiveType type) { 6883 boolean supertypePrimitiveType_PrimitiveType_value = type == this; 6884 6885 return supertypePrimitiveType_PrimitiveType_value; 6886 } 6887 /** 6888 * @attribute syn 6889 * @aspect GenericsSubtype 6890 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:514 6891 */ 6892 @ASTNodeAnnotation.Attribute 6893 public boolean supertypeNullType(NullType type) { 6894 boolean supertypeNullType_NullType_value = false; 6895 6896 return supertypeNullType_NullType_value; 6897 } 6898 /** 6899 * @attribute syn 6900 * @aspect GenericsSubtype 6901 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:518 6902 */ 6903 @ASTNodeAnnotation.Attribute 6904 public boolean supertypeVoidType(VoidType type) { 6905 boolean supertypeVoidType_VoidType_value = false; 6906 6907 return supertypeVoidType_VoidType_value; 6908 } 6909 /** 6910 * @attribute syn 6911 * @aspect GenericsSubtype 6912 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:527 6913 */ 6914 @ASTNodeAnnotation.Attribute 6915 public boolean supertypeClassDeclSubstituted(ClassDeclSubstituted type) { 6916 boolean supertypeClassDeclSubstituted_ClassDeclSubstituted_value = type.original() == this || supertypeClassDecl(type); 6917 6918 return supertypeClassDeclSubstituted_ClassDeclSubstituted_value; 6919 } 6920 /** 6921 * @attribute syn 6922 * @aspect GenericsSubtype 6923 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:538 6924 */ 6925 @ASTNodeAnnotation.Attribute 6926 public boolean supertypeInterfaceDeclSubstituted(InterfaceDeclSubstituted type) { 6927 boolean supertypeInterfaceDeclSubstituted_InterfaceDeclSubstituted_value = type.original() == this || supertypeInterfaceDecl(type); 6928 6929 return supertypeInterfaceDeclSubstituted_InterfaceDeclSubstituted_value; 6930 } 6931 /** 6932 * @attribute syn 6933 * @aspect GenericsSubtype 6934 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:548 6935 */ 6936 @ASTNodeAnnotation.Attribute 6937 public boolean supertypeGenericClassDeclSubstituted(GenericClassDeclSubstituted type) { 6938 boolean supertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value = type.original() == this || supertypeGenericClassDecl(type); 6939 6940 return supertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value; 6941 } 6942 /** 6943 * @attribute syn 6944 * @aspect GenericsSubtype 6945 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:559 6946 */ 6947 @ASTNodeAnnotation.Attribute 6948 public boolean supertypeGenericInterfaceDeclSubstituted(GenericInterfaceDeclSubstituted type) { 6949 boolean supertypeGenericInterfaceDeclSubstituted_GenericInterfaceDeclSubstituted_value = type.original() == this || supertypeGenericInterfaceDecl(type); 6950 6951 return supertypeGenericInterfaceDeclSubstituted_GenericInterfaceDeclSubstituted_value; 6952 } 6953 /** 6954 * A type is reifiable if it either refers to a non-parameterized type, 6955 * is a raw type, is a parameterized type with only unbound wildcard 6956 * parameters or is an array type with a reifiable type parameter. 6957 * 6958 * @see "JLS SE7 §4.7" 6959 * @attribute syn 6960 * @aspect ReifiableTypes 6961 * @declaredat /home/jesper/git/extendj/java5/frontend/ReifiableTypes.jrag:39 6962 */ 6963 @ASTNodeAnnotation.Attribute 6964 public boolean isReifiable() { 6965 boolean isReifiable_value = true; 6966 6967 return isReifiable_value; 6968 } 6969 /** 6970 * @apilevel internal 6971 */ 6972 protected java.util.Map createEnumMethod_TypeDecl_values; 6973 /** 6974 * @apilevel internal 6975 */ 6976 private void createEnumMethod_TypeDecl_reset() { 6977 createEnumMethod_TypeDecl_values = null; 6978 } 6979 /** 6980 * @attribute syn 6981 * @aspect EnumsCodegen 6982 * @declaredat /home/jesper/git/extendj/java5/backend/EnumsCodegen.jrag:63 6983 */ 6984 @ASTNodeAnnotation.Attribute 6985 public MethodDecl createEnumMethod(TypeDecl enumDecl) { 6986 Object _parameters = enumDecl; 6987 if (createEnumMethod_TypeDecl_values == null) createEnumMethod_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 6988 ASTNode$State state = state(); 6989 if (createEnumMethod_TypeDecl_values.containsKey(_parameters)) { 6990 return (MethodDecl) createEnumMethod_TypeDecl_values.get(_parameters); 6991 } 6992 boolean intermediate = state.INTERMEDIATE_VALUE; 6993 state.INTERMEDIATE_VALUE = false; 6994 int num = state.boundariesCrossed; 6995 boolean isFinal = this.is$Final(); 6996 MethodDecl createEnumMethod_TypeDecl_value = createEnumMethod_compute(enumDecl); 6997 if (isFinal && num == state().boundariesCrossed) { 6998 createEnumMethod_TypeDecl_values.put(_parameters, createEnumMethod_TypeDecl_value); 6999 } else { 7000 } 7001 state.INTERMEDIATE_VALUE |= intermediate; 7002 7003 return createEnumMethod_TypeDecl_value; 7004 } 7005 /** 7006 * @apilevel internal 7007 */ 7008 private MethodDecl createEnumMethod_compute(TypeDecl enumDecl) { 7009 MethodDecl m = new MethodDecl( 7010 new Modifiers(new List().add(new Modifier("static")).add(new Modifier("final")).add(new Modifier("private"))), 7011 typeInt().arrayType().createQualifiedAccess(), 7012 "$SwitchMap$" + enumDecl.fullName().replace('.', '$'), 7013 new List(), 7014 new List(), 7015 new Opt( 7016 new Block( 7017 new List().add( 7018 new IfStmt( 7019 new EQExpr( 7020 createEnumArray(enumDecl).createBoundFieldAccess(), 7021 new NullLiteral("null") 7022 ), 7023 AssignExpr.asStmt( 7024 createEnumArray(enumDecl).createBoundFieldAccess(), 7025 new ArrayCreationExpr( 7026 new ArrayTypeWithSizeAccess( 7027 typeInt().createQualifiedAccess(), 7028 enumDecl.createQualifiedAccess().qualifiesAccess( 7029 new MethodAccess("values", new List())).qualifiesAccess( 7030 new VarAccess("length")) 7031 ), 7032 new Opt() 7033 ) 7034 ), 7035 new Opt() 7036 ) 7037 ).add( 7038 new ReturnStmt( 7039 createEnumArray(enumDecl).createBoundFieldAccess() 7040 ) 7041 ) 7042 ) 7043 ) 7044 ); 7045 // add method declaration as a body declaration 7046 getBodyDeclList().insertChild(m, 1); 7047 // trigger possible rewrites 7048 return (MethodDecl) getBodyDeclList().getChild(1); 7049 } 7050 /** 7051 * @apilevel internal 7052 */ 7053 protected java.util.Map createEnumIndex_EnumConstant_values; 7054 /** 7055 * @apilevel internal 7056 */ 7057 private void createEnumIndex_EnumConstant_reset() { 7058 createEnumIndex_EnumConstant_values = null; 7059 } 7060 /** 7061 * @attribute syn 7062 * @aspect EnumsCodegen 7063 * @declaredat /home/jesper/git/extendj/java5/backend/EnumsCodegen.jrag:107 7064 */ 7065 @ASTNodeAnnotation.Attribute 7066 public int createEnumIndex(EnumConstant e) { 7067 Object _parameters = e; 7068 if (createEnumIndex_EnumConstant_values == null) createEnumIndex_EnumConstant_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 7069 ASTNode$State state = state(); 7070 if (createEnumIndex_EnumConstant_values.containsKey(_parameters)) { 7071 return (Integer) createEnumIndex_EnumConstant_values.get(_parameters); 7072 } 7073 boolean intermediate = state.INTERMEDIATE_VALUE; 7074 state.INTERMEDIATE_VALUE = false; 7075 int num = state.boundariesCrossed; 7076 boolean isFinal = this.is$Final(); 7077 int createEnumIndex_EnumConstant_value = createEnumIndex_compute(e); 7078 if (isFinal && num == state().boundariesCrossed) { 7079 createEnumIndex_EnumConstant_values.put(_parameters, createEnumIndex_EnumConstant_value); 7080 } else { 7081 } 7082 state.INTERMEDIATE_VALUE |= intermediate; 7083 7084 return createEnumIndex_EnumConstant_value; 7085 } 7086 /** 7087 * @apilevel internal 7088 */ 7089 private int createEnumIndex_compute(EnumConstant e) { 7090 if (createEnumIndexMap == null) { 7091 createEnumIndexMap = new HashMap(); 7092 } 7093 if (!createEnumIndexMap.containsKey(e.hostType())) { 7094 createEnumIndexMap.put(e.hostType(), new Integer(0)); 7095 } 7096 Integer i = (Integer) createEnumIndexMap.get(e.hostType()); 7097 i = new Integer(i.intValue() + 1); 7098 createEnumIndexMap.put(e.hostType(), i); 7099 7100 MethodDecl m = createEnumMethod(e.hostType()); 7101 List list = m.getBlock().getStmtList(); 7102 list.insertChild( 7103 new TryStmt( 7104 new Block( 7105 new List().add( 7106 AssignExpr.asStmt( 7107 createEnumArray(e.hostType()).createBoundFieldAccess().qualifiesAccess( 7108 new ArrayAccess( 7109 e.createBoundFieldAccess().qualifiesAccess(new MethodAccess("ordinal", new List())) 7110 ) 7111 ), 7112 Literal.buildIntegerLiteral(i.intValue()) 7113 ) 7114 ) 7115 ), 7116 new List().add( 7117 new BasicCatch( 7118 new ParameterDeclaration( 7119 lookupType("java.lang", "NoSuchFieldError").createQualifiedAccess(), 7120 "e" 7121 ), 7122 new Block( 7123 new List() 7124 ) 7125 ) 7126 ), 7127 new Opt() 7128 ), 7129 list.getNumChild()-1 7130 ); 7131 return i.intValue(); 7132 } 7133 /** 7134 * @apilevel internal 7135 */ 7136 protected java.util.Map createEnumArray_TypeDecl_values; 7137 /** 7138 * @apilevel internal 7139 */ 7140 private void createEnumArray_TypeDecl_reset() { 7141 createEnumArray_TypeDecl_values = null; 7142 } 7143 /** 7144 * @attribute syn 7145 * @aspect EnumsCodegen 7146 * @declaredat /home/jesper/git/extendj/java5/backend/EnumsCodegen.jrag:152 7147 */ 7148 @ASTNodeAnnotation.Attribute 7149 public FieldDeclaration createEnumArray(TypeDecl enumDecl) { 7150 Object _parameters = enumDecl; 7151 if (createEnumArray_TypeDecl_values == null) createEnumArray_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 7152 ASTNode$State state = state(); 7153 if (createEnumArray_TypeDecl_values.containsKey(_parameters)) { 7154 return (FieldDeclaration) createEnumArray_TypeDecl_values.get(_parameters); 7155 } 7156 boolean intermediate = state.INTERMEDIATE_VALUE; 7157 state.INTERMEDIATE_VALUE = false; 7158 int num = state.boundariesCrossed; 7159 boolean isFinal = this.is$Final(); 7160 FieldDeclaration createEnumArray_TypeDecl_value = createEnumArray_compute(enumDecl); 7161 if (isFinal && num == state().boundariesCrossed) { 7162 createEnumArray_TypeDecl_values.put(_parameters, createEnumArray_TypeDecl_value); 7163 } else { 7164 } 7165 state.INTERMEDIATE_VALUE |= intermediate; 7166 7167 return createEnumArray_TypeDecl_value; 7168 } 7169 /** 7170 * @apilevel internal 7171 */ 7172 private FieldDeclaration createEnumArray_compute(TypeDecl enumDecl) { 7173 FieldDeclaration f = new FieldDeclaration( 7174 new Modifiers(new List().add(new Modifier("static")).add(new Modifier("final")).add(new Modifier("private"))), 7175 typeInt().arrayType().createQualifiedAccess(), 7176 "$SwitchMap$" + enumDecl.fullName().replace('.', '$'), 7177 new Opt() 7178 ); 7179 // add field declaration as a body declaration 7180 getBodyDeclList().insertChild(f, 0); 7181 // trigger possible rewrites 7182 return (FieldDeclaration) getBodyDeclList().getChild(0); 7183 } 7184 /** 7185 * @attribute syn 7186 * @aspect GenericsCodegen 7187 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:228 7188 */ 7189 @ASTNodeAnnotation.Attribute 7190 public SimpleSet bridgeCandidates(String signature) { 7191 SimpleSet bridgeCandidates_String_value = SimpleSet.emptySet; 7192 7193 return bridgeCandidates_String_value; 7194 } 7195 /** 7196 * @apilevel internal 7197 */ 7198 protected boolean needsSignatureAttribute_computed = false; 7199 /** 7200 * @apilevel internal 7201 */ 7202 protected boolean needsSignatureAttribute_value; 7203 /** 7204 * @apilevel internal 7205 */ 7206 private void needsSignatureAttribute_reset() { 7207 needsSignatureAttribute_computed = false; 7208 } 7209 /** 7210 * @attribute syn 7211 * @aspect GenericsCodegen 7212 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:345 7213 */ 7214 @ASTNodeAnnotation.Attribute 7215 public boolean needsSignatureAttribute() { 7216 ASTNode$State state = state(); 7217 if (needsSignatureAttribute_computed) { 7218 return needsSignatureAttribute_value; 7219 } 7220 boolean intermediate = state.INTERMEDIATE_VALUE; 7221 state.INTERMEDIATE_VALUE = false; 7222 int num = state.boundariesCrossed; 7223 boolean isFinal = this.is$Final(); 7224 needsSignatureAttribute_value = false; 7225 if (isFinal && num == state().boundariesCrossed) { 7226 needsSignatureAttribute_computed = true; 7227 } else { 7228 } 7229 state.INTERMEDIATE_VALUE |= intermediate; 7230 7231 return needsSignatureAttribute_value; 7232 } 7233 /** 7234 * @apilevel internal 7235 */ 7236 protected boolean classSignature_computed = false; 7237 /** 7238 * @apilevel internal 7239 */ 7240 protected String classSignature_value; 7241 /** 7242 * @apilevel internal 7243 */ 7244 private void classSignature_reset() { 7245 classSignature_computed = false; 7246 classSignature_value = null; 7247 } 7248 /** 7249 * @attribute syn 7250 * @aspect GenericsCodegen 7251 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:401 7252 */ 7253 @ASTNodeAnnotation.Attribute 7254 public String classSignature() { 7255 ASTNode$State state = state(); 7256 if (classSignature_computed) { 7257 return classSignature_value; 7258 } 7259 boolean intermediate = state.INTERMEDIATE_VALUE; 7260 state.INTERMEDIATE_VALUE = false; 7261 int num = state.boundariesCrossed; 7262 boolean isFinal = this.is$Final(); 7263 classSignature_value = ""; 7264 if (isFinal && num == state().boundariesCrossed) { 7265 classSignature_computed = true; 7266 } else { 7267 } 7268 state.INTERMEDIATE_VALUE |= intermediate; 7269 7270 return classSignature_value; 7271 } 7272 /** 7273 * @apilevel internal 7274 */ 7275 protected boolean fieldTypeSignature_computed = false; 7276 /** 7277 * @apilevel internal 7278 */ 7279 protected String fieldTypeSignature_value; 7280 /** 7281 * @apilevel internal 7282 */ 7283 private void fieldTypeSignature_reset() { 7284 fieldTypeSignature_computed = false; 7285 fieldTypeSignature_value = null; 7286 } 7287 /** 7288 * @attribute syn 7289 * @aspect GenericsCodegen 7290 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:467 7291 */ 7292 @ASTNodeAnnotation.Attribute 7293 public String fieldTypeSignature() { 7294 ASTNode$State state = state(); 7295 if (fieldTypeSignature_computed) { 7296 return fieldTypeSignature_value; 7297 } 7298 boolean intermediate = state.INTERMEDIATE_VALUE; 7299 state.INTERMEDIATE_VALUE = false; 7300 int num = state.boundariesCrossed; 7301 boolean isFinal = this.is$Final(); 7302 fieldTypeSignature_value = classTypeSignature(); 7303 if (isFinal && num == state().boundariesCrossed) { 7304 fieldTypeSignature_computed = true; 7305 } else { 7306 } 7307 state.INTERMEDIATE_VALUE |= intermediate; 7308 7309 return fieldTypeSignature_value; 7310 } 7311 /** 7312 * @apilevel internal 7313 */ 7314 protected boolean classTypeSignature_computed = false; 7315 /** 7316 * @apilevel internal 7317 */ 7318 protected String classTypeSignature_value; 7319 /** 7320 * @apilevel internal 7321 */ 7322 private void classTypeSignature_reset() { 7323 classTypeSignature_computed = false; 7324 classTypeSignature_value = null; 7325 } 7326 /** 7327 * @attribute syn 7328 * @aspect GenericsCodegen 7329 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:476 7330 */ 7331 @ASTNodeAnnotation.Attribute 7332 public String classTypeSignature() { 7333 ASTNode$State state = state(); 7334 if (classTypeSignature_computed) { 7335 return classTypeSignature_value; 7336 } 7337 boolean intermediate = state.INTERMEDIATE_VALUE; 7338 state.INTERMEDIATE_VALUE = false; 7339 int num = state.boundariesCrossed; 7340 boolean isFinal = this.is$Final(); 7341 classTypeSignature_value = "L" + classTypeSignatureContents() + ";"; 7342 if (isFinal && num == state().boundariesCrossed) { 7343 classTypeSignature_computed = true; 7344 } else { 7345 } 7346 state.INTERMEDIATE_VALUE |= intermediate; 7347 7348 return classTypeSignature_value; 7349 } 7350 /** 7351 * @attribute syn 7352 * @aspect GenericsCodegen 7353 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:482 7354 */ 7355 @ASTNodeAnnotation.Attribute 7356 public String classTypeSignatureContents() { 7357 { 7358 StringBuilder buf = new StringBuilder(); 7359 if (isTopLevelType()) { 7360 if (!packageName().equals("")) { 7361 buf.append(packageName().replace('.', '/') + "/"); 7362 } 7363 } else { 7364 buf.append(enclosingType().classTypeSignatureContents() + "."); 7365 } 7366 buf.append(name()); 7367 buf.append(typeArgumentsOpt()); 7368 return buf.toString(); 7369 } 7370 } 7371 /** 7372 * @attribute syn 7373 * @aspect GenericsCodegen 7374 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:495 7375 */ 7376 @ASTNodeAnnotation.Attribute 7377 public String typeArgumentsOpt() { 7378 String typeArgumentsOpt_value = ""; 7379 7380 return typeArgumentsOpt_value; 7381 } 7382 /** 7383 * @return true if the modifier list includes the SafeVarargs annotation 7384 * @attribute syn 7385 * @aspect SafeVarargs 7386 * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:37 7387 */ 7388 @ASTNodeAnnotation.Attribute 7389 public boolean hasAnnotationSafeVarargs() { 7390 boolean hasAnnotationSafeVarargs_value = getModifiers().hasAnnotationSafeVarargs(); 7391 7392 return hasAnnotationSafeVarargs_value; 7393 } 7394 /** 7395 * An unchecked conversion occurs when converting from a 7396 * raw type G to a generic type G<T1, ..., Tn>. 7397 * @attribute syn 7398 * @aspect UncheckedConversion 7399 * @declaredat /home/jesper/git/extendj/java7/frontend/UncheckedConversion.jrag:76 7400 */ 7401 @ASTNodeAnnotation.Attribute 7402 public boolean isUncheckedConversionTo(TypeDecl dest) { 7403 boolean isUncheckedConversionTo_TypeDecl_value = (!dest.isRawType()) && this.isRawType(); 7404 7405 return isUncheckedConversionTo_TypeDecl_value; 7406 } 7407 /** 7408 * @attribute syn 7409 * @aspect PreciseRethrow 7410 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:41 7411 */ 7412 @ASTNodeAnnotation.Attribute 7413 public boolean modifiedInScope(Variable var) { 7414 { 7415 for (int i = 0; i < getNumBodyDecl(); i++) { 7416 BodyDecl body = getBodyDecl(i); 7417 if (body.modifiedInScope(var)) { 7418 return true; 7419 } 7420 } 7421 return false; 7422 } 7423 } 7424 /** 7425 * @apilevel internal 7426 */ 7427 protected boolean isFunctionalInterface_computed = false; 7428 /** 7429 * @apilevel internal 7430 */ 7431 protected boolean isFunctionalInterface_value; 7432 /** 7433 * @apilevel internal 7434 */ 7435 private void isFunctionalInterface_reset() { 7436 isFunctionalInterface_computed = false; 7437 } 7438 /** 7439 * @attribute syn 7440 * @aspect FunctionalInterface 7441 * @declaredat /home/jesper/git/extendj/java8/frontend/FunctionalInterface.jrag:30 7442 */ 7443 @ASTNodeAnnotation.Attribute 7444 public boolean isFunctionalInterface() { 7445 ASTNode$State state = state(); 7446 if (isFunctionalInterface_computed) { 7447 return isFunctionalInterface_value; 7448 } 7449 boolean intermediate = state.INTERMEDIATE_VALUE; 7450 state.INTERMEDIATE_VALUE = false; 7451 int num = state.boundariesCrossed; 7452 boolean isFinal = this.is$Final(); 7453 isFunctionalInterface_value = false; 7454 if (isFinal && num == state().boundariesCrossed) { 7455 isFunctionalInterface_computed = true; 7456 } else { 7457 } 7458 state.INTERMEDIATE_VALUE |= intermediate; 7459 7460 return isFunctionalInterface_value; 7461 } 7462 /** 7463 * @attribute syn 7464 * @aspect StrictSubtype 7465 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:39 7466 */ 7467 @ASTNodeAnnotation.Attribute 7468 public boolean strictSupertypeGenericClassDecl(GenericClassDecl type) { 7469 boolean strictSupertypeGenericClassDecl_GenericClassDecl_value = strictSupertypeClassDecl(type); 7470 7471 return strictSupertypeGenericClassDecl_GenericClassDecl_value; 7472 } 7473 /** 7474 * @attribute syn 7475 * @aspect StrictSubtype 7476 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:46 7477 */ 7478 @ASTNodeAnnotation.Attribute 7479 public boolean strictSupertypeGenericInterfaceDecl(GenericInterfaceDecl type) { 7480 boolean strictSupertypeGenericInterfaceDecl_GenericInterfaceDecl_value = this == type || strictSupertypeInterfaceDecl(type); 7481 7482 return strictSupertypeGenericInterfaceDecl_GenericInterfaceDecl_value; 7483 } 7484 /** 7485 * @attribute syn 7486 * @aspect StrictSubtype 7487 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:52 7488 */ 7489 @ASTNodeAnnotation.Attribute 7490 public boolean strictSupertypeRawClassDecl(RawClassDecl type) { 7491 boolean strictSupertypeRawClassDecl_RawClassDecl_value = strictSupertypeParClassDecl(type); 7492 7493 return strictSupertypeRawClassDecl_RawClassDecl_value; 7494 } 7495 /** 7496 * @attribute syn 7497 * @aspect StrictSubtype 7498 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:56 7499 */ 7500 @ASTNodeAnnotation.Attribute 7501 public boolean strictSupertypeRawInterfaceDecl(RawInterfaceDecl type) { 7502 boolean strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value = strictSupertypeParInterfaceDecl(type); 7503 7504 return strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value; 7505 } 7506 /** 7507 * @attribute syn 7508 * @aspect StrictSubtype 7509 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:68 7510 */ 7511 @ASTNodeAnnotation.Attribute 7512 public boolean strictSupertypeWildcard(WildcardType type) { 7513 boolean strictSupertypeWildcard_WildcardType_value = false; 7514 7515 return strictSupertypeWildcard_WildcardType_value; 7516 } 7517 /** 7518 * @attribute syn 7519 * @aspect StrictSubtype 7520 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:77 7521 */ 7522 @ASTNodeAnnotation.Attribute 7523 public boolean strictSupertypeWildcardExtends(WildcardExtendsType type) { 7524 boolean strictSupertypeWildcardExtends_WildcardExtendsType_value = false; 7525 7526 return strictSupertypeWildcardExtends_WildcardExtendsType_value; 7527 } 7528 /** 7529 * @attribute syn 7530 * @aspect StrictSubtype 7531 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:85 7532 */ 7533 @ASTNodeAnnotation.Attribute 7534 public boolean strictSupertypeWildcardSuper(WildcardSuperType type) { 7535 boolean strictSupertypeWildcardSuper_WildcardSuperType_value = false; 7536 7537 return strictSupertypeWildcardSuper_WildcardSuperType_value; 7538 } 7539 /** 7540 * @attribute syn 7541 * @aspect StrictSubtype 7542 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:155 7543 */ 7544 @ASTNodeAnnotation.Attribute 7545 public boolean strictSupertypeParClassDecl(ParClassDecl type) { 7546 boolean strictSupertypeParClassDecl_ParClassDecl_value = strictSupertypeClassDecl(type); 7547 7548 return strictSupertypeParClassDecl_ParClassDecl_value; 7549 } 7550 /** 7551 * @attribute syn 7552 * @aspect StrictSubtype 7553 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:159 7554 */ 7555 @ASTNodeAnnotation.Attribute 7556 public boolean strictSupertypeParInterfaceDecl(ParInterfaceDecl type) { 7557 boolean strictSupertypeParInterfaceDecl_ParInterfaceDecl_value = strictSupertypeInterfaceDecl(type); 7558 7559 return strictSupertypeParInterfaceDecl_ParInterfaceDecl_value; 7560 } 7561 /** 7562 * @apilevel internal 7563 */ 7564 private void strictContainedIn_TypeDecl_reset() { 7565 strictContainedIn_TypeDecl_values = null; 7566 } 7567 protected java.util.Map strictContainedIn_TypeDecl_values; 7568 @ASTNodeAnnotation.Attribute 7569 public boolean strictContainedIn(TypeDecl type) { 7570 Object _parameters = type; 7571 if (strictContainedIn_TypeDecl_values == null) strictContainedIn_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 7572 ASTNode$State.CircularValue _value; 7573 if (strictContainedIn_TypeDecl_values.containsKey(_parameters)) { 7574 Object _o = strictContainedIn_TypeDecl_values.get(_parameters); 7575 if (!(_o instanceof ASTNode$State.CircularValue)) { 7576 return (Boolean) _o; 7577 } else { 7578 _value = (ASTNode$State.CircularValue) _o; 7579 } 7580 } else { 7581 _value = new ASTNode$State.CircularValue(); 7582 strictContainedIn_TypeDecl_values.put(_parameters, _value); 7583 _value.value = true; 7584 } 7585 ASTNode$State state = state(); 7586 boolean new_strictContainedIn_TypeDecl_value; 7587 if (!state.IN_CIRCLE) { 7588 state.IN_CIRCLE = true; 7589 int num = state.boundariesCrossed; 7590 boolean isFinal = this.is$Final(); 7591 // TODO: fixme 7592 // state().CIRCLE_INDEX = 1; 7593 do { 7594 _value.visited = state.CIRCLE_INDEX; 7595 state.CHANGE = false; 7596 new_strictContainedIn_TypeDecl_value = strictContainedIn_compute(type); 7597 if (new_strictContainedIn_TypeDecl_value != ((Boolean)_value.value)) { 7598 state.CHANGE = true; 7599 _value.value = new_strictContainedIn_TypeDecl_value; 7600 } 7601 state.CIRCLE_INDEX++; 7602 } while (state.CHANGE); 7603 if (isFinal && num == state().boundariesCrossed) { 7604 strictContainedIn_TypeDecl_values.put(_parameters, new_strictContainedIn_TypeDecl_value); 7605 } else { 7606 strictContainedIn_TypeDecl_values.remove(_parameters); 7607 state.RESET_CYCLE = true; 7608 boolean $tmp = strictContainedIn_compute(type); 7609 state.RESET_CYCLE = false; 7610 } 7611 state.IN_CIRCLE = false; 7612 state.INTERMEDIATE_VALUE = false; 7613 return new_strictContainedIn_TypeDecl_value; 7614 } 7615 if (state.CIRCLE_INDEX != _value.visited) { 7616 _value.visited = state.CIRCLE_INDEX; 7617 new_strictContainedIn_TypeDecl_value = strictContainedIn_compute(type); 7618 if (state.RESET_CYCLE) { 7619 strictContainedIn_TypeDecl_values.remove(_parameters); 7620 } 7621 else if (new_strictContainedIn_TypeDecl_value != ((Boolean)_value.value)) { 7622 state.CHANGE = true; 7623 _value.value = new_strictContainedIn_TypeDecl_value; 7624 } 7625 state.INTERMEDIATE_VALUE = true; 7626 return new_strictContainedIn_TypeDecl_value; 7627 } 7628 state.INTERMEDIATE_VALUE = true; 7629 return (Boolean) _value.value; 7630 } 7631 /** 7632 * @apilevel internal 7633 */ 7634 private boolean strictContainedIn_compute(TypeDecl type) { 7635 if (type == this || type instanceof WildcardType) { 7636 return true; 7637 } else if (type instanceof WildcardExtendsType) { 7638 return this.strictSubtype(((WildcardExtendsType) type).extendsType()); 7639 } else if (type instanceof WildcardSuperType) { 7640 return ((WildcardSuperType) type).superType().strictSubtype(this); 7641 } else if (type instanceof TypeVariable) { 7642 return strictSubtype(type); 7643 } 7644 return sameStructure(type); 7645 } 7646 /** 7647 * @attribute syn 7648 * @aspect StrictSubtype 7649 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:276 7650 */ 7651 @ASTNodeAnnotation.Attribute 7652 public boolean strictSupertypeTypeVariable(TypeVariable type) { 7653 { 7654 if (type == this) { 7655 return true; 7656 } 7657 for (int i = 0; i < type.getNumTypeBound(); i++) { 7658 if (type.getTypeBound(i).type().strictSubtype(this)) { 7659 return true; 7660 } 7661 } 7662 return false; 7663 } 7664 } 7665 /** 7666 * @attribute syn 7667 * @aspect StrictSubtype 7668 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:316 7669 */ 7670 @ASTNodeAnnotation.Attribute 7671 public boolean strictSupertypeLUBType(LUBType type) { 7672 { 7673 for (int i = 0; i < type.getNumTypeBound(); i++) { 7674 if (!type.getTypeBound(i).type().strictSubtype(this)) { 7675 return false; 7676 } 7677 } 7678 return true; 7679 } 7680 } 7681 /** 7682 * @attribute syn 7683 * @aspect StrictSubtype 7684 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:336 7685 */ 7686 @ASTNodeAnnotation.Attribute 7687 public boolean strictSupertypeGLBType(GLBType type) { 7688 { 7689 // T1 && .. && Tn <: this, if exists 0 < i <= n Ti <: this 7690 for (int i = 0; i < type.getNumTypeBound(); i++) { 7691 if (type.getTypeBound(i).type().strictSubtype(this)) { 7692 return true; 7693 } 7694 } 7695 return false; 7696 } 7697 } 7698 /** 7699 * @apilevel internal 7700 */ 7701 private void strictSubtype_TypeDecl_reset() { 7702 strictSubtype_TypeDecl_values = null; 7703 } 7704 protected java.util.Map strictSubtype_TypeDecl_values; 7705 @ASTNodeAnnotation.Attribute 7706 public boolean strictSubtype(TypeDecl type) { 7707 Object _parameters = type; 7708 if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 7709 ASTNode$State.CircularValue _value; 7710 if (strictSubtype_TypeDecl_values.containsKey(_parameters)) { 7711 Object _o = strictSubtype_TypeDecl_values.get(_parameters); 7712 if (!(_o instanceof ASTNode$State.CircularValue)) { 7713 return (Boolean) _o; 7714 } else { 7715 _value = (ASTNode$State.CircularValue) _o; 7716 } 7717 } else { 7718 _value = new ASTNode$State.CircularValue(); 7719 strictSubtype_TypeDecl_values.put(_parameters, _value); 7720 _value.value = true; 7721 } 7722 ASTNode$State state = state(); 7723 boolean new_strictSubtype_TypeDecl_value; 7724 if (!state.IN_CIRCLE) { 7725 state.IN_CIRCLE = true; 7726 int num = state.boundariesCrossed; 7727 boolean isFinal = this.is$Final(); 7728 // TODO: fixme 7729 // state().CIRCLE_INDEX = 1; 7730 do { 7731 _value.visited = state.CIRCLE_INDEX; 7732 state.CHANGE = false; 7733 new_strictSubtype_TypeDecl_value = type == this; 7734 if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 7735 state.CHANGE = true; 7736 _value.value = new_strictSubtype_TypeDecl_value; 7737 } 7738 state.CIRCLE_INDEX++; 7739 } while (state.CHANGE); 7740 if (isFinal && num == state().boundariesCrossed) { 7741 strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value); 7742 } else { 7743 strictSubtype_TypeDecl_values.remove(_parameters); 7744 state.RESET_CYCLE = true; 7745 boolean $tmp = type == this; 7746 state.RESET_CYCLE = false; 7747 } 7748 state.IN_CIRCLE = false; 7749 state.INTERMEDIATE_VALUE = false; 7750 return new_strictSubtype_TypeDecl_value; 7751 } 7752 if (state.CIRCLE_INDEX != _value.visited) { 7753 _value.visited = state.CIRCLE_INDEX; 7754 new_strictSubtype_TypeDecl_value = type == this; 7755 if (state.RESET_CYCLE) { 7756 strictSubtype_TypeDecl_values.remove(_parameters); 7757 } 7758 else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 7759 state.CHANGE = true; 7760 _value.value = new_strictSubtype_TypeDecl_value; 7761 } 7762 state.INTERMEDIATE_VALUE = true; 7763 return new_strictSubtype_TypeDecl_value; 7764 } 7765 state.INTERMEDIATE_VALUE = true; 7766 return (Boolean) _value.value; 7767 } 7768 /** 7769 * @attribute syn 7770 * @aspect StrictSubtype 7771 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:370 7772 */ 7773 @ASTNodeAnnotation.Attribute 7774 public boolean strictSupertypeClassDecl(ClassDecl type) { 7775 boolean strictSupertypeClassDecl_ClassDecl_value = type == this; 7776 7777 return strictSupertypeClassDecl_ClassDecl_value; 7778 } 7779 /** 7780 * @attribute syn 7781 * @aspect StrictSubtype 7782 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:390 7783 */ 7784 @ASTNodeAnnotation.Attribute 7785 public boolean strictSupertypeInterfaceDecl(InterfaceDecl type) { 7786 boolean strictSupertypeInterfaceDecl_InterfaceDecl_value = type == this; 7787 7788 return strictSupertypeInterfaceDecl_InterfaceDecl_value; 7789 } 7790 /** 7791 * @attribute syn 7792 * @aspect StrictSubtype 7793 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:407 7794 */ 7795 @ASTNodeAnnotation.Attribute 7796 public boolean strictSupertypeArrayDecl(ArrayDecl type) { 7797 boolean strictSupertypeArrayDecl_ArrayDecl_value = this == type; 7798 7799 return strictSupertypeArrayDecl_ArrayDecl_value; 7800 } 7801 /** 7802 * @attribute syn 7803 * @aspect StrictSubtype 7804 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:437 7805 */ 7806 @ASTNodeAnnotation.Attribute 7807 public boolean strictSupertypePrimitiveType(PrimitiveType type) { 7808 boolean strictSupertypePrimitiveType_PrimitiveType_value = type == this; 7809 7810 return strictSupertypePrimitiveType_PrimitiveType_value; 7811 } 7812 /** 7813 * @attribute syn 7814 * @aspect StrictSubtype 7815 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:446 7816 */ 7817 @ASTNodeAnnotation.Attribute 7818 public boolean strictSupertypeNullType(NullType type) { 7819 boolean strictSupertypeNullType_NullType_value = false; 7820 7821 return strictSupertypeNullType_NullType_value; 7822 } 7823 /** 7824 * @attribute syn 7825 * @aspect StrictSubtype 7826 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:450 7827 */ 7828 @ASTNodeAnnotation.Attribute 7829 public boolean strictSupertypeVoidType(VoidType type) { 7830 boolean strictSupertypeVoidType_VoidType_value = false; 7831 7832 return strictSupertypeVoidType_VoidType_value; 7833 } 7834 /** 7835 * @attribute syn 7836 * @aspect StrictSubtype 7837 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:455 7838 */ 7839 @ASTNodeAnnotation.Attribute 7840 public boolean strictSupertypeClassDeclSubstituted(ClassDeclSubstituted type) { 7841 boolean strictSupertypeClassDeclSubstituted_ClassDeclSubstituted_value = type.original() == this || strictSupertypeClassDecl(type); 7842 7843 return strictSupertypeClassDeclSubstituted_ClassDeclSubstituted_value; 7844 } 7845 /** 7846 * @attribute syn 7847 * @aspect StrictSubtype 7848 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:466 7849 */ 7850 @ASTNodeAnnotation.Attribute 7851 public boolean strictSupertypeInterfaceDeclSubstituted(InterfaceDeclSubstituted type) { 7852 boolean strictSupertypeInterfaceDeclSubstituted_InterfaceDeclSubstituted_value = type.original() == this || strictSupertypeInterfaceDecl(type); 7853 7854 return strictSupertypeInterfaceDeclSubstituted_InterfaceDeclSubstituted_value; 7855 } 7856 /** 7857 * @attribute syn 7858 * @aspect StrictSubtype 7859 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:478 7860 */ 7861 @ASTNodeAnnotation.Attribute 7862 public boolean strictSupertypeGenericClassDeclSubstituted(GenericClassDeclSubstituted type) { 7863 boolean strictSupertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value = type.original() == this || strictSupertypeGenericClassDecl(type); 7864 7865 return strictSupertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value; 7866 } 7867 /** 7868 * @attribute syn 7869 * @aspect StrictSubtype 7870 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:492 7871 */ 7872 @ASTNodeAnnotation.Attribute 7873 public boolean strictSupertypeGenericInterfaceDeclSubstituted(GenericInterfaceDeclSubstituted type) { 7874 boolean strictSupertypeGenericInterfaceDeclSubstituted_GenericInterfaceDeclSubstituted_value = type.original() == this || strictSupertypeGenericInterfaceDecl(type); 7875 7876 return strictSupertypeGenericInterfaceDeclSubstituted_GenericInterfaceDeclSubstituted_value; 7877 } 7878 /** 7879 * @attribute inh 7880 * @aspect Arrays 7881 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:42 7882 */ 7883 /** 7884 * @attribute inh 7885 * @aspect Arrays 7886 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:42 7887 */ 7888 @ASTNodeAnnotation.Attribute 7889 public TypeDecl componentType() { 7890 ASTNode$State state = state(); 7891 if (componentType_computed) { 7892 return componentType_value; 7893 } 7894 boolean intermediate = state.INTERMEDIATE_VALUE; 7895 state.INTERMEDIATE_VALUE = false; 7896 int num = state.boundariesCrossed; 7897 boolean isFinal = this.is$Final(); 7898 componentType_value = getParent().Define_componentType(this, null); 7899 if (isFinal && num == state().boundariesCrossed) { 7900 componentType_computed = true; 7901 } else { 7902 } 7903 state.INTERMEDIATE_VALUE |= intermediate; 7904 7905 return componentType_value; 7906 } 7907 /** 7908 * @apilevel internal 7909 */ 7910 protected boolean componentType_computed = false; 7911 /** 7912 * @apilevel internal 7913 */ 7914 protected TypeDecl componentType_value; 7915 /** 7916 * @apilevel internal 7917 */ 7918 private void componentType_reset() { 7919 componentType_computed = false; 7920 componentType_value = null; 7921 } 7922 /** 7923 * @attribute inh 7924 * @aspect Arrays 7925 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:70 7926 */ 7927 /** 7928 * @attribute inh 7929 * @aspect Arrays 7930 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:70 7931 */ 7932 @ASTNodeAnnotation.Attribute 7933 public TypeDecl typeCloneable() { 7934 TypeDecl typeCloneable_value = getParent().Define_typeCloneable(this, null); 7935 7936 return typeCloneable_value; 7937 } 7938 /** 7939 * @attribute inh 7940 * @aspect Arrays 7941 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:71 7942 */ 7943 /** 7944 * @attribute inh 7945 * @aspect Arrays 7946 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:71 7947 */ 7948 @ASTNodeAnnotation.Attribute 7949 public TypeDecl typeSerializable() { 7950 TypeDecl typeSerializable_value = getParent().Define_typeSerializable(this, null); 7951 7952 return typeSerializable_value; 7953 } 7954 /** 7955 * @attribute inh 7956 * @aspect ClassPath 7957 * @declaredat /home/jesper/git/extendj/java4/frontend/ClassPath.jrag:78 7958 */ 7959 /** 7960 * @attribute inh 7961 * @aspect ClassPath 7962 * @declaredat /home/jesper/git/extendj/java4/frontend/ClassPath.jrag:78 7963 */ 7964 @ASTNodeAnnotation.Attribute 7965 public CompilationUnit compilationUnit() { 7966 CompilationUnit compilationUnit_value = getParent().Define_compilationUnit(this, null); 7967 7968 return compilationUnit_value; 7969 } 7970 /** 7971 * @attribute inh 7972 * @aspect DA 7973 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:264 7974 */ 7975 /** 7976 * @attribute inh 7977 * @aspect DA 7978 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:264 7979 */ 7980 @ASTNodeAnnotation.Attribute 7981 public boolean isDAbefore(Variable v) { 7982 Object _parameters = v; 7983 if (isDAbefore_Variable_values == null) isDAbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 7984 ASTNode$State state = state(); 7985 if (isDAbefore_Variable_values.containsKey(_parameters)) { 7986 return (Boolean) isDAbefore_Variable_values.get(_parameters); 7987 } 7988 boolean intermediate = state.INTERMEDIATE_VALUE; 7989 state.INTERMEDIATE_VALUE = false; 7990 int num = state.boundariesCrossed; 7991 boolean isFinal = this.is$Final(); 7992 boolean isDAbefore_Variable_value = getParent().Define_isDAbefore(this, null, v); 7993 if (isFinal && num == state().boundariesCrossed) { 7994 isDAbefore_Variable_values.put(_parameters, isDAbefore_Variable_value); 7995 } else { 7996 } 7997 state.INTERMEDIATE_VALUE |= intermediate; 7998 7999 return isDAbefore_Variable_value; 8000 } 8001 /** 8002 * @apilevel internal 8003 */ 8004 protected java.util.Map isDAbefore_Variable_values; 8005 /** 8006 * @apilevel internal 8007 */ 8008 private void isDAbefore_Variable_reset() { 8009 isDAbefore_Variable_values = null; 8010 } 8011 /** 8012 * @attribute inh 8013 * @aspect DU 8014 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:794 8015 */ 8016 /** 8017 * @attribute inh 8018 * @aspect DU 8019 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:794 8020 */ 8021 @ASTNodeAnnotation.Attribute 8022 public boolean isDUbefore(Variable v) { 8023 Object _parameters = v; 8024 if (isDUbefore_Variable_values == null) isDUbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 8025 ASTNode$State state = state(); 8026 if (isDUbefore_Variable_values.containsKey(_parameters)) { 8027 return (Boolean) isDUbefore_Variable_values.get(_parameters); 8028 } 8029 boolean intermediate = state.INTERMEDIATE_VALUE; 8030 state.INTERMEDIATE_VALUE = false; 8031 int num = state.boundariesCrossed; 8032 boolean isFinal = this.is$Final(); 8033 boolean isDUbefore_Variable_value = getParent().Define_isDUbefore(this, null, v); 8034 if (isFinal && num == state().boundariesCrossed) { 8035 isDUbefore_Variable_values.put(_parameters, isDUbefore_Variable_value); 8036 } else { 8037 } 8038 state.INTERMEDIATE_VALUE |= intermediate; 8039 8040 return isDUbefore_Variable_value; 8041 } 8042 /** 8043 * @apilevel internal 8044 */ 8045 protected java.util.Map isDUbefore_Variable_values; 8046 /** 8047 * @apilevel internal 8048 */ 8049 private void isDUbefore_Variable_reset() { 8050 isDUbefore_Variable_values = null; 8051 } 8052 /** 8053 * @attribute inh 8054 * @aspect ExceptionHandling 8055 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:41 8056 */ 8057 /** 8058 * @attribute inh 8059 * @aspect ExceptionHandling 8060 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:41 8061 */ 8062 @ASTNodeAnnotation.Attribute 8063 public TypeDecl typeException() { 8064 ASTNode$State state = state(); 8065 if (typeException_computed) { 8066 return typeException_value; 8067 } 8068 boolean intermediate = state.INTERMEDIATE_VALUE; 8069 state.INTERMEDIATE_VALUE = false; 8070 int num = state.boundariesCrossed; 8071 boolean isFinal = this.is$Final(); 8072 typeException_value = getParent().Define_typeException(this, null); 8073 if (isFinal && num == state().boundariesCrossed) { 8074 typeException_computed = true; 8075 } else { 8076 } 8077 state.INTERMEDIATE_VALUE |= intermediate; 8078 8079 return typeException_value; 8080 } 8081 /** 8082 * @apilevel internal 8083 */ 8084 protected boolean typeException_computed = false; 8085 /** 8086 * @apilevel internal 8087 */ 8088 protected TypeDecl typeException_value; 8089 /** 8090 * @apilevel internal 8091 */ 8092 private void typeException_reset() { 8093 typeException_computed = false; 8094 typeException_value = null; 8095 } 8096 /** 8097 * @attribute inh 8098 * @aspect ExceptionHandling 8099 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:43 8100 */ 8101 /** 8102 * @attribute inh 8103 * @aspect ExceptionHandling 8104 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:43 8105 */ 8106 @ASTNodeAnnotation.Attribute 8107 public TypeDecl typeRuntimeException() { 8108 ASTNode$State state = state(); 8109 if (typeRuntimeException_computed) { 8110 return typeRuntimeException_value; 8111 } 8112 boolean intermediate = state.INTERMEDIATE_VALUE; 8113 state.INTERMEDIATE_VALUE = false; 8114 int num = state.boundariesCrossed; 8115 boolean isFinal = this.is$Final(); 8116 typeRuntimeException_value = getParent().Define_typeRuntimeException(this, null); 8117 if (isFinal && num == state().boundariesCrossed) { 8118 typeRuntimeException_computed = true; 8119 } else { 8120 } 8121 state.INTERMEDIATE_VALUE |= intermediate; 8122 8123 return typeRuntimeException_value; 8124 } 8125 /** 8126 * @apilevel internal 8127 */ 8128 protected boolean typeRuntimeException_computed = false; 8129 /** 8130 * @apilevel internal 8131 */ 8132 protected TypeDecl typeRuntimeException_value; 8133 /** 8134 * @apilevel internal 8135 */ 8136 private void typeRuntimeException_reset() { 8137 typeRuntimeException_computed = false; 8138 typeRuntimeException_value = null; 8139 } 8140 /** 8141 * @attribute inh 8142 * @aspect ExceptionHandling 8143 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:45 8144 */ 8145 /** 8146 * @attribute inh 8147 * @aspect ExceptionHandling 8148 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:45 8149 */ 8150 @ASTNodeAnnotation.Attribute 8151 public TypeDecl typeError() { 8152 ASTNode$State state = state(); 8153 if (typeError_computed) { 8154 return typeError_value; 8155 } 8156 boolean intermediate = state.INTERMEDIATE_VALUE; 8157 state.INTERMEDIATE_VALUE = false; 8158 int num = state.boundariesCrossed; 8159 boolean isFinal = this.is$Final(); 8160 typeError_value = getParent().Define_typeError(this, null); 8161 if (isFinal && num == state().boundariesCrossed) { 8162 typeError_computed = true; 8163 } else { 8164 } 8165 state.INTERMEDIATE_VALUE |= intermediate; 8166 8167 return typeError_value; 8168 } 8169 /** 8170 * @apilevel internal 8171 */ 8172 protected boolean typeError_computed = false; 8173 /** 8174 * @apilevel internal 8175 */ 8176 protected TypeDecl typeError_value; 8177 /** 8178 * @apilevel internal 8179 */ 8180 private void typeError_reset() { 8181 typeError_computed = false; 8182 typeError_value = null; 8183 } 8184 /** 8185 * @attribute inh 8186 * @aspect LookupMethod 8187 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:48 8188 */ 8189 /** 8190 * @attribute inh 8191 * @aspect LookupMethod 8192 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:48 8193 */ 8194 @ASTNodeAnnotation.Attribute 8195 public Collection lookupMethod(String name) { 8196 Object _parameters = name; 8197 if (lookupMethod_String_values == null) lookupMethod_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 8198 ASTNode$State state = state(); 8199 if (lookupMethod_String_values.containsKey(_parameters)) { 8200 return (Collection) lookupMethod_String_values.get(_parameters); 8201 } 8202 boolean intermediate = state.INTERMEDIATE_VALUE; 8203 state.INTERMEDIATE_VALUE = false; 8204 int num = state.boundariesCrossed; 8205 boolean isFinal = this.is$Final(); 8206 Collection lookupMethod_String_value = getParent().Define_lookupMethod(this, null, name); 8207 if (isFinal && num == state().boundariesCrossed) { 8208 lookupMethod_String_values.put(_parameters, lookupMethod_String_value); 8209 } else { 8210 } 8211 state.INTERMEDIATE_VALUE |= intermediate; 8212 8213 return lookupMethod_String_value; 8214 } 8215 /** 8216 * @apilevel internal 8217 */ 8218 protected java.util.Map lookupMethod_String_values; 8219 /** 8220 * @apilevel internal 8221 */ 8222 private void lookupMethod_String_reset() { 8223 lookupMethod_String_values = null; 8224 } 8225 /** 8226 * @attribute inh 8227 * @aspect SpecialClasses 8228 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:87 8229 */ 8230 /** 8231 * @attribute inh 8232 * @aspect SpecialClasses 8233 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:87 8234 */ 8235 @ASTNodeAnnotation.Attribute 8236 public TypeDecl typeInt() { 8237 TypeDecl typeInt_value = getParent().Define_typeInt(this, null); 8238 8239 return typeInt_value; 8240 } 8241 /** 8242 * @attribute inh 8243 * @aspect SpecialClasses 8244 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:90 8245 */ 8246 /** 8247 * @attribute inh 8248 * @aspect SpecialClasses 8249 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:90 8250 */ 8251 @ASTNodeAnnotation.Attribute 8252 public TypeDecl typeObject() { 8253 ASTNode$State state = state(); 8254 if (typeObject_computed) { 8255 return typeObject_value; 8256 } 8257 boolean intermediate = state.INTERMEDIATE_VALUE; 8258 state.INTERMEDIATE_VALUE = false; 8259 int num = state.boundariesCrossed; 8260 boolean isFinal = this.is$Final(); 8261 typeObject_value = getParent().Define_typeObject(this, null); 8262 if (isFinal && num == state().boundariesCrossed) { 8263 typeObject_computed = true; 8264 } else { 8265 } 8266 state.INTERMEDIATE_VALUE |= intermediate; 8267 8268 return typeObject_value; 8269 } 8270 /** 8271 * @apilevel internal 8272 */ 8273 protected boolean typeObject_computed = false; 8274 /** 8275 * @apilevel internal 8276 */ 8277 protected TypeDecl typeObject_value; 8278 /** 8279 * @apilevel internal 8280 */ 8281 private void typeObject_reset() { 8282 typeObject_computed = false; 8283 typeObject_value = null; 8284 } 8285 /** 8286 * @attribute inh 8287 * @aspect LookupFullyQualifiedTypes 8288 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:132 8289 */ 8290 /** 8291 * @attribute inh 8292 * @aspect LookupFullyQualifiedTypes 8293 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:132 8294 */ 8295 @ASTNodeAnnotation.Attribute 8296 public TypeDecl lookupType(String packageName, String typeName) { 8297 TypeDecl lookupType_String_String_value = getParent().Define_lookupType(this, null, packageName, typeName); 8298 8299 return lookupType_String_String_value; 8300 } 8301 /** 8302 * @attribute inh 8303 * @aspect TypeScopePropagation 8304 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:337 8305 */ 8306 /** 8307 * @attribute inh 8308 * @aspect TypeScopePropagation 8309 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:337 8310 */ 8311 @ASTNodeAnnotation.Attribute 8312 public SimpleSet lookupType(String name) { 8313 Object _parameters = name; 8314 if (lookupType_String_values == null) lookupType_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 8315 ASTNode$State state = state(); 8316 if (lookupType_String_values.containsKey(_parameters)) { 8317 return (SimpleSet) lookupType_String_values.get(_parameters); 8318 } 8319 boolean intermediate = state.INTERMEDIATE_VALUE; 8320 state.INTERMEDIATE_VALUE = false; 8321 int num = state.boundariesCrossed; 8322 boolean isFinal = this.is$Final(); 8323 SimpleSet lookupType_String_value = getParent().Define_lookupType(this, null, name); 8324 if (isFinal && num == state().boundariesCrossed) { 8325 lookupType_String_values.put(_parameters, lookupType_String_value); 8326 } else { 8327 } 8328 state.INTERMEDIATE_VALUE |= intermediate; 8329 8330 return lookupType_String_value; 8331 } 8332 /** 8333 * @apilevel internal 8334 */ 8335 protected java.util.Map lookupType_String_values; 8336 /** 8337 * @apilevel internal 8338 */ 8339 private void lookupType_String_reset() { 8340 lookupType_String_values = null; 8341 } 8342 /** 8343 * @attribute inh 8344 * @aspect VariableScope 8345 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:35 8346 */ 8347 /** 8348 * @attribute inh 8349 * @aspect VariableScope 8350 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:35 8351 */ 8352 @ASTNodeAnnotation.Attribute 8353 public SimpleSet lookupVariable(String name) { 8354 Object _parameters = name; 8355 if (lookupVariable_String_values == null) lookupVariable_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 8356 ASTNode$State state = state(); 8357 if (lookupVariable_String_values.containsKey(_parameters)) { 8358 return (SimpleSet) lookupVariable_String_values.get(_parameters); 8359 } 8360 boolean intermediate = state.INTERMEDIATE_VALUE; 8361 state.INTERMEDIATE_VALUE = false; 8362 int num = state.boundariesCrossed; 8363 boolean isFinal = this.is$Final(); 8364 SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name); 8365 if (isFinal && num == state().boundariesCrossed) { 8366 lookupVariable_String_values.put(_parameters, lookupVariable_String_value); 8367 } else { 8368 } 8369 state.INTERMEDIATE_VALUE |= intermediate; 8370 8371 return lookupVariable_String_value; 8372 } 8373 /** 8374 * @apilevel internal 8375 */ 8376 protected java.util.Map lookupVariable_String_values; 8377 /** 8378 * @apilevel internal 8379 */ 8380 private void lookupVariable_String_reset() { 8381 lookupVariable_String_values = null; 8382 } 8383 /** 8384 * @attribute inh 8385 * @aspect NameCheck 8386 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:307 8387 */ 8388 /** 8389 * @attribute inh 8390 * @aspect NameCheck 8391 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:307 8392 */ 8393 @ASTNodeAnnotation.Attribute 8394 public boolean hasPackage(String packageName) { 8395 boolean hasPackage_String_value = getParent().Define_hasPackage(this, null, packageName); 8396 8397 return hasPackage_String_value; 8398 } 8399 /** 8400 * @attribute inh 8401 * @aspect NameCheck 8402 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:310 8403 */ 8404 /** 8405 * @attribute inh 8406 * @aspect NameCheck 8407 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:310 8408 */ 8409 @ASTNodeAnnotation.Attribute 8410 public ASTNode enclosingBlock() { 8411 ASTNode enclosingBlock_value = getParent().Define_enclosingBlock(this, null); 8412 8413 return enclosingBlock_value; 8414 } 8415 /** 8416 * @attribute inh 8417 * @aspect TypeName 8418 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:103 8419 */ 8420 /** 8421 * @attribute inh 8422 * @aspect TypeName 8423 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:103 8424 */ 8425 @ASTNodeAnnotation.Attribute 8426 public String packageName() { 8427 ASTNode$State state = state(); 8428 if (packageName_computed) { 8429 return packageName_value; 8430 } 8431 boolean intermediate = state.INTERMEDIATE_VALUE; 8432 state.INTERMEDIATE_VALUE = false; 8433 int num = state.boundariesCrossed; 8434 boolean isFinal = this.is$Final(); 8435 packageName_value = getParent().Define_packageName(this, null); 8436 if (isFinal && num == state().boundariesCrossed) { 8437 packageName_computed = true; 8438 } else { 8439 } 8440 state.INTERMEDIATE_VALUE |= intermediate; 8441 8442 return packageName_value; 8443 } 8444 /** 8445 * @apilevel internal 8446 */ 8447 protected boolean packageName_computed = false; 8448 /** 8449 * @apilevel internal 8450 */ 8451 protected String packageName_value; 8452 /** 8453 * @apilevel internal 8454 */ 8455 private void packageName_reset() { 8456 packageName_computed = false; 8457 packageName_value = null; 8458 } 8459 /** 8460 * @attribute inh 8461 * @aspect TypeAnalysis 8462 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:240 8463 */ 8464 /** 8465 * @attribute inh 8466 * @aspect TypeAnalysis 8467 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:240 8468 */ 8469 @ASTNodeAnnotation.Attribute 8470 public boolean isAnonymous() { 8471 ASTNode$State state = state(); 8472 if (isAnonymous_computed) { 8473 return isAnonymous_value; 8474 } 8475 boolean intermediate = state.INTERMEDIATE_VALUE; 8476 state.INTERMEDIATE_VALUE = false; 8477 int num = state.boundariesCrossed; 8478 boolean isFinal = this.is$Final(); 8479 isAnonymous_value = getParent().Define_isAnonymous(this, null); 8480 if (isFinal && num == state().boundariesCrossed) { 8481 isAnonymous_computed = true; 8482 } else { 8483 } 8484 state.INTERMEDIATE_VALUE |= intermediate; 8485 8486 return isAnonymous_value; 8487 } 8488 /** 8489 * @apilevel internal 8490 */ 8491 protected boolean isAnonymous_computed = false; 8492 /** 8493 * @apilevel internal 8494 */ 8495 protected boolean isAnonymous_value; 8496 /** 8497 * @apilevel internal 8498 */ 8499 private void isAnonymous_reset() { 8500 isAnonymous_computed = false; 8501 } 8502 /** 8503 * @attribute inh 8504 * @aspect NestedTypes 8505 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:544 8506 */ 8507 /** 8508 * @attribute inh 8509 * @aspect NestedTypes 8510 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:544 8511 */ 8512 @ASTNodeAnnotation.Attribute 8513 public TypeDecl enclosingType() { 8514 TypeDecl enclosingType_value = getParent().Define_enclosingType(this, null); 8515 8516 return enclosingType_value; 8517 } 8518 /** 8519 * @attribute inh 8520 * @aspect NestedTypes 8521 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:562 8522 */ 8523 /** 8524 * @attribute inh 8525 * @aspect NestedTypes 8526 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:562 8527 */ 8528 @ASTNodeAnnotation.Attribute 8529 public BodyDecl enclosingBodyDecl() { 8530 BodyDecl enclosingBodyDecl_value = getParent().Define_enclosingBodyDecl(this, null); 8531 8532 return enclosingBodyDecl_value; 8533 } 8534 /** 8535 * @attribute inh 8536 * @aspect NestedTypes 8537 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:569 8538 */ 8539 /** 8540 * @attribute inh 8541 * @aspect NestedTypes 8542 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:569 8543 */ 8544 @ASTNodeAnnotation.Attribute 8545 public boolean isNestedType() { 8546 boolean isNestedType_value = getParent().Define_isNestedType(this, null); 8547 8548 return isNestedType_value; 8549 } 8550 /** 8551 * @attribute inh 8552 * @aspect NestedTypes 8553 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:577 8554 */ 8555 /** 8556 * @attribute inh 8557 * @aspect NestedTypes 8558 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:577 8559 */ 8560 @ASTNodeAnnotation.Attribute 8561 public boolean isMemberType() { 8562 boolean isMemberType_value = getParent().Define_isMemberType(this, null); 8563 8564 return isMemberType_value; 8565 } 8566 /** 8567 * @attribute inh 8568 * @aspect NestedTypes 8569 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:591 8570 */ 8571 /** 8572 * @attribute inh 8573 * @aspect NestedTypes 8574 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:591 8575 */ 8576 @ASTNodeAnnotation.Attribute 8577 public boolean isLocalClass() { 8578 boolean isLocalClass_value = getParent().Define_isLocalClass(this, null); 8579 8580 return isLocalClass_value; 8581 } 8582 /** 8583 * @attribute inh 8584 * @aspect NestedTypes 8585 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:620 8586 */ 8587 /** 8588 * @attribute inh 8589 * @aspect NestedTypes 8590 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:620 8591 */ 8592 @ASTNodeAnnotation.Attribute 8593 public String hostPackage() { 8594 String hostPackage_value = getParent().Define_hostPackage(this, null); 8595 8596 return hostPackage_value; 8597 } 8598 /** 8599 * @attribute inh 8600 * @aspect Circularity 8601 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:751 8602 */ 8603 /** 8604 * @attribute inh 8605 * @aspect Circularity 8606 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:751 8607 */ 8608 @ASTNodeAnnotation.Attribute 8609 public TypeDecl unknownType() { 8610 ASTNode$State state = state(); 8611 if (unknownType_computed) { 8612 return unknownType_value; 8613 } 8614 boolean intermediate = state.INTERMEDIATE_VALUE; 8615 state.INTERMEDIATE_VALUE = false; 8616 int num = state.boundariesCrossed; 8617 boolean isFinal = this.is$Final(); 8618 unknownType_value = getParent().Define_unknownType(this, null); 8619 if (isFinal && num == state().boundariesCrossed) { 8620 unknownType_computed = true; 8621 } else { 8622 } 8623 state.INTERMEDIATE_VALUE |= intermediate; 8624 8625 return unknownType_value; 8626 } 8627 /** 8628 * @apilevel internal 8629 */ 8630 protected boolean unknownType_computed = false; 8631 /** 8632 * @apilevel internal 8633 */ 8634 protected TypeDecl unknownType_value; 8635 /** 8636 * @apilevel internal 8637 */ 8638 private void unknownType_reset() { 8639 unknownType_computed = false; 8640 unknownType_value = null; 8641 } 8642 /** 8643 * @attribute inh 8644 * @aspect TypeCheck 8645 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:471 8646 */ 8647 /** 8648 * @attribute inh 8649 * @aspect TypeCheck 8650 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:471 8651 */ 8652 @ASTNodeAnnotation.Attribute 8653 public TypeDecl typeVoid() { 8654 TypeDecl typeVoid_value = getParent().Define_typeVoid(this, null); 8655 8656 return typeVoid_value; 8657 } 8658 /** 8659 * @attribute inh 8660 * @aspect TypeCheck 8661 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:586 8662 */ 8663 /** 8664 * @attribute inh 8665 * @aspect TypeCheck 8666 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:586 8667 */ 8668 @ASTNodeAnnotation.Attribute 8669 public TypeDecl enclosingInstance() { 8670 TypeDecl enclosingInstance_value = getParent().Define_enclosingInstance(this, null); 8671 8672 return enclosingInstance_value; 8673 } 8674 /** 8675 * @attribute inh 8676 * @aspect TypeHierarchyCheck 8677 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:165 8678 */ 8679 /** 8680 * @attribute inh 8681 * @aspect TypeHierarchyCheck 8682 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:165 8683 */ 8684 @ASTNodeAnnotation.Attribute 8685 public boolean inExplicitConstructorInvocation() { 8686 ASTNode$State state = state(); 8687 if (inExplicitConstructorInvocation_computed) { 8688 return inExplicitConstructorInvocation_value; 8689 } 8690 boolean intermediate = state.INTERMEDIATE_VALUE; 8691 state.INTERMEDIATE_VALUE = false; 8692 int num = state.boundariesCrossed; 8693 boolean isFinal = this.is$Final(); 8694 inExplicitConstructorInvocation_value = getParent().Define_inExplicitConstructorInvocation(this, null); 8695 if (isFinal && num == state().boundariesCrossed) { 8696 inExplicitConstructorInvocation_computed = true; 8697 } else { 8698 } 8699 state.INTERMEDIATE_VALUE |= intermediate; 8700 8701 return inExplicitConstructorInvocation_value; 8702 } 8703 /** 8704 * @apilevel internal 8705 */ 8706 protected boolean inExplicitConstructorInvocation_computed = false; 8707 /** 8708 * @apilevel internal 8709 */ 8710 protected boolean inExplicitConstructorInvocation_value; 8711 /** 8712 * @apilevel internal 8713 */ 8714 private void inExplicitConstructorInvocation_reset() { 8715 inExplicitConstructorInvocation_computed = false; 8716 } 8717 /** 8718 * @attribute inh 8719 * @aspect TypeHierarchyCheck 8720 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:183 8721 */ 8722 /** 8723 * @attribute inh 8724 * @aspect TypeHierarchyCheck 8725 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:183 8726 */ 8727 @ASTNodeAnnotation.Attribute 8728 public boolean inStaticContext() { 8729 ASTNode$State state = state(); 8730 if (inStaticContext_computed) { 8731 return inStaticContext_value; 8732 } 8733 boolean intermediate = state.INTERMEDIATE_VALUE; 8734 state.INTERMEDIATE_VALUE = false; 8735 int num = state.boundariesCrossed; 8736 boolean isFinal = this.is$Final(); 8737 inStaticContext_value = getParent().Define_inStaticContext(this, null); 8738 if (isFinal && num == state().boundariesCrossed) { 8739 inStaticContext_computed = true; 8740 } else { 8741 } 8742 state.INTERMEDIATE_VALUE |= intermediate; 8743 8744 return inStaticContext_value; 8745 } 8746 /** 8747 * @apilevel internal 8748 */ 8749 protected boolean inStaticContext_computed = false; 8750 /** 8751 * @apilevel internal 8752 */ 8753 protected boolean inStaticContext_value; 8754 /** 8755 * @apilevel internal 8756 */ 8757 private void inStaticContext_reset() { 8758 inStaticContext_computed = false; 8759 } 8760 /** 8761 * @attribute inh 8762 * @aspect Annotations 8763 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:353 8764 */ 8765 /** 8766 * @attribute inh 8767 * @aspect Annotations 8768 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:353 8769 */ 8770 @ASTNodeAnnotation.Attribute 8771 public boolean withinSuppressWarnings(String annot) { 8772 boolean withinSuppressWarnings_String_value = getParent().Define_withinSuppressWarnings(this, null, annot); 8773 8774 return withinSuppressWarnings_String_value; 8775 } 8776 /** 8777 * @attribute inh 8778 * @aspect Annotations 8779 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:456 8780 */ 8781 /** 8782 * @attribute inh 8783 * @aspect Annotations 8784 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:456 8785 */ 8786 @ASTNodeAnnotation.Attribute 8787 public boolean withinDeprecatedAnnotation() { 8788 boolean withinDeprecatedAnnotation_value = getParent().Define_withinDeprecatedAnnotation(this, null); 8789 8790 return withinDeprecatedAnnotation_value; 8791 } 8792 /** 8793 * @attribute inh 8794 * @aspect LookupParTypeDecl 8795 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1488 8796 */ 8797 /** 8798 * @attribute inh 8799 * @aspect LookupParTypeDecl 8800 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1488 8801 */ 8802 @ASTNodeAnnotation.Attribute 8803 public TypeDecl typeWildcard() { 8804 TypeDecl typeWildcard_value = getParent().Define_typeWildcard(this, null); 8805 8806 return typeWildcard_value; 8807 } 8808 /** 8809 * @attribute inh 8810 * @aspect LookupParTypeDecl 8811 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1502 8812 */ 8813 /** 8814 * @attribute inh 8815 * @aspect LookupParTypeDecl 8816 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1502 8817 */ 8818 @ASTNodeAnnotation.Attribute 8819 public TypeDecl lookupWildcardExtends(TypeDecl typeDecl) { 8820 TypeDecl lookupWildcardExtends_TypeDecl_value = getParent().Define_lookupWildcardExtends(this, null, typeDecl); 8821 8822 return lookupWildcardExtends_TypeDecl_value; 8823 } 8824 /** 8825 * @attribute inh 8826 * @aspect LookupParTypeDecl 8827 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1516 8828 */ 8829 /** 8830 * @attribute inh 8831 * @aspect LookupParTypeDecl 8832 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1516 8833 */ 8834 @ASTNodeAnnotation.Attribute 8835 public TypeDecl lookupWildcardSuper(TypeDecl typeDecl) { 8836 TypeDecl lookupWildcardSuper_TypeDecl_value = getParent().Define_lookupWildcardSuper(this, null, typeDecl); 8837 8838 return lookupWildcardSuper_TypeDecl_value; 8839 } 8840 /** 8841 * @attribute inh 8842 * @aspect LookupParTypeDecl 8843 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1539 8844 */ 8845 /** 8846 * @attribute inh 8847 * @aspect LookupParTypeDecl 8848 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1539 8849 */ 8850 @ASTNodeAnnotation.Attribute 8851 public LUBType lookupLUBType(Collection bounds) { 8852 LUBType lookupLUBType_Collection_value = getParent().Define_lookupLUBType(this, null, bounds); 8853 8854 return lookupLUBType_Collection_value; 8855 } 8856 /** 8857 * @attribute inh 8858 * @aspect LookupParTypeDecl 8859 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1580 8860 */ 8861 /** 8862 * @attribute inh 8863 * @aspect LookupParTypeDecl 8864 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1580 8865 */ 8866 @ASTNodeAnnotation.Attribute 8867 public GLBType lookupGLBType(ArrayList bounds) { 8868 GLBType lookupGLBType_ArrayList_value = getParent().Define_lookupGLBType(this, null, bounds); 8869 8870 return lookupGLBType_ArrayList_value; 8871 } 8872 /** 8873 * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:42 8874 * @apilevel internal 8875 */ 8876 public TypeDecl Define_componentType(ASTNode caller, ASTNode child) { 8877 if (caller == arrayType_value) { 8878 // @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:41 8879 return this; 8880 } 8881 else { 8882 return getParent().Define_componentType(this, caller); 8883 } 8884 } 8885 protected boolean canDefine_componentType(ASTNode caller, ASTNode child) { 8886 return true; 8887 } 8888 /** 8889 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:37 8890 * @apilevel internal 8891 */ 8892 public boolean Define_isDest(ASTNode caller, ASTNode child) { 8893 int childIndex = this.getIndexOfChild(caller); 8894 return false; 8895 } 8896 protected boolean canDefine_isDest(ASTNode caller, ASTNode child) { 8897 return true; 8898 } 8899 /** 8900 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47 8901 * @apilevel internal 8902 */ 8903 public boolean Define_isSource(ASTNode caller, ASTNode child) { 8904 int childIndex = this.getIndexOfChild(caller); 8905 return true; 8906 } 8907 protected boolean canDefine_isSource(ASTNode caller, ASTNode child) { 8908 return true; 8909 } 8910 /** 8911 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:272 8912 * @apilevel internal 8913 */ 8914 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) { 8915 int childIndex = this.getIndexOfChild(caller); 8916 { 8917 //if (b instanceof MethodDecl || b instanceof MemberTypeDecl) { 8918 if (!v.isInstanceVariable() && !v.isClassVariable()) { 8919 if (v.hostType() != this) { 8920 return isDAbefore(v); 8921 } 8922 return false; 8923 } 8924 if (b instanceof FieldDeclaration && !((FieldDeclaration) b).isStatic() && v.isClassVariable()) { 8925 return true; 8926 } 8927 8928 if (b instanceof MethodDecl) { 8929 return true; 8930 } 8931 if (b instanceof MemberTypeDecl && v.isBlank() && v.isFinal() && v.hostType() == this) { 8932 return true; 8933 } 8934 if (v.isClassVariable() || v.isInstanceVariable()) { 8935 if (v.isFinal() && v.hostType() != this && instanceOf(v.hostType())) { 8936 return true; 8937 } 8938 8939 boolean search = true; 8940 if (b instanceof ConstructorDecl) { 8941 search = false; 8942 } 8943 8944 for (int i = getNumBodyDecl() - 1; i >= 0; --i) { 8945 BodyDecl decl = getBodyDecl(i); 8946 if (b == decl) { 8947 search = false; 8948 continue; 8949 } 8950 if (search) { 8951 continue; 8952 } 8953 if (decl instanceof FieldDeclaration) { 8954 FieldDeclaration f = (FieldDeclaration) decl; 8955 if ((v.isClassVariable() && f.isStatic()) || (v.isInstanceVariable() && !f.isStatic())) { 8956 boolean c = f.isDAafter(v); 8957 //System.err.println("DefiniteAssignment: is " + v.name() + " DA after index " + i + ", " + f + ": " + c); 8958 return c; 8959 //return f.isDAafter(v); 8960 } 8961 } else if (decl instanceof StaticInitializer && v.isClassVariable()) { 8962 StaticInitializer si = (StaticInitializer) decl; 8963 return si.isDAafter(v); 8964 } else if (decl instanceof InstanceInitializer && v.isInstanceVariable()) { 8965 InstanceInitializer ii = (InstanceInitializer) decl; 8966 return ii.isDAafter(v); 8967 } 8968 } 8969 } 8970 return isDAbefore(v); 8971 } 8972 } 8973 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) { 8974 return true; 8975 } 8976 /** 8977 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:804 8978 * @apilevel internal 8979 */ 8980 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) { 8981 int childIndex = this.getIndexOfChild(caller); 8982 { 8983 if (b instanceof MethodDecl || b instanceof MemberTypeDecl) { 8984 return false; 8985 } 8986 if (v.isClassVariable() || v.isInstanceVariable()) { 8987 boolean search = true; 8988 if (b instanceof ConstructorDecl) { 8989 search = false; 8990 } 8991 8992 for (int i = getNumBodyDecl() - 1; i >= 0; --i) { 8993 BodyDecl decl = getBodyDecl(i); 8994 if (b == decl) { 8995 search = false; 8996 continue; 8997 } 8998 if (search) { 8999 continue; 9000 } 9001 if (decl instanceof FieldDeclaration) { 9002 FieldDeclaration f = (FieldDeclaration) decl; 9003 //System.err.println(" working on field " + f.name() + " which is child " + i); 9004 if (f == v) { 9005 return !f.hasInit(); 9006 } 9007 if ((v.isClassVariable() && f.isStatic()) || (v.isInstanceVariable() && !f.isStatic())) { 9008 return f.isDUafter(v); 9009 } 9010 //System.err.println(" field " + f.name() + " can not affect " + v.name()); 9011 } else if (decl instanceof StaticInitializer && v.isClassVariable()) { 9012 StaticInitializer si = (StaticInitializer) decl; 9013 //System.err.println(" working on static initializer which is child " + i); 9014 return si.isDUafter(v); 9015 } else if (decl instanceof InstanceInitializer && v.isInstanceVariable()) { 9016 InstanceInitializer ii = (InstanceInitializer) decl; 9017 //System.err.println(" working on instance initializer which is child " + i); 9018 return ii.isDUafter(v); 9019 } 9020 } 9021 } 9022 //System.err.println("Reached TypeDecl when searching for DU for variable"); 9023 return isDUbefore(v); 9024 } 9025 } 9026 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) { 9027 return true; 9028 } 9029 /** 9030 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:35 9031 * @apilevel internal 9032 */ 9033 public Collection Define_lookupConstructor(ASTNode caller, ASTNode child) { 9034 int childIndex = this.getIndexOfChild(caller); 9035 return constructors(); 9036 } 9037 protected boolean canDefine_lookupConstructor(ASTNode caller, ASTNode child) { 9038 return true; 9039 } 9040 /** 9041 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:40 9042 * @apilevel internal 9043 */ 9044 public Collection Define_lookupSuperConstructor(ASTNode caller, ASTNode child) { 9045 int childIndex = this.getIndexOfChild(caller); 9046 return lookupSuperConstructor(); 9047 } 9048 protected boolean canDefine_lookupSuperConstructor(ASTNode caller, ASTNode child) { 9049 return true; 9050 } 9051 /** 9052 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46 9053 * @apilevel internal 9054 */ 9055 public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) { 9056 if (caller == getBodyDeclListNoTransform()) { 9057 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:56 9058 int i = caller.getIndexOfChild(child); 9059 return unqualifiedLookupMethod(name); 9060 } 9061 else { 9062 return getParent().Define_lookupMethod(this, caller, name); 9063 } 9064 } 9065 protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) { 9066 return true; 9067 } 9068 /** 9069 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197 9070 * @apilevel internal 9071 */ 9072 public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) { 9073 if (caller == getBodyDeclListNoTransform()) { 9074 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:472 9075 int index = caller.getIndexOfChild(child); 9076 return localLookupType(name); 9077 } 9078 else { 9079 return getParent().Define_lookupType(this, caller, name); 9080 } 9081 } 9082 protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) { 9083 return true; 9084 } 9085 /** 9086 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 9087 * @apilevel internal 9088 */ 9089 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 9090 if (caller == getBodyDeclListNoTransform()) { 9091 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:48 9092 int i = caller.getIndexOfChild(child); 9093 { 9094 SimpleSet list = memberFields(name); 9095 if (!list.isEmpty()) { 9096 return list; 9097 } 9098 list = lookupVariable(name); 9099 if (inStaticContext() || isStatic()) { 9100 list = removeInstanceVariables(list); 9101 } 9102 return list; 9103 } 9104 } 9105 else { 9106 return getParent().Define_lookupVariable(this, caller, name); 9107 } 9108 } 9109 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 9110 return true; 9111 } 9112 /** 9113 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:419 9114 * @apilevel internal 9115 */ 9116 public boolean Define_mayBePublic(ASTNode caller, ASTNode child) { 9117 if (caller == getBodyDeclListNoTransform()) { 9118 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:342 9119 int childIndex = caller.getIndexOfChild(child); 9120 return false; 9121 } 9122 else if (caller == getModifiersNoTransform()) { 9123 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:292 9124 return true; 9125 } 9126 else { 9127 return getParent().Define_mayBePublic(this, caller); 9128 } 9129 } 9130 protected boolean canDefine_mayBePublic(ASTNode caller, ASTNode child) { 9131 return true; 9132 } 9133 /** 9134 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:421 9135 * @apilevel internal 9136 */ 9137 public boolean Define_mayBeProtected(ASTNode caller, ASTNode child) { 9138 if (caller == getBodyDeclListNoTransform()) { 9139 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:343 9140 int childIndex = caller.getIndexOfChild(child); 9141 return false; 9142 } 9143 else if (caller == getModifiersNoTransform()) { 9144 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:293 9145 return true; 9146 } 9147 else { 9148 return getParent().Define_mayBeProtected(this, caller); 9149 } 9150 } 9151 protected boolean canDefine_mayBeProtected(ASTNode caller, ASTNode child) { 9152 return true; 9153 } 9154 /** 9155 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:420 9156 * @apilevel internal 9157 */ 9158 public boolean Define_mayBePrivate(ASTNode caller, ASTNode child) { 9159 if (caller == getBodyDeclListNoTransform()) { 9160 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:344 9161 int childIndex = caller.getIndexOfChild(child); 9162 return false; 9163 } 9164 else if (caller == getModifiersNoTransform()) { 9165 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:294 9166 return true; 9167 } 9168 else { 9169 return getParent().Define_mayBePrivate(this, caller); 9170 } 9171 } 9172 protected boolean canDefine_mayBePrivate(ASTNode caller, ASTNode child) { 9173 return true; 9174 } 9175 /** 9176 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:424 9177 * @apilevel internal 9178 */ 9179 public boolean Define_mayBeAbstract(ASTNode caller, ASTNode child) { 9180 if (caller == getBodyDeclListNoTransform()) { 9181 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:347 9182 int childIndex = caller.getIndexOfChild(child); 9183 return false; 9184 } 9185 else if (caller == getModifiersNoTransform()) { 9186 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:295 9187 return true; 9188 } 9189 else { 9190 return getParent().Define_mayBeAbstract(this, caller); 9191 } 9192 } 9193 protected boolean canDefine_mayBeAbstract(ASTNode caller, ASTNode child) { 9194 return true; 9195 } 9196 /** 9197 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:422 9198 * @apilevel internal 9199 */ 9200 public boolean Define_mayBeStatic(ASTNode caller, ASTNode child) { 9201 if (caller == getBodyDeclListNoTransform()) { 9202 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:345 9203 int childIndex = caller.getIndexOfChild(child); 9204 return false; 9205 } 9206 else if (caller == getModifiersNoTransform()) { 9207 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:296 9208 return true; 9209 } 9210 else { 9211 return getParent().Define_mayBeStatic(this, caller); 9212 } 9213 } 9214 protected boolean canDefine_mayBeStatic(ASTNode caller, ASTNode child) { 9215 return true; 9216 } 9217 /** 9218 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:427 9219 * @apilevel internal 9220 */ 9221 public boolean Define_mayBeStrictfp(ASTNode caller, ASTNode child) { 9222 if (caller == getBodyDeclListNoTransform()) { 9223 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:350 9224 int childIndex = caller.getIndexOfChild(child); 9225 return false; 9226 } 9227 else if (caller == getModifiersNoTransform()) { 9228 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:297 9229 return true; 9230 } 9231 else { 9232 return getParent().Define_mayBeStrictfp(this, caller); 9233 } 9234 } 9235 protected boolean canDefine_mayBeStrictfp(ASTNode caller, ASTNode child) { 9236 return true; 9237 } 9238 /** 9239 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423 9240 * @apilevel internal 9241 */ 9242 public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) { 9243 if (caller == getBodyDeclListNoTransform()) { 9244 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:346 9245 int childIndex = caller.getIndexOfChild(child); 9246 return false; 9247 } 9248 else { 9249 return getParent().Define_mayBeFinal(this, caller); 9250 } 9251 } 9252 protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) { 9253 return true; 9254 } 9255 /** 9256 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:425 9257 * @apilevel internal 9258 */ 9259 public boolean Define_mayBeVolatile(ASTNode caller, ASTNode child) { 9260 if (caller == getBodyDeclListNoTransform()) { 9261 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:348 9262 int childIndex = caller.getIndexOfChild(child); 9263 return false; 9264 } 9265 else { 9266 return getParent().Define_mayBeVolatile(this, caller); 9267 } 9268 } 9269 protected boolean canDefine_mayBeVolatile(ASTNode caller, ASTNode child) { 9270 return true; 9271 } 9272 /** 9273 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:426 9274 * @apilevel internal 9275 */ 9276 public boolean Define_mayBeTransient(ASTNode caller, ASTNode child) { 9277 if (caller == getBodyDeclListNoTransform()) { 9278 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:349 9279 int childIndex = caller.getIndexOfChild(child); 9280 return false; 9281 } 9282 else { 9283 return getParent().Define_mayBeTransient(this, caller); 9284 } 9285 } 9286 protected boolean canDefine_mayBeTransient(ASTNode caller, ASTNode child) { 9287 return true; 9288 } 9289 /** 9290 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:428 9291 * @apilevel internal 9292 */ 9293 public boolean Define_mayBeSynchronized(ASTNode caller, ASTNode child) { 9294 if (caller == getBodyDeclListNoTransform()) { 9295 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:351 9296 int childIndex = caller.getIndexOfChild(child); 9297 return false; 9298 } 9299 else { 9300 return getParent().Define_mayBeSynchronized(this, caller); 9301 } 9302 } 9303 protected boolean canDefine_mayBeSynchronized(ASTNode caller, ASTNode child) { 9304 return true; 9305 } 9306 /** 9307 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:429 9308 * @apilevel internal 9309 */ 9310 public boolean Define_mayBeNative(ASTNode caller, ASTNode child) { 9311 if (caller == getBodyDeclListNoTransform()) { 9312 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:352 9313 int childIndex = caller.getIndexOfChild(child); 9314 return false; 9315 } 9316 else { 9317 return getParent().Define_mayBeNative(this, caller); 9318 } 9319 } 9320 protected boolean canDefine_mayBeNative(ASTNode caller, ASTNode child) { 9321 return true; 9322 } 9323 /** 9324 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:30 9325 * @apilevel internal 9326 */ 9327 public VariableScope Define_outerScope(ASTNode caller, ASTNode child) { 9328 int childIndex = this.getIndexOfChild(caller); 9329 return this; 9330 } 9331 protected boolean canDefine_outerScope(ASTNode caller, ASTNode child) { 9332 return true; 9333 } 9334 /** 9335 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:441 9336 * @apilevel internal 9337 */ 9338 public boolean Define_insideLoop(ASTNode caller, ASTNode child) { 9339 if (caller == getBodyDeclListNoTransform()) { 9340 // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:444 9341 int i = caller.getIndexOfChild(child); 9342 return false; 9343 } 9344 else { 9345 return getParent().Define_insideLoop(this, caller); 9346 } 9347 } 9348 protected boolean canDefine_insideLoop(ASTNode caller, ASTNode child) { 9349 return true; 9350 } 9351 /** 9352 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:449 9353 * @apilevel internal 9354 */ 9355 public boolean Define_insideSwitch(ASTNode caller, ASTNode child) { 9356 if (caller == getBodyDeclListNoTransform()) { 9357 // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:451 9358 int i = caller.getIndexOfChild(child); 9359 return false; 9360 } 9361 else { 9362 return getParent().Define_insideSwitch(this, caller); 9363 } 9364 } 9365 protected boolean canDefine_insideSwitch(ASTNode caller, ASTNode child) { 9366 return true; 9367 } 9368 /** 9369 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 9370 * @apilevel internal 9371 */ 9372 public NameType Define_nameType(ASTNode caller, ASTNode child) { 9373 if (caller == getBodyDeclListNoTransform()) { 9374 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:141 9375 int childIndex = caller.getIndexOfChild(child); 9376 return NameType.EXPRESSION_NAME; 9377 } 9378 else { 9379 return getParent().Define_nameType(this, caller); 9380 } 9381 } 9382 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 9383 return true; 9384 } 9385 /** 9386 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:240 9387 * @apilevel internal 9388 */ 9389 public boolean Define_isAnonymous(ASTNode caller, ASTNode child) { 9390 int childIndex = this.getIndexOfChild(caller); 9391 return false; 9392 } 9393 protected boolean canDefine_isAnonymous(ASTNode caller, ASTNode child) { 9394 return true; 9395 } 9396 /** 9397 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:544 9398 * @apilevel internal 9399 */ 9400 public TypeDecl Define_enclosingType(ASTNode caller, ASTNode child) { 9401 if (caller == getBodyDeclListNoTransform()) { 9402 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:540 9403 int childIndex = caller.getIndexOfChild(child); 9404 return this; 9405 } 9406 else { 9407 return getParent().Define_enclosingType(this, caller); 9408 } 9409 } 9410 protected boolean canDefine_enclosingType(ASTNode caller, ASTNode child) { 9411 return true; 9412 } 9413 /** 9414 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:569 9415 * @apilevel internal 9416 */ 9417 public boolean Define_isNestedType(ASTNode caller, ASTNode child) { 9418 if (caller == getBodyDeclListNoTransform()) { 9419 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:571 9420 int childIndex = caller.getIndexOfChild(child); 9421 return true; 9422 } 9423 else { 9424 return getParent().Define_isNestedType(this, caller); 9425 } 9426 } 9427 protected boolean canDefine_isNestedType(ASTNode caller, ASTNode child) { 9428 return true; 9429 } 9430 /** 9431 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:591 9432 * @apilevel internal 9433 */ 9434 public boolean Define_isLocalClass(ASTNode caller, ASTNode child) { 9435 if (caller == getBodyDeclListNoTransform()) { 9436 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:593 9437 int childIndex = caller.getIndexOfChild(child); 9438 return false; 9439 } 9440 else { 9441 return getParent().Define_isLocalClass(this, caller); 9442 } 9443 } 9444 protected boolean canDefine_isLocalClass(ASTNode caller, ASTNode child) { 9445 return true; 9446 } 9447 /** 9448 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:71 9449 * @apilevel internal 9450 */ 9451 public TypeDecl Define_hostType(ASTNode caller, ASTNode child) { 9452 int childIndex = this.getIndexOfChild(caller); 9453 return this; 9454 } 9455 protected boolean canDefine_hostType(ASTNode caller, ASTNode child) { 9456 return true; 9457 } 9458 /** 9459 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:472 9460 * @apilevel internal 9461 */ 9462 public TypeDecl Define_returnType(ASTNode caller, ASTNode child) { 9463 if (caller == getBodyDeclListNoTransform()) { 9464 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:473 9465 int childIndex = caller.getIndexOfChild(child); 9466 return typeVoid(); 9467 } 9468 else { 9469 return getParent().Define_returnType(this, caller); 9470 } 9471 } 9472 protected boolean canDefine_returnType(ASTNode caller, ASTNode child) { 9473 return true; 9474 } 9475 /** 9476 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:586 9477 * @apilevel internal 9478 */ 9479 public TypeDecl Define_enclosingInstance(ASTNode caller, ASTNode child) { 9480 if (caller == getBodyDeclListNoTransform()) { 9481 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:590 9482 int index = caller.getIndexOfChild(child); 9483 { 9484 if (getBodyDecl(index) instanceof MemberTypeDecl && !((MemberTypeDecl) getBodyDecl(index)).typeDecl().isInnerType()) { 9485 return null; 9486 } 9487 if (getBodyDecl(index) instanceof ConstructorDecl) { 9488 return enclosingInstance(); 9489 } 9490 return this; 9491 } 9492 } 9493 else { 9494 return getParent().Define_enclosingInstance(this, caller); 9495 } 9496 } 9497 protected boolean canDefine_enclosingInstance(ASTNode caller, ASTNode child) { 9498 return true; 9499 } 9500 /** 9501 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:32 9502 * @apilevel internal 9503 */ 9504 public String Define_methodHost(ASTNode caller, ASTNode child) { 9505 int childIndex = this.getIndexOfChild(caller); 9506 return typeName(); 9507 } 9508 protected boolean canDefine_methodHost(ASTNode caller, ASTNode child) { 9509 return true; 9510 } 9511 /** 9512 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:182 9513 * @apilevel internal 9514 */ 9515 public boolean Define_inStaticContext(ASTNode caller, ASTNode child) { 9516 int childIndex = this.getIndexOfChild(caller); 9517 return isStatic() || inStaticContext(); 9518 } 9519 protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) { 9520 return true; 9521 } 9522 /** 9523 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:283 9524 * @apilevel internal 9525 */ 9526 public boolean Define_reportUnreachable(ASTNode caller, ASTNode child) { 9527 int childIndex = this.getIndexOfChild(caller); 9528 return true; 9529 } 9530 protected boolean canDefine_reportUnreachable(ASTNode caller, ASTNode child) { 9531 return true; 9532 } 9533 /** 9534 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:96 9535 * @apilevel internal 9536 */ 9537 public boolean Define_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) { 9538 if (caller == getModifiersNoTransform()) { 9539 // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:101 9540 return name.equals("TYPE"); 9541 } 9542 else { 9543 return getParent().Define_mayUseAnnotationTarget(this, caller, name); 9544 } 9545 } 9546 protected boolean canDefine_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) { 9547 return true; 9548 } 9549 /** 9550 * @apilevel internal 9551 */ 9552 public ASTNode rewriteTo() { 9553 return super.rewriteTo(); 9554 } 9555 }