001 /*
002 * Copyright 1999-2008 Sun Microsystems, Inc. All Rights Reserved.
003 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004 *
005 * This code is free software; you can redistribute it and/or modify it
006 * under the terms of the GNU General Public License version 2 only, as
007 * published by the Free Software Foundation. Sun designates this
008 * particular file as subject to the "Classpath" exception as provided
009 * by Sun in the LICENSE file that accompanied this code.
010 *
011 * This code is distributed in the hope that it will be useful, but WITHOUT
012 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014 * version 2 for more details (a copy is included in the LICENSE file that
015 * accompanied this code).
016 *
017 * You should have received a copy of the GNU General Public License version
018 * 2 along with this work; if not, write to the Free Software Foundation,
019 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020 *
021 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022 * CA 95054 USA or visit www.sun.com if you need additional information or
023 * have any questions.
024 */
025
026 package com.sun.tools.javac.comp;
027
028 import java.util.*;
029 import javax.tools.JavaFileObject;
030 import javax.tools.JavaFileManager;
031
032 import com.sun.tools.javac.code.*;
033 import com.sun.tools.javac.jvm.*;
034 import com.sun.tools.javac.tree.*;
035 import com.sun.tools.javac.util.*;
036 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
037 import com.sun.tools.javac.util.List;
038
039 import com.sun.tools.javac.code.Type.*;
040 import com.sun.tools.javac.code.Symbol.*;
041 import com.sun.tools.javac.tree.JCTree.*;
042
043 import static com.sun.tools.javac.code.Flags.*;
044 import static com.sun.tools.javac.code.Kinds.*;
045
046 /** This class enters symbols for all encountered definitions into
047 * the symbol table. The pass consists of two phases, organized as
048 * follows:
049 *
050 * <p>In the first phase, all class symbols are intered into their
051 * enclosing scope, descending recursively down the tree for classes
052 * which are members of other classes. The class symbols are given a
053 * MemberEnter object as completer.
054 *
055 * <p>In the second phase classes are completed using
056 * MemberEnter.complete(). Completion might occur on demand, but
057 * any classes that are not completed that way will be eventually
058 * completed by processing the `uncompleted' queue. Completion
059 * entails (1) determination of a class's parameters, supertype and
060 * interfaces, as well as (2) entering all symbols defined in the
061 * class into its scope, with the exception of class symbols which
062 * have been entered in phase 1. (2) depends on (1) having been
063 * completed for a class and all its superclasses and enclosing
064 * classes. That's why, after doing (1), we put classes in a
065 * `halfcompleted' queue. Only when we have performed (1) for a class
066 * and all it's superclasses and enclosing classes, we proceed to
067 * (2).
068 *
069 * <p>Whereas the first phase is organized as a sweep through all
070 * compiled syntax trees, the second phase is demand. Members of a
071 * class are entered when the contents of a class are first
072 * accessed. This is accomplished by installing completer objects in
073 * class symbols for compiled classes which invoke the member-enter
074 * phase for the corresponding class tree.
075 *
076 * <p>Classes migrate from one phase to the next via queues:
077 *
078 * <pre>
079 * class enter -> (Enter.uncompleted) --> member enter (1)
080 * -> (MemberEnter.halfcompleted) --> member enter (2)
081 * -> (Todo) --> attribute
082 * (only for toplevel classes)
083 * </pre>
084 *
085 * <p><b>This is NOT part of any API supported by Sun Microsystems. If
086 * you write code that depends on this, you do so at your own risk.
087 * This code and its internal interfaces are subject to change or
088 * deletion without notice.</b>
089 */
090 public class Enter extends JCTree.Visitor {
091 protected static final Context.Key<Enter> enterKey =
092 new Context.Key<Enter>();
093
094 Log log;
095 Symtab syms;
096 Check chk;
097 TreeMaker make;
098 ClassReader reader;
099 Annotate annotate;
100 MemberEnter memberEnter;
101 Types types;
102 Lint lint;
103 JavaFileManager fileManager;
104
105 private final Todo todo;
106
107 public static Enter instance(Context context) {
108 Enter instance = context.get(enterKey);
109 if (instance == null)
110 instance = new Enter(context);
111 return instance;
112 }
113
114 protected Enter(Context context) {
115 context.put(enterKey, this);
116
117 log = Log.instance(context);
118 reader = ClassReader.instance(context);
119 make = TreeMaker.instance(context);
120 syms = Symtab.instance(context);
121 chk = Check.instance(context);
122 memberEnter = MemberEnter.instance(context);
123 types = Types.instance(context);
124 annotate = Annotate.instance(context);
125 lint = Lint.instance(context);
126
127 predefClassDef = make.ClassDef(
128 make.Modifiers(PUBLIC),
129 syms.predefClass.name, null, null, null, null);
130 predefClassDef.sym = syms.predefClass;
131 todo = Todo.instance(context);
132 fileManager = context.get(JavaFileManager.class);
133 }
134
135 /** A hashtable mapping classes and packages to the environments current
136 * at the points of their definitions.
137 */
138 Map<TypeSymbol,Env<AttrContext>> typeEnvs =
139 new HashMap<TypeSymbol,Env<AttrContext>>();
140
141 /** Accessor for typeEnvs
142 */
143 public Env<AttrContext> getEnv(TypeSymbol sym) {
144 return typeEnvs.get(sym);
145 }
146
147 public Env<AttrContext> getClassEnv(TypeSymbol sym) {
148 Env<AttrContext> localEnv = getEnv(sym);
149 Env<AttrContext> lintEnv = localEnv;
150 while (lintEnv.info.lint == null)
151 lintEnv = lintEnv.next;
152 localEnv.info.lint = lintEnv.info.lint.augment(sym.attributes_field, sym.flags());
153 return localEnv;
154 }
155
156 /** The queue of all classes that might still need to be completed;
157 * saved and initialized by main().
158 */
159 ListBuffer<ClassSymbol> uncompleted;
160
161 /** A dummy class to serve as enclClass for toplevel environments.
162 */
163 private JCClassDecl predefClassDef;
164
165 /* ************************************************************************
166 * environment construction
167 *************************************************************************/
168
169
170 /** Create a fresh environment for class bodies.
171 * This will create a fresh scope for local symbols of a class, referred
172 * to by the environments info.scope field.
173 * This scope will contain
174 * - symbols for this and super
175 * - symbols for any type parameters
176 * In addition, it serves as an anchor for scopes of methods and initializers
177 * which are nested in this scope via Scope.dup().
178 * This scope should not be confused with the members scope of a class.
179 *
180 * @param tree The class definition.
181 * @param env The environment current outside of the class definition.
182 */
183 public Env<AttrContext> classEnv(JCClassDecl tree, Env<AttrContext> env) {
184 Env<AttrContext> localEnv =
185 env.dup(tree, env.info.dup(new Scope(tree.sym)));
186 localEnv.enclClass = tree;
187 localEnv.outer = env;
188 localEnv.info.isSelfCall = false;
189 localEnv.info.lint = null; // leave this to be filled in by Attr,
190 // when annotations have been processed
191 return localEnv;
192 }
193
194 /** Create a fresh environment for toplevels.
195 * @param tree The toplevel tree.
196 */
197 Env<AttrContext> topLevelEnv(JCCompilationUnit tree) {
198 Env<AttrContext> localEnv = new Env<AttrContext>(tree, new AttrContext());
199 localEnv.toplevel = tree;
200 localEnv.enclClass = predefClassDef;
201 tree.namedImportScope = new Scope.ImportScope(tree.packge);
202 tree.starImportScope = new Scope.ImportScope(tree.packge);
203 localEnv.info.scope = tree.namedImportScope;
204 localEnv.info.lint = lint;
205 return localEnv;
206 }
207
208 public Env<AttrContext> getTopLevelEnv(JCCompilationUnit tree) {
209 Env<AttrContext> localEnv = new Env<AttrContext>(tree, new AttrContext());
210 localEnv.toplevel = tree;
211 localEnv.enclClass = predefClassDef;
212 localEnv.info.scope = tree.namedImportScope;
213 localEnv.info.lint = lint;
214 return localEnv;
215 }
216
217 /** The scope in which a member definition in environment env is to be entered
218 * This is usually the environment's scope, except for class environments,
219 * where the local scope is for type variables, and the this and super symbol
220 * only, and members go into the class member scope.
221 */
222 Scope enterScope(Env<AttrContext> env) {
223 return (env.tree.getTag() == JCTree.CLASSDEF)
224 ? ((JCClassDecl) env.tree).sym.members_field
225 : env.info.scope;
226 }
227
228 // mgr: staging additions
229
230 /** Create a fresh environment for bracket bodies.
231 * @param tree The bracket expression.
232 * @param env The environment current outside of the bracket.
233 */
234 public Env<AttrContext> bracketEnv(JCExpression tree, Env<AttrContext> env) {
235 Env<AttrContext> localEnv =
236 env.dupBracket(tree, env.info.dup(new Scope(env.info.scope.owner)), tree);
237 localEnv.outer = env;
238 return localEnv;
239 }
240
241 /** Create a fresh environment for escape bodies.
242 * @param tree The escape expression.
243 * @param env The environment current outside of the escape.
244 */
245 public Env<AttrContext> escapeEnv(JCTree tree, Env<AttrContext> env) {
246 Env<AttrContext> localEnv =
247 env.dupEscape(tree, env.info.dup(new Scope(env.info.scope.owner)));
248 localEnv.outer = env;
249 return localEnv;
250 }
251
252 /* ************************************************************************
253 * Visitor methods for phase 1: class enter
254 *************************************************************************/
255
256 /** Visitor argument: the current environment.
257 */
258 protected Env<AttrContext> env;
259
260 /** Visitor result: the computed type.
261 */
262 Type result;
263
264 /** Visitor method: enter all classes in given tree, catching any
265 * completion failure exceptions. Return the tree's type.
266 *
267 * @param tree The tree to be visited.
268 * @param env The environment visitor argument.
269 */
270 Type classEnter(JCTree tree, Env<AttrContext> env) {
271 Env<AttrContext> prevEnv = this.env;
272 try {
273 this.env = env;
274 tree.accept(this);
275 return result;
276 } catch (CompletionFailure ex) {
277 return chk.completionError(tree.pos(), ex);
278 } finally {
279 this.env = prevEnv;
280 }
281 }
282
283 /** Visitor method: enter classes of a list of trees, returning a list of types.
284 */
285 <T extends JCTree> List<Type> classEnter(List<T> trees, Env<AttrContext> env) {
286 ListBuffer<Type> ts = new ListBuffer<Type>();
287 for (List<T> l = trees; l.nonEmpty(); l = l.tail) {
288 Type t = classEnter(l.head, env);
289 if (t != null)
290 ts.append(t);
291 }
292 return ts.toList();
293 }
294
295 public void visitTopLevel(JCCompilationUnit tree) {
296 JavaFileObject prev = log.useSource(tree.sourcefile);
297 boolean addEnv = false;
298 boolean isPkgInfo = tree.sourcefile.isNameCompatible("package-info",
299 JavaFileObject.Kind.SOURCE);
300 if (tree.pid != null) {
301 tree.packge = reader.enterPackage(TreeInfo.fullName(tree.pid));
302 if (tree.packageAnnotations.nonEmpty()) {
303 if (isPkgInfo) {
304 addEnv = true;
305 } else {
306 log.error(tree.packageAnnotations.head.pos(),
307 "pkg.annotations.sb.in.package-info.java");
308 }
309 }
310 } else {
311 tree.packge = syms.unnamedPackage;
312 }
313 tree.packge.complete(); // Find all classes in package.
314 Env<AttrContext> env = topLevelEnv(tree);
315
316 // Save environment of package-info.java file.
317 if (isPkgInfo) {
318 Env<AttrContext> env0 = typeEnvs.get(tree.packge);
319 if (env0 == null) {
320 typeEnvs.put(tree.packge, env);
321 } else {
322 JCCompilationUnit tree0 = env0.toplevel;
323 if (!fileManager.isSameFile(tree.sourcefile, tree0.sourcefile)) {
324 log.warning(tree.pid != null ? tree.pid.pos()
325 : null,
326 "pkg-info.already.seen",
327 tree.packge);
328 if (addEnv || (tree0.packageAnnotations.isEmpty() &&
329 tree.docComments != null &&
330 tree.docComments.get(tree) != null)) {
331 typeEnvs.put(tree.packge, env);
332 }
333 }
334 }
335 }
336 classEnter(tree.defs, env);
337 if (addEnv) {
338 todo.append(env);
339 }
340 log.useSource(prev);
341 result = null;
342 }
343
344 public void visitClassDef(JCClassDecl tree) {
345 Symbol owner = env.info.scope.owner;
346 Scope enclScope = enterScope(env);
347 ClassSymbol c;
348 if (owner.kind == PCK) {
349 // We are seeing a toplevel class.
350 PackageSymbol packge = (PackageSymbol)owner;
351 for (Symbol q = packge; q != null && q.kind == PCK; q = q.owner)
352 q.flags_field |= EXISTS;
353 c = reader.enterClass(tree.name, packge);
354 packge.members().enterIfAbsent(c);
355 if ((tree.mods.flags & PUBLIC) != 0 && !classNameMatchesFileName(c, env)) {
356 log.error(tree.pos(),
357 "class.public.should.be.in.file", tree.name);
358 }
359 } else {
360 if (!tree.name.isEmpty() &&
361 !chk.checkUniqueClassName(tree.pos(), tree.name, enclScope)) {
362 result = null;
363 return;
364 }
365 if (owner.kind == TYP) {
366 // We are seeing a member class.
367 c = reader.enterClass(tree.name, (TypeSymbol)owner);
368 if ((owner.flags_field & INTERFACE) != 0) {
369 tree.mods.flags |= PUBLIC | STATIC;
370 }
371 } else {
372 // We are seeing a local class.
373 c = reader.defineClass(tree.name, owner);
374 c.flatname = chk.localClassName(c);
375 if (!c.name.isEmpty())
376 chk.checkTransparentClass(tree.pos(), c, env.info.scope);
377 }
378 }
379 tree.sym = c;
380
381 // Enter class into `compiled' table and enclosing scope.
382 if (chk.compiled.get(c.flatname) != null) {
383 duplicateClass(tree.pos(), c);
384 result = types.createErrorType(tree.name, (TypeSymbol)owner, Type.noType);
385 tree.sym = (ClassSymbol)result.tsym;
386 return;
387 }
388 chk.compiled.put(c.flatname, c);
389 enclScope.enter(c);
390
391 // Set up an environment for class block and store in `typeEnvs'
392 // table, to be retrieved later in memberEnter and attribution.
393 Env<AttrContext> localEnv = classEnv(tree, env);
394 typeEnvs.put(c, localEnv);
395
396 // Fill out class fields.
397 c.completer = memberEnter;
398 c.flags_field = chk.checkFlags(tree.pos(), tree.mods.flags, c, tree);
399 c.sourcefile = env.toplevel.sourcefile;
400 c.members_field = new Scope(c);
401
402 ClassType ct = (ClassType)c.type;
403 if (owner.kind != PCK && (c.flags_field & STATIC) == 0) {
404 // We are seeing a local or inner class.
405 // Set outer_field of this class to closest enclosing class
406 // which contains this class in a non-static context
407 // (its "enclosing instance class"), provided such a class exists.
408 Symbol owner1 = owner;
409 while ((owner1.kind & (VAR | MTH)) != 0 &&
410 (owner1.flags_field & STATIC) == 0) {
411 owner1 = owner1.owner;
412 }
413 if (owner1.kind == TYP) {
414 ct.setEnclosingType(owner1.type);
415 }
416 }
417
418 // Enter type parameters.
419 ct.typarams_field = classEnter(tree.typarams, localEnv);
420
421 // Add non-local class to uncompleted, to make sure it will be
422 // completed later.
423 if (!c.isLocal() && uncompleted != null) uncompleted.append(c);
424 // System.err.println("entering " + c.fullname + " in " + c.owner);//DEBUG
425
426 // Recursively enter all member classes.
427 classEnter(tree.defs, localEnv);
428
429 result = c.type;
430 }
431 //where
432 /** Does class have the same name as the file it appears in?
433 */
434 private static boolean classNameMatchesFileName(ClassSymbol c,
435 Env<AttrContext> env) {
436 return env.toplevel.sourcefile.isNameCompatible(c.name.toString(),
437 JavaFileObject.Kind.SOURCE);
438 }
439
440 /** Complain about a duplicate class. */
441 protected void duplicateClass(DiagnosticPosition pos, ClassSymbol c) {
442 log.error(pos, "duplicate.class", c.fullname);
443 }
444
445 /** Class enter visitor method for type parameters.
446 * Enter a symbol for type parameter in local scope, after checking that it
447 * is unique.
448 */
449 public void visitTypeParameter(JCTypeParameter tree) {
450 TypeVar a = (tree.type != null)
451 ? (TypeVar)tree.type
452 : new TypeVar(tree.name, env.info.scope.owner, syms.botType);
453 tree.type = a;
454 if (chk.checkUnique(tree.pos(), a.tsym, env.info.scope)) {
455 env.info.scope.enter(a.tsym);
456 }
457 result = a;
458 }
459
460 /** Default class enter visitor method: do nothing.
461 */
462 public void visitTree(JCTree tree) {
463 result = null;
464 }
465
466 /** Main method: enter all classes in a list of toplevel trees.
467 * @param trees The list of trees to be processed.
468 */
469 public void main(List<JCCompilationUnit> trees) {
470 complete(trees, null);
471 }
472
473 /** Main method: enter one class from a list of toplevel trees and
474 * place the rest on uncompleted for later processing.
475 * @param trees The list of trees to be processed.
476 * @param c The class symbol to be processed.
477 */
478 public void complete(List<JCCompilationUnit> trees, ClassSymbol c) {
479 annotate.enterStart();
480 ListBuffer<ClassSymbol> prevUncompleted = uncompleted;
481 if (memberEnter.completionEnabled) uncompleted = new ListBuffer<ClassSymbol>();
482
483 try {
484 // enter all classes, and construct uncompleted list
485 classEnter(trees, null);
486
487 // complete all uncompleted classes in memberEnter
488 if (memberEnter.completionEnabled) {
489 while (uncompleted.nonEmpty()) {
490 ClassSymbol clazz = uncompleted.next();
491 if (c == null || c == clazz || prevUncompleted == null)
492 clazz.complete();
493 else
494 // defer
495 prevUncompleted.append(clazz);
496 }
497
498 // if there remain any unimported toplevels (these must have
499 // no classes at all), process their import statements as well.
500 for (JCCompilationUnit tree : trees) {
501 if (tree.starImportScope.elems == null) {
502 JavaFileObject prev = log.useSource(tree.sourcefile);
503 Env<AttrContext> env = typeEnvs.get(tree);
504 if (env == null)
505 env = topLevelEnv(tree);
506 memberEnter.memberEnter(tree, env);
507 log.useSource(prev);
508 }
509 }
510 }
511 } finally {
512 uncompleted = prevUncompleted;
513 annotate.enterDone();
514 }
515 }
516 }