Symtab.java revision 3763:120957324d6e
1/* 2 * Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26package com.sun.tools.javac.code; 27 28import java.util.Collection; 29import java.util.Collections; 30import java.util.EnumSet; 31import java.util.HashMap; 32import java.util.LinkedHashMap; 33import java.util.Map; 34 35import javax.lang.model.element.ElementVisitor; 36 37import com.sun.tools.javac.code.Scope.WriteableScope; 38import com.sun.tools.javac.code.Symbol.ClassSymbol; 39import com.sun.tools.javac.code.Symbol.Completer; 40import com.sun.tools.javac.code.Symbol.CompletionFailure; 41import com.sun.tools.javac.code.Symbol.MethodSymbol; 42import com.sun.tools.javac.code.Symbol.ModuleSymbol; 43import com.sun.tools.javac.code.Symbol.PackageSymbol; 44import com.sun.tools.javac.code.Symbol.TypeSymbol; 45import com.sun.tools.javac.code.Symbol.VarSymbol; 46import com.sun.tools.javac.code.Type.BottomType; 47import com.sun.tools.javac.code.Type.ClassType; 48import com.sun.tools.javac.code.Type.ErrorType; 49import com.sun.tools.javac.code.Type.JCPrimitiveType; 50import com.sun.tools.javac.code.Type.JCVoidType; 51import com.sun.tools.javac.code.Type.MethodType; 52import com.sun.tools.javac.code.Type.UnknownType; 53import com.sun.tools.javac.comp.Modules; 54import com.sun.tools.javac.util.Assert; 55import com.sun.tools.javac.util.Context; 56import com.sun.tools.javac.util.Convert; 57import com.sun.tools.javac.util.DefinedBy; 58import com.sun.tools.javac.util.DefinedBy.Api; 59import com.sun.tools.javac.util.Iterators; 60import com.sun.tools.javac.util.JavacMessages; 61import com.sun.tools.javac.util.List; 62import com.sun.tools.javac.util.Name; 63import com.sun.tools.javac.util.Names; 64import com.sun.tools.javac.util.Options; 65 66import static com.sun.tools.javac.code.Flags.*; 67import static com.sun.tools.javac.code.Kinds.Kind.*; 68import static com.sun.tools.javac.code.TypeTag.*; 69 70/** A class that defines all predefined constants and operators 71 * as well as special classes such as java.lang.Object, which need 72 * to be known to the compiler. All symbols are held in instance 73 * fields. This makes it possible to work in multiple concurrent 74 * projects, which might use different class files for library classes. 75 * 76 * <p><b>This is NOT part of any supported API. 77 * If you write code that depends on this, you do so at your own risk. 78 * This code and its internal interfaces are subject to change or 79 * deletion without notice.</b> 80 */ 81public class Symtab { 82 /** The context key for the symbol table. */ 83 protected static final Context.Key<Symtab> symtabKey = new Context.Key<>(); 84 85 /** Get the symbol table instance. */ 86 public static Symtab instance(Context context) { 87 Symtab instance = context.get(symtabKey); 88 if (instance == null) 89 instance = new Symtab(context); 90 return instance; 91 } 92 93 /** Builtin types. 94 */ 95 public final JCPrimitiveType byteType = new JCPrimitiveType(BYTE, null); 96 public final JCPrimitiveType charType = new JCPrimitiveType(CHAR, null); 97 public final JCPrimitiveType shortType = new JCPrimitiveType(SHORT, null); 98 public final JCPrimitiveType intType = new JCPrimitiveType(INT, null); 99 public final JCPrimitiveType longType = new JCPrimitiveType(LONG, null); 100 public final JCPrimitiveType floatType = new JCPrimitiveType(FLOAT, null); 101 public final JCPrimitiveType doubleType = new JCPrimitiveType(DOUBLE, null); 102 public final JCPrimitiveType booleanType = new JCPrimitiveType(BOOLEAN, null); 103 public final Type botType = new BottomType(); 104 public final JCVoidType voidType = new JCVoidType(); 105 106 private final Names names; 107 private final JavacMessages messages; 108 private final Completer initialCompleter; 109 private final Completer moduleCompleter; 110 111 /** A symbol for the unnamed module. 112 */ 113 public final ModuleSymbol unnamedModule; 114 115 /** The error module. 116 */ 117 public final ModuleSymbol errModule; 118 119 /** A symbol for no module, for use with -source 8 or less 120 */ 121 public final ModuleSymbol noModule; 122 123 /** A symbol for the root package. 124 */ 125 public final PackageSymbol rootPackage; 126 127 /** A symbol that stands for a missing symbol. 128 */ 129 public final TypeSymbol noSymbol; 130 131 /** The error symbol. 132 */ 133 public final ClassSymbol errSymbol; 134 135 /** The unknown symbol. 136 */ 137 public final ClassSymbol unknownSymbol; 138 139 /** A value for the errType, with a originalType of noType */ 140 public final Type errType; 141 142 /** A value for the unknown type. */ 143 public final Type unknownType; 144 145 /** The builtin type of all arrays. */ 146 public final ClassSymbol arrayClass; 147 public final MethodSymbol arrayCloneMethod; 148 149 /** VGJ: The (singleton) type of all bound types. */ 150 public final ClassSymbol boundClass; 151 152 /** The builtin type of all methods. */ 153 public final ClassSymbol methodClass; 154 155 /** A symbol for the java.base module. 156 */ 157 public final ModuleSymbol java_base; 158 159 /** Predefined types. 160 */ 161 public final Type objectType; 162 public final Type objectsType; 163 public final Type classType; 164 public final Type classLoaderType; 165 public final Type stringType; 166 public final Type stringBufferType; 167 public final Type stringBuilderType; 168 public final Type cloneableType; 169 public final Type serializableType; 170 public final Type serializedLambdaType; 171 public final Type varHandleType; 172 public final Type methodHandleType; 173 public final Type methodHandleLookupType; 174 public final Type methodTypeType; 175 public final Type nativeHeaderType; 176 public final Type throwableType; 177 public final Type errorType; 178 public final Type interruptedExceptionType; 179 public final Type illegalArgumentExceptionType; 180 public final Type exceptionType; 181 public final Type runtimeExceptionType; 182 public final Type classNotFoundExceptionType; 183 public final Type noClassDefFoundErrorType; 184 public final Type noSuchFieldErrorType; 185 public final Type assertionErrorType; 186 public final Type cloneNotSupportedExceptionType; 187 public final Type annotationType; 188 public final TypeSymbol enumSym; 189 public final Type listType; 190 public final Type collectionsType; 191 public final Type comparableType; 192 public final Type comparatorType; 193 public final Type arraysType; 194 public final Type iterableType; 195 public final Type iteratorType; 196 public final Type annotationTargetType; 197 public final Type overrideType; 198 public final Type retentionType; 199 public final Type deprecatedType; 200 public final Type suppressWarningsType; 201 public final Type supplierType; 202 public final Type inheritedType; 203 public final Type profileType; 204 public final Type proprietaryType; 205 public final Type systemType; 206 public final Type autoCloseableType; 207 public final Type trustMeType; 208 public final Type lambdaMetafactory; 209 public final Type stringConcatFactory; 210 public final Type repeatableType; 211 public final Type documentedType; 212 public final Type elementTypeType; 213 public final Type functionalInterfaceType; 214 215 /** The symbol representing the length field of an array. 216 */ 217 public final VarSymbol lengthVar; 218 219 /** The symbol representing the final finalize method on enums */ 220 public final MethodSymbol enumFinalFinalize; 221 222 /** The symbol representing the close method on TWR AutoCloseable type */ 223 public final MethodSymbol autoCloseableClose; 224 225 /** The predefined type that belongs to a tag. 226 */ 227 public final Type[] typeOfTag = new Type[TypeTag.getTypeTagCount()]; 228 229 /** The name of the class that belongs to a basic type tag. 230 */ 231 public final Name[] boxedName = new Name[TypeTag.getTypeTagCount()]; 232 233 /** A hashtable containing the encountered top-level and member classes, 234 * indexed by flat names. The table does not contain local classes. 235 * It should be updated from the outside to reflect classes defined 236 * by compiled source files. 237 */ 238 private final Map<Name, Map<ModuleSymbol,ClassSymbol>> classes = new HashMap<>(); 239 240 /** A hashtable containing the encountered packages. 241 * the table should be updated from outside to reflect packages defined 242 * by compiled source files. 243 */ 244 private final Map<Name, Map<ModuleSymbol,PackageSymbol>> packages = new HashMap<>(); 245 246 /** A hashtable giving the encountered modules. 247 */ 248 private final Map<Name, ModuleSymbol> modules = new LinkedHashMap<>(); 249 250 public void initType(Type type, ClassSymbol c) { 251 type.tsym = c; 252 typeOfTag[type.getTag().ordinal()] = type; 253 } 254 255 public void initType(Type type, String name) { 256 initType( 257 type, 258 new ClassSymbol( 259 PUBLIC, names.fromString(name), type, rootPackage)); 260 } 261 262 public void initType(Type type, String name, String bname) { 263 initType(type, name); 264 boxedName[type.getTag().ordinal()] = names.fromString("java.lang." + bname); 265 } 266 267 /** The class symbol that owns all predefined symbols. 268 */ 269 public final ClassSymbol predefClass; 270 271 /** Enter a class into symbol table. 272 * @param s The name of the class. 273 */ 274 private Type enterClass(String s) { 275 return enterClass(java_base, names.fromString(s)).type; 276 } 277 278 public void synthesizeEmptyInterfaceIfMissing(final Type type) { 279 final Completer completer = type.tsym.completer; 280 type.tsym.completer = new Completer() { 281 @Override 282 public void complete(Symbol sym) throws CompletionFailure { 283 try { 284 completer.complete(sym); 285 } catch (CompletionFailure e) { 286 sym.flags_field |= (PUBLIC | INTERFACE); 287 ((ClassType) sym.type).supertype_field = objectType; 288 } 289 } 290 291 @Override 292 public boolean isTerminal() { 293 return completer.isTerminal(); 294 } 295 }; 296 } 297 298 public void synthesizeBoxTypeIfMissing(final Type type) { 299 ClassSymbol sym = enterClass(java_base, boxedName[type.getTag().ordinal()]); 300 final Completer completer = sym.completer; 301 sym.completer = new Completer() { 302 @Override 303 public void complete(Symbol sym) throws CompletionFailure { 304 try { 305 completer.complete(sym); 306 } catch (CompletionFailure e) { 307 sym.flags_field |= PUBLIC; 308 ((ClassType) sym.type).supertype_field = objectType; 309 MethodSymbol boxMethod = 310 new MethodSymbol(PUBLIC | STATIC, names.valueOf, 311 new MethodType(List.of(type), sym.type, 312 List.<Type>nil(), methodClass), 313 sym); 314 sym.members().enter(boxMethod); 315 MethodSymbol unboxMethod = 316 new MethodSymbol(PUBLIC, 317 type.tsym.name.append(names.Value), // x.intValue() 318 new MethodType(List.<Type>nil(), type, 319 List.<Type>nil(), methodClass), 320 sym); 321 sym.members().enter(unboxMethod); 322 } 323 } 324 325 @Override 326 public boolean isTerminal() { 327 return completer.isTerminal(); 328 } 329 }; 330 } 331 332 // Enter a synthetic class that is used to mark classes in ct.sym. 333 // This class does not have a class file. 334 private Type enterSyntheticAnnotation(String name) { 335 // for now, leave the module null, to prevent problems from synthesizing the 336 // existence of a class in any specific module, including noModule 337 ClassType type = (ClassType)enterClass(java_base, names.fromString(name)).type; 338 ClassSymbol sym = (ClassSymbol)type.tsym; 339 sym.completer = Completer.NULL_COMPLETER; 340 sym.flags_field = PUBLIC|ACYCLIC|ANNOTATION|INTERFACE; 341 sym.erasure_field = type; 342 sym.members_field = WriteableScope.create(sym); 343 type.typarams_field = List.nil(); 344 type.allparams_field = List.nil(); 345 type.supertype_field = annotationType; 346 type.interfaces_field = List.nil(); 347 return type; 348 } 349 350 /** Constructor; enters all predefined identifiers and operators 351 * into symbol table. 352 */ 353 protected Symtab(Context context) throws CompletionFailure { 354 context.put(symtabKey, this); 355 356 names = Names.instance(context); 357 358 // Create the unknown type 359 unknownType = new UnknownType(); 360 361 messages = JavacMessages.instance(context); 362 363 rootPackage = new PackageSymbol(names.empty, null); 364 365 // create the basic builtin symbols 366 unnamedModule = new ModuleSymbol(names.empty, null) { 367 { 368 directives = List.nil(); 369 exports = List.nil(); 370 provides = List.nil(); 371 uses = List.nil(); 372 ModuleSymbol java_base = enterModule(names.java_base); 373 com.sun.tools.javac.code.Directive.RequiresDirective d = 374 new com.sun.tools.javac.code.Directive.RequiresDirective(java_base, 375 EnumSet.of(com.sun.tools.javac.code.Directive.RequiresFlag.MANDATED)); 376 requires = List.of(d); 377 } 378 @Override 379 public String toString() { 380 return messages.getLocalizedString("compiler.misc.unnamed.module"); 381 } 382 }; 383 addRootPackageFor(unnamedModule); 384 unnamedModule.enclosedPackages = unnamedModule.enclosedPackages.prepend(unnamedModule.unnamedPackage); 385 386 errModule = new ModuleSymbol(names.empty, null) { 387 { 388 directives = List.nil(); 389 exports = List.nil(); 390 provides = List.nil(); 391 uses = List.nil(); 392 ModuleSymbol java_base = enterModule(names.java_base); 393 com.sun.tools.javac.code.Directive.RequiresDirective d = 394 new com.sun.tools.javac.code.Directive.RequiresDirective(java_base, 395 EnumSet.of(com.sun.tools.javac.code.Directive.RequiresFlag.MANDATED)); 396 requires = List.of(d); 397 } 398 }; 399 addRootPackageFor(errModule); 400 401 noModule = new ModuleSymbol(names.empty, null) { 402 @Override public boolean isNoModule() { 403 return true; 404 } 405 }; 406 addRootPackageFor(noModule); 407 408 noSymbol = new TypeSymbol(NIL, 0, names.empty, Type.noType, rootPackage) { 409 @Override @DefinedBy(Api.LANGUAGE_MODEL) 410 public <R, P> R accept(ElementVisitor<R, P> v, P p) { 411 return v.visitUnknown(this, p); 412 } 413 }; 414 415 // create the error symbols 416 errSymbol = new ClassSymbol(PUBLIC|STATIC|ACYCLIC, names.any, null, rootPackage); 417 errType = new ErrorType(errSymbol, Type.noType); 418 419 unknownSymbol = new ClassSymbol(PUBLIC|STATIC|ACYCLIC, names.fromString("<any?>"), null, rootPackage); 420 unknownSymbol.members_field = new Scope.ErrorScope(unknownSymbol); 421 unknownSymbol.type = unknownType; 422 423 // initialize builtin types 424 initType(byteType, "byte", "Byte"); 425 initType(shortType, "short", "Short"); 426 initType(charType, "char", "Character"); 427 initType(intType, "int", "Integer"); 428 initType(longType, "long", "Long"); 429 initType(floatType, "float", "Float"); 430 initType(doubleType, "double", "Double"); 431 initType(booleanType, "boolean", "Boolean"); 432 initType(voidType, "void", "Void"); 433 initType(botType, "<nulltype>"); 434 initType(errType, errSymbol); 435 initType(unknownType, unknownSymbol); 436 437 // the builtin class of all arrays 438 arrayClass = new ClassSymbol(PUBLIC|ACYCLIC, names.Array, noSymbol); 439 440 // VGJ 441 boundClass = new ClassSymbol(PUBLIC|ACYCLIC, names.Bound, noSymbol); 442 boundClass.members_field = new Scope.ErrorScope(boundClass); 443 444 // the builtin class of all methods 445 methodClass = new ClassSymbol(PUBLIC|ACYCLIC, names.Method, noSymbol); 446 methodClass.members_field = new Scope.ErrorScope(boundClass); 447 448 // Create class to hold all predefined constants and operations. 449 predefClass = new ClassSymbol(PUBLIC|ACYCLIC, names.empty, rootPackage); 450 WriteableScope scope = WriteableScope.create(predefClass); 451 predefClass.members_field = scope; 452 453 // Get the initial completer for Symbols from the ClassFinder 454 initialCompleter = ClassFinder.instance(context).getCompleter(); 455 rootPackage.members_field = WriteableScope.create(rootPackage); 456 457 // Enter symbols for basic types. 458 scope.enter(byteType.tsym); 459 scope.enter(shortType.tsym); 460 scope.enter(charType.tsym); 461 scope.enter(intType.tsym); 462 scope.enter(longType.tsym); 463 scope.enter(floatType.tsym); 464 scope.enter(doubleType.tsym); 465 scope.enter(booleanType.tsym); 466 scope.enter(errType.tsym); 467 468 // Enter symbol for the errSymbol 469 scope.enter(errSymbol); 470 471 Source source = Source.instance(context); 472 Options options = Options.instance(context); 473 boolean noModules = options.isSet("noModules"); 474 if (source.allowModules() && !noModules) { 475 java_base = enterModule(names.java_base); 476 //avoid completing java.base during the Symtab initialization 477 java_base.completer = Completer.NULL_COMPLETER; 478 java_base.visiblePackages = Collections.emptyMap(); 479 } else { 480 java_base = noModule; 481 } 482 483 // Get the initial completer for ModuleSymbols from Modules 484 moduleCompleter = Modules.instance(context).getCompleter(); 485 486 // Enter predefined classes. All are assumed to be in the java.base module. 487 objectType = enterClass("java.lang.Object"); 488 objectsType = enterClass("java.util.Objects"); 489 classType = enterClass("java.lang.Class"); 490 stringType = enterClass("java.lang.String"); 491 stringBufferType = enterClass("java.lang.StringBuffer"); 492 stringBuilderType = enterClass("java.lang.StringBuilder"); 493 cloneableType = enterClass("java.lang.Cloneable"); 494 throwableType = enterClass("java.lang.Throwable"); 495 serializableType = enterClass("java.io.Serializable"); 496 serializedLambdaType = enterClass("java.lang.invoke.SerializedLambda"); 497 varHandleType = enterClass("java.lang.invoke.VarHandle"); 498 methodHandleType = enterClass("java.lang.invoke.MethodHandle"); 499 methodHandleLookupType = enterClass("java.lang.invoke.MethodHandles$Lookup"); 500 methodTypeType = enterClass("java.lang.invoke.MethodType"); 501 errorType = enterClass("java.lang.Error"); 502 illegalArgumentExceptionType = enterClass("java.lang.IllegalArgumentException"); 503 interruptedExceptionType = enterClass("java.lang.InterruptedException"); 504 exceptionType = enterClass("java.lang.Exception"); 505 runtimeExceptionType = enterClass("java.lang.RuntimeException"); 506 classNotFoundExceptionType = enterClass("java.lang.ClassNotFoundException"); 507 noClassDefFoundErrorType = enterClass("java.lang.NoClassDefFoundError"); 508 noSuchFieldErrorType = enterClass("java.lang.NoSuchFieldError"); 509 assertionErrorType = enterClass("java.lang.AssertionError"); 510 cloneNotSupportedExceptionType = enterClass("java.lang.CloneNotSupportedException"); 511 annotationType = enterClass("java.lang.annotation.Annotation"); 512 classLoaderType = enterClass("java.lang.ClassLoader"); 513 enumSym = enterClass(java_base, names.java_lang_Enum); 514 enumFinalFinalize = 515 new MethodSymbol(PROTECTED|FINAL|HYPOTHETICAL, 516 names.finalize, 517 new MethodType(List.<Type>nil(), voidType, 518 List.<Type>nil(), methodClass), 519 enumSym); 520 listType = enterClass("java.util.List"); 521 collectionsType = enterClass("java.util.Collections"); 522 comparableType = enterClass("java.lang.Comparable"); 523 comparatorType = enterClass("java.util.Comparator"); 524 arraysType = enterClass("java.util.Arrays"); 525 iterableType = enterClass("java.lang.Iterable"); 526 iteratorType = enterClass("java.util.Iterator"); 527 annotationTargetType = enterClass("java.lang.annotation.Target"); 528 overrideType = enterClass("java.lang.Override"); 529 retentionType = enterClass("java.lang.annotation.Retention"); 530 deprecatedType = enterClass("java.lang.Deprecated"); 531 suppressWarningsType = enterClass("java.lang.SuppressWarnings"); 532 supplierType = enterClass("java.util.function.Supplier"); 533 inheritedType = enterClass("java.lang.annotation.Inherited"); 534 repeatableType = enterClass("java.lang.annotation.Repeatable"); 535 documentedType = enterClass("java.lang.annotation.Documented"); 536 elementTypeType = enterClass("java.lang.annotation.ElementType"); 537 systemType = enterClass("java.lang.System"); 538 autoCloseableType = enterClass("java.lang.AutoCloseable"); 539 autoCloseableClose = new MethodSymbol(PUBLIC, 540 names.close, 541 new MethodType(List.<Type>nil(), voidType, 542 List.of(exceptionType), methodClass), 543 autoCloseableType.tsym); 544 trustMeType = enterClass("java.lang.SafeVarargs"); 545 nativeHeaderType = enterClass("java.lang.annotation.Native"); 546 lambdaMetafactory = enterClass("java.lang.invoke.LambdaMetafactory"); 547 stringConcatFactory = enterClass("java.lang.invoke.StringConcatFactory"); 548 functionalInterfaceType = enterClass("java.lang.FunctionalInterface"); 549 550 synthesizeEmptyInterfaceIfMissing(autoCloseableType); 551 synthesizeEmptyInterfaceIfMissing(cloneableType); 552 synthesizeEmptyInterfaceIfMissing(serializableType); 553 synthesizeEmptyInterfaceIfMissing(lambdaMetafactory); 554 synthesizeEmptyInterfaceIfMissing(serializedLambdaType); 555 synthesizeEmptyInterfaceIfMissing(stringConcatFactory); 556 synthesizeBoxTypeIfMissing(doubleType); 557 synthesizeBoxTypeIfMissing(floatType); 558 synthesizeBoxTypeIfMissing(voidType); 559 560 // Enter a synthetic class that is used to mark internal 561 // proprietary classes in ct.sym. This class does not have a 562 // class file. 563 proprietaryType = enterSyntheticAnnotation("sun.Proprietary+Annotation"); 564 565 // Enter a synthetic class that is used to provide profile info for 566 // classes in ct.sym. This class does not have a class file. 567 profileType = enterSyntheticAnnotation("jdk.Profile+Annotation"); 568 MethodSymbol m = new MethodSymbol(PUBLIC | ABSTRACT, names.value, intType, profileType.tsym); 569 profileType.tsym.members().enter(m); 570 571 // Enter a class for arrays. 572 // The class implements java.lang.Cloneable and java.io.Serializable. 573 // It has a final length field and a clone method. 574 ClassType arrayClassType = (ClassType)arrayClass.type; 575 arrayClassType.supertype_field = objectType; 576 arrayClassType.interfaces_field = List.of(cloneableType, serializableType); 577 arrayClass.members_field = WriteableScope.create(arrayClass); 578 lengthVar = new VarSymbol( 579 PUBLIC | FINAL, 580 names.length, 581 intType, 582 arrayClass); 583 arrayClass.members().enter(lengthVar); 584 arrayCloneMethod = new MethodSymbol( 585 PUBLIC, 586 names.clone, 587 new MethodType(List.<Type>nil(), objectType, 588 List.<Type>nil(), methodClass), 589 arrayClass); 590 arrayClass.members().enter(arrayCloneMethod); 591 592 if (java_base != noModule) 593 java_base.completer = sym -> moduleCompleter.complete(sym); //bootstrap issues 594 595 } 596 597 /** Define a new class given its name and owner. 598 */ 599 public ClassSymbol defineClass(Name name, Symbol owner) { 600 ClassSymbol c = new ClassSymbol(0, name, owner); 601 c.completer = initialCompleter; 602 return c; 603 } 604 605 /** Create a new toplevel or member class symbol with given name 606 * and owner and enter in `classes' unless already there. 607 */ 608 public ClassSymbol enterClass(ModuleSymbol msym, Name name, TypeSymbol owner) { 609 Assert.checkNonNull(msym); 610 Name flatname = TypeSymbol.formFlatName(name, owner); 611 ClassSymbol c = getClass(msym, flatname); 612 if (c == null) { 613 c = defineClass(name, owner); 614 doEnterClass(msym, c); 615 } else if ((c.name != name || c.owner != owner) && owner.kind == TYP && c.owner.kind == PCK) { 616 // reassign fields of classes that might have been loaded with 617 // their flat names. 618 c.owner.members().remove(c); 619 c.name = name; 620 c.owner = owner; 621 c.fullname = ClassSymbol.formFullName(name, owner); 622 } 623 return c; 624 } 625 626 public ClassSymbol getClass(ModuleSymbol msym, Name flatName) { 627 Assert.checkNonNull(msym, () -> flatName.toString()); 628 return classes.getOrDefault(flatName, Collections.emptyMap()).get(msym); 629 } 630 631 public PackageSymbol lookupPackage(ModuleSymbol msym, Name flatName) { 632 Assert.checkNonNull(msym); 633 634 if (flatName.isEmpty()) { 635 //unnamed packages only from the current module - visiblePackages contains *root* package, not unnamed package! 636 return msym.unnamedPackage; 637 } 638 639 if (msym == noModule) { 640 return enterPackage(msym, flatName); 641 } 642 643 msym.complete(); 644 645 PackageSymbol pack; 646 647 pack = msym.visiblePackages.get(flatName); 648 649 if (pack != null) 650 return pack; 651 652 pack = getPackage(msym, flatName); 653 654 if (pack != null && pack.exists()) 655 return pack; 656 657 boolean dependsOnUnnamed = msym.requires != null && 658 msym.requires.stream() 659 .map(rd -> rd.module) 660 .anyMatch(mod -> mod == unnamedModule); 661 662 if (dependsOnUnnamed) { 663 //msyms depends on the unnamed module, for which we generally don't know 664 //the list of packages it "exports" ahead of time. So try to lookup the package in the 665 //current module, and in the unnamed module and see if it exists in one of them 666 PackageSymbol unnamedPack = getPackage(unnamedModule, flatName); 667 668 if (unnamedPack != null && unnamedPack.exists()) { 669 msym.visiblePackages.put(unnamedPack.fullname, unnamedPack); 670 return unnamedPack; 671 } 672 673 pack = enterPackage(msym, flatName); 674 pack.complete(); 675 if (pack.exists()) 676 return pack; 677 678 unnamedPack = enterPackage(unnamedModule, flatName); 679 unnamedPack.complete(); 680 if (unnamedPack.exists()) { 681 msym.visiblePackages.put(unnamedPack.fullname, unnamedPack); 682 return unnamedPack; 683 } 684 685 return pack; 686 } 687 688 return enterPackage(msym, flatName); 689 } 690 691 private static final Map<ModuleSymbol, ClassSymbol> EMPTY = new HashMap<>(); 692 693 public void removeClass(ModuleSymbol msym, Name flatName) { 694 classes.getOrDefault(flatName, EMPTY).remove(msym); 695 } 696 697 public Iterable<ClassSymbol> getAllClasses() { 698 return () -> Iterators.createCompoundIterator(classes.values(), v -> v.values().iterator()); 699 } 700 701 private void doEnterClass(ModuleSymbol msym, ClassSymbol cs) { 702 classes.computeIfAbsent(cs.flatname, n -> new HashMap<>()).put(msym, cs); 703 } 704 705 /** Create a new member or toplevel class symbol with given flat name 706 * and enter in `classes' unless already there. 707 */ 708 public ClassSymbol enterClass(ModuleSymbol msym, Name flatname) { 709 Assert.checkNonNull(msym); 710 PackageSymbol ps = lookupPackage(msym, Convert.packagePart(flatname)); 711 Assert.checkNonNull(ps); 712 Assert.checkNonNull(ps.modle); 713 ClassSymbol c = getClass(ps.modle, flatname); 714 if (c == null) { 715 c = defineClass(Convert.shortName(flatname), ps); 716 doEnterClass(ps.modle, c); 717 return c; 718 } else 719 return c; 720 } 721 722 /** Check to see if a package exists, given its fully qualified name. 723 */ 724 public boolean packageExists(ModuleSymbol msym, Name fullname) { 725 Assert.checkNonNull(msym); 726 return lookupPackage(msym, fullname).exists(); 727 } 728 729 /** Make a package, given its fully qualified name. 730 */ 731 public PackageSymbol enterPackage(ModuleSymbol currModule, Name fullname) { 732 Assert.checkNonNull(currModule); 733 PackageSymbol p = getPackage(currModule, fullname); 734 if (p == null) { 735 Assert.check(!fullname.isEmpty(), () -> "rootPackage missing!; currModule: " + currModule); 736 p = new PackageSymbol( 737 Convert.shortName(fullname), 738 enterPackage(currModule, Convert.packagePart(fullname))); 739 p.completer = initialCompleter; 740 p.modle = currModule; 741 doEnterPackage(currModule, p); 742 } 743 return p; 744 } 745 746 private void doEnterPackage(ModuleSymbol msym, PackageSymbol pack) { 747 packages.computeIfAbsent(pack.fullname, n -> new HashMap<>()).put(msym, pack); 748 msym.enclosedPackages = msym.enclosedPackages.prepend(pack); 749 } 750 751 private void addRootPackageFor(ModuleSymbol module) { 752 doEnterPackage(module, rootPackage); 753 PackageSymbol unnamedPackage = new PackageSymbol(names.empty, rootPackage) { 754 @Override 755 public String toString() { 756 return messages.getLocalizedString("compiler.misc.unnamed.package"); 757 } 758 }; 759 unnamedPackage.modle = module; 760 unnamedPackage.completer = sym -> initialCompleter.complete(sym); 761 module.unnamedPackage = unnamedPackage; 762 } 763 764 public PackageSymbol getPackage(ModuleSymbol module, Name fullname) { 765 return packages.getOrDefault(fullname, Collections.emptyMap()).get(module); 766 } 767 768 public ModuleSymbol enterModule(Name name) { 769 ModuleSymbol msym = modules.get(name); 770 if (msym == null) { 771 msym = ModuleSymbol.create(name, names.module_info); 772 addRootPackageFor(msym); 773 msym.completer = sym -> moduleCompleter.complete(sym); //bootstrap issues 774 modules.put(name, msym); 775 } 776 return msym; 777 } 778 779 public ModuleSymbol getModule(Name name) { 780 return modules.get(name); 781 } 782 783 //temporary: 784 public ModuleSymbol inferModule(Name packageName) { 785 if (packageName.isEmpty()) 786 return java_base == noModule ? noModule : unnamedModule;//! 787 788 ModuleSymbol msym = null; 789 Map<ModuleSymbol,PackageSymbol> map = packages.get(packageName); 790 if (map == null) 791 return null; 792 for (Map.Entry<ModuleSymbol,PackageSymbol> e: map.entrySet()) { 793 if (!e.getValue().members().isEmpty()) { 794 if (msym == null) { 795 msym = e.getKey(); 796 } else { 797 return null; 798 } 799 } 800 } 801 return msym; 802 } 803 804 public List<ModuleSymbol> listPackageModules(Name packageName) { 805 if (packageName.isEmpty()) 806 return List.nil(); 807 808 List<ModuleSymbol> result = List.nil(); 809 Map<ModuleSymbol,PackageSymbol> map = packages.get(packageName); 810 if (map != null) { 811 for (Map.Entry<ModuleSymbol, PackageSymbol> e: map.entrySet()) { 812 if (!e.getValue().members().isEmpty()) { 813 result = result.prepend(e.getKey()); 814 } 815 } 816 } 817 return result; 818 } 819 820 public Collection<ModuleSymbol> getAllModules() { 821 return modules.values(); 822 } 823} 824