@Override public void visitTopLevel(JCCompilationUnit tree) { JavaFileObject prev = log.useSource(tree.sourcefile); boolean addEnv = false; boolean isPkgInfo = tree.sourcefile.isNameCompatible("package-info", JavaFileObject.Kind.SOURCE); if (tree.pid != null) { tree.packge = reader.enterPackage(TreeInfo.fullName(tree.pid)); if (tree.packageAnnotations.nonEmpty() || pkginfoOpt == PkgInfo.ALWAYS) { if (isPkgInfo) { addEnv = true; } else { log.error(tree.packageAnnotations.head.pos(), "pkg.annotations.sb.in.package-info.java"); } } } else { tree.packge = syms.unnamedPackage; } tree.packge.complete(); // Find all classes in package. Env<AttrContext> topEnv = topLevelEnv(tree); // Save environment of package-info.java file. if (isPkgInfo) { Env<AttrContext> env0 = typeEnvs.get(tree.packge); if (env0 == null) { typeEnvs.put(tree.packge, topEnv); } else { JCCompilationUnit tree0 = env0.toplevel; if (!fileManager.isSameFile(tree.sourcefile, tree0.sourcefile)) { log.warning( tree.pid != null ? tree.pid.pos() : null, "pkg-info.already.seen", tree.packge); if (addEnv || (tree0.packageAnnotations.isEmpty() && tree.docComments != null && tree.docComments.get(tree) != null)) { typeEnvs.put(tree.packge, topEnv); } } } for (Symbol q = tree.packge; q != null && q.kind == PCK; q = q.owner) q.flags_field |= EXISTS; Name name = names.package_info; ClassSymbol c = reader.enterClass(name, tree.packge); c.flatname = names.fromString(tree.packge + "." + name); c.sourcefile = tree.sourcefile; c.completer = null; c.members_field = new Scope(c); tree.packge.package_info = c; } classEnter(tree.defs, topEnv); if (addEnv) { todo.append(topEnv); } log.useSource(prev); result = null; }
public void visitClassDef(JCClassDecl tree) { Symbol owner = env.info.scope.owner; Scope enclScope = enterScope(env); ClassSymbol c; if (owner.kind == PCK) { // We are seeing a toplevel class. PackageSymbol packge = (PackageSymbol) owner; for (Symbol q = packge; q != null && q.kind == PCK; q = q.owner) q.flags_field |= EXISTS; c = reader.enterClass(tree.name, packge); packge.members().enterIfAbsent(c); if ((tree.mods.flags & PUBLIC) != 0 && !classNameMatchesFileName(c, env)) { log.error(tree.pos(), "class.public.should.be.in.file", tree.name); } } else { if (!tree.name.isEmpty() && !chk.checkUniqueClassName(tree.pos(), tree.name, enclScope)) { result = null; return; } if (owner.kind == TYP) { // We are seeing a member class. c = reader.enterClass(tree.name, (TypeSymbol) owner); if ((owner.flags_field & INTERFACE) != 0) { tree.mods.flags |= PUBLIC | STATIC; } } else { // We are seeing a local class. c = reader.defineClass(tree.name, owner); c.flatname = chk.localClassName(c); if (!c.name.isEmpty()) chk.checkTransparentClass(tree.pos(), c, env.info.scope); } } tree.sym = c; // Enter class into `compiled' table and enclosing scope. if (chk.compiled.get(c.flatname) != null) { duplicateClass(tree.pos(), c); result = types.createErrorType(tree.name, (TypeSymbol) owner, Type.noType); tree.sym = (ClassSymbol) result.tsym; return; } chk.compiled.put(c.flatname, c); enclScope.enter(c); // Set up an environment for class block and store in `typeEnvs' // table, to be retrieved later in memberEnter and attribution. Env<AttrContext> localEnv = classEnv(tree, env); typeEnvs.put(c, localEnv); // Fill out class fields. c.completer = memberEnter; c.flags_field = chk.checkFlags(tree.pos(), tree.mods.flags, c, tree); c.sourcefile = env.toplevel.sourcefile; c.members_field = new Scope(c); ClassType ct = (ClassType) c.type; if (owner.kind != PCK && (c.flags_field & STATIC) == 0) { // We are seeing a local or inner class. // Set outer_field of this class to closest enclosing class // which contains this class in a non-static context // (its "enclosing instance class"), provided such a class exists. Symbol owner1 = owner; while ((owner1.kind & (VAR | MTH)) != 0 && (owner1.flags_field & STATIC) == 0) { owner1 = owner1.owner; } if (owner1.kind == TYP) { ct.setEnclosingType(owner1.type); } } // Enter type parameters. ct.typarams_field = classEnter(tree.typarams, localEnv); // Add non-local class to uncompleted, to make sure it will be // completed later. if (!c.isLocal() && uncompleted != null) uncompleted.append(c); // System.err.println("entering " + c.fullname + " in " + c.owner);//DEBUG // Recursively enter all member classes. classEnter(tree.defs, localEnv); result = c.type; }
/** Constructor; enters all predefined identifiers and operators into symbol table. */ private Symtab(Context context) throws CompletionFailure { super(); context.put(symtabKey, this); names = Name.Table.instance(context); byteType = new Type(TypeTags.BYTE, null); charType = new Type(TypeTags.CHAR, null); shortType = new Type(TypeTags.SHORT, null); intType = new Type(TypeTags.INT, null); longType = new Type(TypeTags.LONG, null); floatType = new Type(TypeTags.FLOAT, null); doubleType = new Type(TypeTags.DOUBLE, null); booleanType = new Type(TypeTags.BOOLEAN, null); voidType = new Type(TypeTags.VOID, null); botType = new Type(TypeTags.BOT, null); unknownType = new Type(TypeTags.UNKNOWN, null) { public boolean isSameType(Type that) { return true; } public boolean isSubType(Type that) { return false; } public boolean isSuperType(Type that) { return true; } }; rootPackage = new PackageSymbol(names.empty, null); emptyPackage = new PackageSymbol(names.emptyPackage, rootPackage); noSymbol = new TypeSymbol(0, names.empty, Type.noType, rootPackage); noSymbol.kind = Kinds.NIL; errSymbol = new ClassSymbol(PUBLIC | STATIC, names.any, null, rootPackage); errType = new ErrorType(errSymbol); initType(byteType, "byte", "Byte"); initType(shortType, "short", "Short"); initType(charType, "char", "Character"); initType(intType, "int", "Integer"); initType(longType, "long", "Long"); initType(floatType, "float", "Float"); initType(doubleType, "double", "Double"); initType(booleanType, "boolean", "Boolean"); initType(voidType, "void", "Void"); initType(botType, "<nulltype>"); initType(errType, errSymbol); initType(unknownType, "<any?>"); arrayClass = new ClassSymbol(PUBLIC, names.Array, noSymbol); methodClass = new ClassSymbol(PUBLIC, names.Method, noSymbol); predefClass = new ClassSymbol(PUBLIC, names.empty, rootPackage); Scope scope = new Scope(predefClass); predefClass.members_field = scope; scope.enter(byteType.tsym); scope.enter(shortType.tsym); scope.enter(charType.tsym); scope.enter(intType.tsym); scope.enter(longType.tsym); scope.enter(floatType.tsym); scope.enter(doubleType.tsym); scope.enter(booleanType.tsym); scope.enter(errType.tsym); classes.put(predefClass.fullname, predefClass); reader = ClassReader.instance(context); reader.init(this); objectType = enterClass("java.lang.Object"); classType = enterClass("java.lang.Class"); stringType = enterClass("java.lang.String"); stringBufferType = enterClass("java.lang.StringBuffer"); cloneableType = enterClass("java.lang.Cloneable"); throwableType = enterClass("java.lang.Throwable"); serializableType = enterClass("java.io.Serializable"); errorType = enterClass("java.lang.Error"); exceptionType = enterClass("java.lang.Exception"); runtimeExceptionType = enterClass("java.lang.RuntimeException"); classNotFoundExceptionType = enterClass("java.lang.ClassNotFoundException"); noClassDefFoundErrorType = enterClass("java.lang.NoClassDefFoundError"); assertionErrorType = enterClass("java.lang.AssertionError"); classLoaderType = enterClass("java.lang.ClassLoader"); ClassType arrayClassType = (ClassType) arrayClass.type; arrayClassType.supertype_field = objectType; arrayClassType.interfaces_field = List.make(cloneableType, serializableType); arrayClass.members_field = new Scope(arrayClass); lengthVar = new VarSymbol(PUBLIC | FINAL, names.length, intType, arrayClass); arrayClass.members().enter(lengthVar); Symbol cloneMethod = new MethodSymbol( PUBLIC, names.clone, new MethodType(Type.emptyList, objectType, Type.emptyList, methodClass), arrayClass); arrayClass.members().enter(cloneMethod); nullConst = enterConstant("null", botType); trueConst = enterConstant("true", booleanType.constType(new Integer(1))); falseConst = enterConstant("false", booleanType.constType(new Integer(0))); enterUnop("+", intType, intType, nop); enterUnop("+", longType, longType, nop); enterUnop("+", floatType, floatType, nop); enterUnop("+", doubleType, doubleType, nop); enterUnop("-", intType, intType, ineg); enterUnop("-", longType, longType, lneg); enterUnop("-", floatType, floatType, fneg); enterUnop("-", doubleType, doubleType, dneg); enterUnop("~", intType, intType, ixor); enterUnop("~", longType, longType, lxor); enterUnop("++", byteType, byteType, iadd); enterUnop("++", shortType, shortType, iadd); enterUnop("++", charType, charType, iadd); enterUnop("++", intType, intType, iadd); enterUnop("++", longType, longType, ladd); enterUnop("++", floatType, floatType, fadd); enterUnop("++", doubleType, doubleType, dadd); enterUnop("--", byteType, byteType, isub); enterUnop("--", shortType, shortType, isub); enterUnop("--", charType, charType, isub); enterUnop("--", intType, intType, isub); enterUnop("--", longType, longType, lsub); enterUnop("--", floatType, floatType, fsub); enterUnop("--", doubleType, doubleType, dsub); enterUnop("!", booleanType, booleanType, bool_not); nullcheck = enterUnop("<*nullchk*>", objectType, objectType, nullchk); enterBinop("+", stringType, stringType, stringType, string_add); enterBinop("+", stringType, intType, stringType, string_add); enterBinop("+", stringType, longType, stringType, string_add); enterBinop("+", stringType, floatType, stringType, string_add); enterBinop("+", stringType, doubleType, stringType, string_add); enterBinop("+", stringType, booleanType, stringType, string_add); enterBinop("+", stringType, objectType, stringType, string_add); enterBinop("+", stringType, botType, stringType, string_add); enterBinop("+", intType, stringType, stringType, string_add); enterBinop("+", longType, stringType, stringType, string_add); enterBinop("+", floatType, stringType, stringType, string_add); enterBinop("+", doubleType, stringType, stringType, string_add); enterBinop("+", booleanType, stringType, stringType, string_add); enterBinop("+", objectType, stringType, stringType, string_add); enterBinop("+", botType, stringType, stringType, string_add); enterBinop("+", intType, intType, intType, iadd); enterBinop("+", longType, longType, longType, ladd); enterBinop("+", floatType, floatType, floatType, fadd); enterBinop("+", doubleType, doubleType, doubleType, dadd); enterBinop("+", botType, botType, botType, error); enterBinop("+", botType, intType, botType, error); enterBinop("+", botType, longType, botType, error); enterBinop("+", botType, floatType, botType, error); enterBinop("+", botType, doubleType, botType, error); enterBinop("+", botType, booleanType, botType, error); enterBinop("+", botType, objectType, botType, error); enterBinop("+", intType, botType, botType, error); enterBinop("+", longType, botType, botType, error); enterBinop("+", floatType, botType, botType, error); enterBinop("+", doubleType, botType, botType, error); enterBinop("+", booleanType, botType, botType, error); enterBinop("+", objectType, botType, botType, error); enterBinop("-", intType, intType, intType, isub); enterBinop("-", longType, longType, longType, lsub); enterBinop("-", floatType, floatType, floatType, fsub); enterBinop("-", doubleType, doubleType, doubleType, dsub); enterBinop("*", intType, intType, intType, imul); enterBinop("*", longType, longType, longType, lmul); enterBinop("*", floatType, floatType, floatType, fmul); enterBinop("*", doubleType, doubleType, doubleType, dmul); enterBinop("/", intType, intType, intType, idiv); enterBinop("/", longType, longType, longType, ldiv); enterBinop("/", floatType, floatType, floatType, fdiv); enterBinop("/", doubleType, doubleType, doubleType, ddiv); enterBinop("%", intType, intType, intType, imod); enterBinop("%", longType, longType, longType, lmod); enterBinop("%", floatType, floatType, floatType, fmod); enterBinop("%", doubleType, doubleType, doubleType, dmod); enterBinop("&", booleanType, booleanType, booleanType, iand); enterBinop("&", intType, intType, intType, iand); enterBinop("&", longType, longType, longType, land); enterBinop("|", booleanType, booleanType, booleanType, ior); enterBinop("|", intType, intType, intType, ior); enterBinop("|", longType, longType, longType, lor); enterBinop("^", booleanType, booleanType, booleanType, ixor); enterBinop("^", intType, intType, intType, ixor); enterBinop("^", longType, longType, longType, lxor); enterBinop("<<", intType, intType, intType, ishl); enterBinop("<<", longType, intType, longType, lshl); enterBinop("<<", intType, longType, intType, ishll); enterBinop("<<", longType, longType, longType, lshll); enterBinop(">>", intType, intType, intType, ishr); enterBinop(">>", longType, intType, longType, lshr); enterBinop(">>", intType, longType, intType, ishrl); enterBinop(">>", longType, longType, longType, lshrl); enterBinop(">>>", intType, intType, intType, iushr); enterBinop(">>>", longType, intType, longType, lushr); enterBinop(">>>", intType, longType, intType, iushrl); enterBinop(">>>", longType, longType, longType, lushrl); enterBinop("<", intType, intType, booleanType, if_icmplt); enterBinop("<", longType, longType, booleanType, lcmp, iflt); enterBinop("<", floatType, floatType, booleanType, fcmpg, iflt); enterBinop("<", doubleType, doubleType, booleanType, dcmpg, iflt); enterBinop(">", intType, intType, booleanType, if_icmpgt); enterBinop(">", longType, longType, booleanType, lcmp, ifgt); enterBinop(">", floatType, floatType, booleanType, fcmpl, ifgt); enterBinop(">", doubleType, doubleType, booleanType, dcmpl, ifgt); enterBinop("<=", intType, intType, booleanType, if_icmple); enterBinop("<=", longType, longType, booleanType, lcmp, ifle); enterBinop("<=", floatType, floatType, booleanType, fcmpg, ifle); enterBinop("<=", doubleType, doubleType, booleanType, dcmpg, ifle); enterBinop(">=", intType, intType, booleanType, if_icmpge); enterBinop(">=", longType, longType, booleanType, lcmp, ifge); enterBinop(">=", floatType, floatType, booleanType, fcmpl, ifge); enterBinop(">=", doubleType, doubleType, booleanType, dcmpl, ifge); enterBinop("==", intType, intType, booleanType, if_icmpeq); enterBinop("==", longType, longType, booleanType, lcmp, ifeq); enterBinop("==", floatType, floatType, booleanType, fcmpl, ifeq); enterBinop("==", doubleType, doubleType, booleanType, dcmpl, ifeq); enterBinop("==", booleanType, booleanType, booleanType, if_icmpeq); enterBinop("==", objectType, objectType, booleanType, if_acmpeq); enterBinop("!=", intType, intType, booleanType, if_icmpne); enterBinop("!=", longType, longType, booleanType, lcmp, ifne); enterBinop("!=", floatType, floatType, booleanType, fcmpl, ifne); enterBinop("!=", doubleType, doubleType, booleanType, dcmpl, ifne); enterBinop("!=", booleanType, booleanType, booleanType, if_icmpne); enterBinop("!=", objectType, objectType, booleanType, if_acmpne); enterBinop("&&", booleanType, booleanType, booleanType, bool_and); enterBinop("||", booleanType, booleanType, booleanType, bool_or); }