View Javadoc
1   /*
2    * Copyright (c) 1994, 2004, 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  
26  package sun.tools.javac;
27  
28  import sun.tools.java.*;
29  import sun.tools.tree.*;
30  import sun.tools.asm.*;
31  import java.util.Vector;
32  import java.util.Enumeration;
33  import java.util.Hashtable;
34  import java.io.PrintStream;
35  
36  /**
37   * A Source Member
38   *
39   * WARNING: The contents of this source file are not part of any
40   * supported API.  Code that depends on them does so at its own risk:
41   * they are subject to change or removal without notice.
42   */
43  @Deprecated
44  public
45  class SourceMember extends MemberDefinition implements Constants {
46      /**
47       * The argument names (if it is a method)
48       */
49      Vector args;
50  
51      // set to the MemberDefinition in the interface if we have this field because
52      // it has been forced on us
53      MemberDefinition abstractSource;
54  
55      /**
56       * The status of the field
57       */
58      int status;
59  
60      static final int PARSED     = 0;
61      static final int CHECKING   = 1;
62      static final int CHECKED    = 2;
63      static final int INLINING   = 3;
64      static final int INLINED    = 4;
65      static final int ERROR      = 5;
66  
67      public Vector getArguments() {
68          return args;
69      }
70  
71      /**
72       * Constructor
73       * @param argNames a vector of IdentifierToken
74       */
75      public SourceMember(long where, ClassDefinition clazz,
76                         String doc, int modifiers, Type type,
77                         Identifier name, Vector argNames,
78                         IdentifierToken exp[], Node value) {
79          super(where, clazz, modifiers, type, name, exp, value);
80          this.documentation = doc;
81          this.args = argNames;   // for the moment
82          // not until type names are resolved: createArgumentFields(argNames);
83  
84          if (ClassDefinition.containsDeprecated(documentation)) {
85              this.modifiers |= M_DEPRECATED;
86          }
87      }
88  
89      void createArgumentFields(Vector argNames) {
90          // Create a list of arguments
91          if (isMethod()) {
92              args = new Vector();
93  
94              if (isConstructor() || !(isStatic() || isInitializer())) {
95                  args.addElement(((SourceClass)clazz).getThisArgument());
96              }
97  
98              if (argNames != null) {
99                  Enumeration e = argNames.elements();
100                 Type argTypes[] = getType().getArgumentTypes();
101                 for (int i = 0 ; i < argTypes.length ; i++) {
102                     Object x = e.nextElement();
103                     if (x instanceof LocalMember) {
104                         // This should not happen, but it does
105                         // in cases of vicious cyclic inheritance.
106                         args = argNames;
107                         return;
108                     }
109                     Identifier id;
110                     int mod;
111                     long where;
112                     if (x instanceof Identifier) {
113                         // allow argNames to be simple Identifiers (deprecated!)
114                         id = (Identifier)x;
115                         mod = 0;
116                         where = getWhere();
117                     } else {
118                         IdentifierToken token = (IdentifierToken)x;
119                         id = token.getName();
120                         mod = token.getModifiers();
121                         where = token.getWhere();
122                     }
123                     args.addElement(new LocalMember(where, clazz, mod,
124                                                    argTypes[i], id));
125                 }
126             }
127         }
128     }
129 
130     // The methods addOuterThis() and addUplevelArguments() were
131     // both originally part of a single method called addUplevelArguments()
132     // which took a single boolean parameter describing which of the
133     // two behaviors it wanted.
134     //
135     // The original addUplevelArguments() claimed to keep the arguments in
136     // the following order:
137     //
138     // (1) <this> <early outer this> <uplevel arguments...> <true arguments...>
139     //
140     // (By <early outer this> I am referring to the clientOuterField added
141     // to some constructors when they are created.  If an outer this is
142     // added later, on demand, then this is mixed in with the rest of the
143     // uplevel arguments and is added by addUplevelArguments.)
144     //
145     // In reality, the `args' Vector was generated in this order, but the
146     // Type array `argTypes' was generated as:
147     //
148     // (2) <this> <uplevel arguments...> <early outer this> <true arguments...>
149     //
150     // This didn't make a difference in the common case -- that is, when
151     // a class had an <outer.this> or <uplevel arguments...> but not both.
152     // Both can happen in the case that a member class is declared inside
153     // of a local class.  It seems that the calling sequences, generated
154     // in places like NewInstanceExpression.codeCommon(), use order (2),
155     // so I have changed the code below to stick with that order.  Since
156     // the only time this happens is in classes which are insideLocal, no
157     // one should be able to tell the difference between these orders.
158     // (bug number 4085633)
159 
160     LocalMember outerThisArg = null;
161 
162     /**
163      * Get outer instance link, or null if none.
164      */
165 
166     public LocalMember getOuterThisArg() {
167         return outerThisArg;
168     }
169 
170     /**
171      * Add the outer.this argument to the list of arguments for this
172      * constructor.  This is called from resolveTypeStructure.  Any
173      * additional uplevel arguments get added later by addUplevelArguments().
174      */
175 
176     void addOuterThis() {
177         UplevelReference refs = clazz.getReferences();
178 
179         // See if we have a client outer field.
180         while (refs != null &&
181                !refs.isClientOuterField()) {
182             refs = refs.getNext();
183         }
184 
185         // There is no outer this argument.  Quit.
186         if (refs == null) {
187             return;
188         }
189 
190         // Get the old arg types.
191         Type oldArgTypes[] = type.getArgumentTypes();
192 
193         // And make an array for the new ones with space for one more.
194         Type argTypes[] = new Type[oldArgTypes.length + 1];
195 
196         LocalMember arg = refs.getLocalArgument();
197         outerThisArg = arg;
198 
199         // args is our list of arguments.  It contains a `this', so
200         // we insert at position 1.  The list of types does not have a
201         // this, so we insert at position 0.
202         args.insertElementAt(arg, 1);
203         argTypes[0] = arg.getType();
204 
205         // Add on the rest of the constructor arguments.
206         for (int i = 0; i < oldArgTypes.length; i++) {
207             argTypes[i + 1] = oldArgTypes[i];
208         }
209 
210         type = Type.tMethod(type.getReturnType(), argTypes);
211     }
212 
213     /**
214      * Prepend argument names and argument types for local variable references.
215      * This information is never seen by the type-check phase,
216      * but it affects code generation, which is the earliest moment
217      * we have comprehensive information on uplevel references.
218      * The code() methods tweaks the constructor calls, prepending
219      * the proper values to the argument list.
220      */
221     void addUplevelArguments() {
222         UplevelReference refs = clazz.getReferences();
223         clazz.getReferencesFrozen();
224 
225         // Count how many uplevels we have to add.
226         int count = 0;
227         for (UplevelReference r = refs; r != null; r = r.getNext()) {
228             if (!r.isClientOuterField()) {
229                 count += 1;
230             }
231         }
232 
233         if (count == 0) {
234             // None to add, quit.
235             return;
236         }
237 
238         // Get the old argument types.
239         Type oldArgTypes[] = type.getArgumentTypes();
240 
241         // Make an array with enough room for the new.
242         Type argTypes[] = new Type[oldArgTypes.length + count];
243 
244         // Add all of the late uplevel references to args and argTypes.
245         // Note that they are `off-by-one' because of the `this'.
246         int ins = 0;
247         for (UplevelReference r = refs; r != null; r = r.getNext()) {
248             if (!r.isClientOuterField()) {
249                 LocalMember arg = r.getLocalArgument();
250 
251                 args.insertElementAt(arg, 1 + ins);
252                 argTypes[ins] = arg.getType();
253 
254                 ins++;
255             }
256         }
257 
258         // Add the rest of the old arguments.
259         for (int i = 0; i < oldArgTypes.length; i++) {
260             argTypes[ins + i] = oldArgTypes[i];
261         }
262 
263         type = Type.tMethod(type.getReturnType(), argTypes);
264     }
265 
266     /**
267      * Constructor for an inner class.
268      */
269     public SourceMember(ClassDefinition innerClass) {
270         super(innerClass);
271     }
272 
273     /**
274      * Constructor.
275      * Used only to generate an abstract copy of a method that a class
276      * inherits from an interface
277      */
278     public SourceMember(MemberDefinition f, ClassDefinition c, Environment env) {
279         this(f.getWhere(), c, f.getDocumentation(),
280              f.getModifiers() | M_ABSTRACT, f.getType(), f.getName(), null,
281              f.getExceptionIds(), null);
282         this.args = f.getArguments();
283         this.abstractSource = f;
284         this.exp = f.getExceptions(env);
285     }
286 
287     /**
288      * Get exceptions
289      */
290     public ClassDeclaration[] getExceptions(Environment env) {
291         if ((!isMethod()) || (exp != null)) {
292             return exp;
293         }
294         if (expIds == null) {
295             // (should not happen)
296             exp = new ClassDeclaration[0];
297             return exp;
298         }
299         // be sure to get the imports right:
300         env = ((SourceClass)getClassDefinition()).setupEnv(env);
301         exp = new ClassDeclaration[expIds.length];
302         for (int i = 0; i < exp.length; i++) {
303             Identifier e = expIds[i].getName();
304             Identifier rexp = getClassDefinition().resolveName(env, e);
305             exp[i] = env.getClassDeclaration(rexp);
306         }
307         return exp;
308     }
309 
310     /**
311      * Set array of name-resolved exceptions directly, e.g., for access methods.
312      */
313     public void setExceptions(ClassDeclaration[] exp) {
314         this.exp = exp;
315     }
316 
317     /**
318      * Resolve types in a field, after parsing.
319      * @see ClassDefinition.resolveTypeStructure
320      */
321 
322     public boolean resolved = false;
323 
324     public void resolveTypeStructure(Environment env) {
325         if (tracing) env.dtEnter("SourceMember.resolveTypeStructure: " + this);
326 
327         // A member should only be resolved once.  For a constructor, it is imperative
328         // that 'addOuterThis' be called only once, else the outer instance argument may
329         // be inserted into the argument list multiple times.
330 
331         if (resolved) {
332             if (tracing) env.dtEvent("SourceMember.resolveTypeStructure: OK " + this);
333             // This case shouldn't be happening.  It is the responsibility
334             // of our callers to avoid attempting multiple resolutions of a member.
335             // *** REMOVE FOR SHIPMENT? ***
336             throw new CompilerError("multiple member type resolution");
337             //return;
338         } else {
339             if (tracing) env.dtEvent("SourceMember.resolveTypeStructure: RESOLVING " + this);
340             resolved = true;
341         }
342 
343         super.resolveTypeStructure(env);
344         if (isInnerClass()) {
345             ClassDefinition nc = getInnerClass();
346             if (nc instanceof SourceClass && !nc.isLocal()) {
347                 ((SourceClass)nc).resolveTypeStructure(env);
348             }
349             type = innerClass.getType();
350         } else {
351             // Expand all class names in 'type', including those that are not
352             // fully-qualified or refer to inner classes, into fully-qualified
353             // names.  Local and anonymous classes get synthesized names here,
354             // corresponding to the class files that will be generated.  This is
355             // currently the only place where 'resolveNames' is used.
356             type = env.resolveNames(getClassDefinition(), type, isSynthetic());
357 
358             // do the throws also:
359             getExceptions(env);
360 
361             if (isMethod()) {
362                 Vector argNames = args; args = null;
363                 createArgumentFields(argNames);
364                 // Add outer instance argument for constructors.
365                 if (isConstructor()) {
366                     addOuterThis();
367                 }
368             }
369         }
370         if (tracing) env.dtExit("SourceMember.resolveTypeStructure: " + this);
371     }
372 
373     /**
374      * Get the class declaration in which the field is actually defined
375      */
376     public ClassDeclaration getDefiningClassDeclaration() {
377         if (abstractSource == null)
378             return super.getDefiningClassDeclaration();
379         else
380             return abstractSource.getDefiningClassDeclaration();
381     }
382 
383     /**
384      * A source field never reports deprecation, since the compiler
385      * allows access to deprecated features that are being compiled
386      * in the same job.
387      */
388     public boolean reportDeprecated(Environment env) {
389         return false;
390     }
391 
392     /**
393      * Check this field.
394      * <p>
395      * This is the method which requests checking.
396      * The real work is done by
397      * <tt>Vset check(Environment, Context, Vset)</tt>.
398      */
399     public void check(Environment env) throws ClassNotFound {
400         if (tracing) env.dtEnter("SourceMember.check: " +
401                                  getName() + ", status = " + status);
402         // rely on the class to check all fields in the proper order
403         if (status == PARSED) {
404             if (isSynthetic() && getValue() == null) {
405                 // break a big cycle for small synthetic variables
406                 status = CHECKED;
407                 if (tracing)
408                     env.dtExit("SourceMember.check: BREAKING CYCLE");
409                 return;
410             }
411             if (tracing) env.dtEvent("SourceMember.check: CHECKING CLASS");
412             clazz.check(env);
413             if (status == PARSED) {
414                 if (getClassDefinition().getError()) {
415                     status = ERROR;
416                 } else {
417                     if (tracing)
418                         env.dtExit("SourceMember.check: CHECK FAILED");
419                     throw new CompilerError("check failed");
420                 }
421             }
422         }
423         if (tracing) env.dtExit("SourceMember.check: DONE " +
424                                 getName() + ", status = " + status);
425     }
426 
427     /**
428      * Check a field.
429      * @param vset tells which uplevel variables are definitely assigned
430      * The vset is also used to track the initialization of blank finals
431      * by whichever fields which are relevant to them.
432      */
433     public Vset check(Environment env, Context ctx, Vset vset) throws ClassNotFound {
434         if (tracing) env.dtEvent("SourceMember.check: MEMBER " +
435                                  getName() + ", status = " + status);
436         if (status == PARSED) {
437             if (isInnerClass()) {
438                 // some classes are checked separately
439                 ClassDefinition nc = getInnerClass();
440                 if (nc instanceof SourceClass && !nc.isLocal()
441                     && nc.isInsideLocal()) {
442                     status = CHECKING;
443                     vset = ((SourceClass)nc).checkInsideClass(env, ctx, vset);
444                 }
445                 status = CHECKED;
446                 return vset;
447             }
448             if (env.dump()) {
449                 System.out.println("[check field " + getClassDeclaration().getName() + "." + getName() + "]");
450                 if (getValue() != null) {
451                     getValue().print(System.out);
452                     System.out.println();
453                 }
454             }
455             env = new Environment(env, this);
456 
457             // This is where all checking of names appearing within the type
458             // of the member is done.  Includes return type and argument types.
459             // Since only one location ('where') for error messages is provided,
460             // localization of errors is poor.  Throws clauses are handled below.
461             env.resolve(where, getClassDefinition(), getType());
462 
463             // Make sure that all the classes that we claim to throw really
464             // are subclasses of Throwable, and are classes that we can reach
465             if (isMethod()) {
466                 ClassDeclaration throwable =
467                     env.getClassDeclaration(idJavaLangThrowable);
468                 ClassDeclaration exp[] = getExceptions(env);
469                 for (int i = 0 ; i < exp.length ; i++) {
470                     ClassDefinition def;
471                     long where = getWhere();
472                     if (expIds != null && i < expIds.length) {
473                         where = IdentifierToken.getWhere(expIds[i], where);
474                     }
475                     try {
476                         def = exp[i].getClassDefinition(env);
477 
478                         // Validate access for all inner-class components
479                         // of a qualified name, not just the last one, which
480                         // is checked below.  Yes, this is a dirty hack...
481                         // Part of fix for 4094658.
482                         env.resolveByName(where, getClassDefinition(), def.getName());
483 
484                     } catch (ClassNotFound e) {
485                         env.error(where, "class.not.found", e.name, "throws");
486                         break;
487                     }
488                     def.noteUsedBy(getClassDefinition(), where, env);
489                     if (!getClassDefinition().
490                           canAccess(env, def.getClassDeclaration())) {
491                         env.error(where, "cant.access.class", def);
492                     } else if (!def.subClassOf(env, throwable)) {
493                         env.error(where, "throws.not.throwable", def);
494                     }
495                 }
496             }
497 
498             status = CHECKING;
499 
500             if (isMethod() && args != null) {
501                 int length = args.size();
502             outer_loop:
503                 for (int i = 0; i < length; i++) {
504                     LocalMember lf = (LocalMember)(args.elementAt(i));
505                     Identifier name_i = lf.getName();
506                     for (int j = i + 1; j < length; j++) {
507                         LocalMember lf2 = (LocalMember)(args.elementAt(j));
508                         Identifier name_j = lf2.getName();
509                         if (name_i.equals(name_j)) {
510                             env.error(lf2.getWhere(), "duplicate.argument",
511                                       name_i);
512                             break outer_loop;
513                         }
514                     }
515                 }
516             }
517 
518             if (getValue() != null) {
519                 ctx = new Context(ctx, this);
520 
521                 if (isMethod()) {
522                     Statement s = (Statement)getValue();
523                     // initialize vset, indication that each of the arguments
524                     // to the function has a value
525 
526                     for (Enumeration e = args.elements(); e.hasMoreElements();){
527                         LocalMember f = (LocalMember)e.nextElement();
528                         vset.addVar(ctx.declare(env, f));
529                     }
530 
531                     if (isConstructor()) {
532                         // Undefine "this" in some constructors, until after
533                         // the super constructor has been called.
534                         vset.clearVar(ctx.getThisNumber());
535 
536                         // If the first thing in the definition isn't a call
537                         // to either super() or this(), then insert one.
538                         Expression supCall = s.firstConstructor();
539                         if ((supCall == null)
540                             && (getClassDefinition().getSuperClass() != null)) {
541                             supCall = getDefaultSuperCall(env);
542                             Statement scs = new ExpressionStatement(where,
543                                                                     supCall);
544                             s = Statement.insertStatement(scs, s);
545                             setValue(s);
546                         }
547                     }
548 
549                     //System.out.println("VSET = " + vset);
550                     ClassDeclaration exp[] = getExceptions(env);
551                     int htsize = (exp.length > 3) ? 17 : 7;
552                     Hashtable thrown = new Hashtable(htsize);
553 
554                     vset = s.checkMethod(env, ctx, vset, thrown);
555 
556                     ClassDeclaration ignore1 =
557                         env.getClassDeclaration(idJavaLangError);
558                     ClassDeclaration ignore2 =
559                         env.getClassDeclaration(idJavaLangRuntimeException);
560 
561                     for (Enumeration e = thrown.keys(); e.hasMoreElements();) {
562                         ClassDeclaration c = (ClassDeclaration)e.nextElement();
563                         ClassDefinition def = c.getClassDefinition(env);
564                         if (def.subClassOf(env, ignore1)
565                                  || def.subClassOf(env, ignore2)) {
566                             continue;
567                         }
568 
569                         boolean ok = false;
570                         if (!isInitializer()) {
571                             for (int i = 0 ; i < exp.length ; i++) {
572                                 if (def.subClassOf(env, exp[i])) {
573                                     ok = true;
574                                 }
575                             }
576                         }
577                         if (!ok) {
578                             Node n = (Node)thrown.get(c);
579                             long where = n.getWhere();
580                             String errorMsg;
581 
582                             if (isConstructor()) {
583                                 if (where ==
584                                     getClassDefinition().getWhere()) {
585 
586                                     // If this message is being generated for
587                                     // a default constructor, we should give
588                                     // a different error message.  Currently
589                                     // we check for this by seeing if the
590                                     // constructor has the same "where" as
591                                     // its class.  This is a bit kludgy, but
592                                     // works. (bug id 4034836)
593                                     errorMsg = "def.constructor.exception";
594                                 } else {
595                                     // Constructor with uncaught exception.
596                                     errorMsg = "constructor.exception";
597                                 }
598                             } else if (isInitializer()) {
599                                 // Initializer with uncaught exception.
600                                 errorMsg = "initializer.exception";
601                             } else {
602                                 // Method with uncaught exception.
603                                 errorMsg = "uncaught.exception";
604                             }
605                             env.error(where, errorMsg, c.getName());
606                         }
607                     }
608                 } else {
609                     Hashtable thrown = new Hashtable(3);  // small & throw-away
610                     Expression val = (Expression)getValue();
611 
612                     vset = val.checkInitializer(env, ctx, vset,
613                                                 getType(), thrown);
614                     setValue(val.convert(env, ctx, getType(), val));
615 
616                     // Complain about static final members of inner classes that
617                     // do not have an initializer that is a constant expression.
618                     // In general, static members are not permitted for inner
619                     // classes, but an exception is made for named constants.
620                     // Other cases of static members, including non-final ones,
621                     // are handled in 'SourceClass'.  Part of fix for 4095568.
622                     if (isStatic() && isFinal() && !clazz.isTopLevel()) {
623                         if (!((Expression)getValue()).isConstant()) {
624                             env.error(where, "static.inner.field", getName(), this);
625                             setValue(null);
626                         }
627                     }
628 
629 
630                     // Both RuntimeExceptions and Errors should be
631                     // allowed in initializers.  Fix for bug 4102541.
632                     ClassDeclaration except =
633                          env.getClassDeclaration(idJavaLangThrowable);
634                     ClassDeclaration ignore1 =
635                         env.getClassDeclaration(idJavaLangError);
636                     ClassDeclaration ignore2 =
637                         env.getClassDeclaration(idJavaLangRuntimeException);
638 
639                     for (Enumeration e = thrown.keys(); e.hasMoreElements(); ) {
640                         ClassDeclaration c = (ClassDeclaration)e.nextElement();
641                         ClassDefinition def = c.getClassDefinition(env);
642 
643                         if (!def.subClassOf(env, ignore1)
644                             && !def.subClassOf(env, ignore2)
645                             && def.subClassOf(env, except)) {
646                             Node n = (Node)thrown.get(c);
647                             env.error(n.getWhere(),
648                                       "initializer.exception", c.getName());
649                         }
650                     }
651                 }
652                 if (env.dump()) {
653                     getValue().print(System.out);
654                     System.out.println();
655                 }
656             }
657             status = getClassDefinition().getError() ? ERROR : CHECKED;
658         }
659 
660 
661         // Initializers (static and instance) must be able to complete normally.
662         if (isInitializer() && vset.isDeadEnd()) {
663             env.error(where, "init.no.normal.completion");
664             vset = vset.clearDeadEnd();
665         }
666 
667         return vset;
668     }
669 
670     // helper to check(): synthesize a missing super() call
671     private Expression getDefaultSuperCall(Environment env) {
672         Expression se = null;
673         ClassDefinition sclass = getClassDefinition().getSuperClass().getClassDefinition();
674         // does the superclass constructor require an enclosing instance?
675         ClassDefinition reqc = (sclass == null) ? null
676                              : sclass.isTopLevel() ? null
677                              : sclass.getOuterClass();
678         ClassDefinition thisc = getClassDefinition();
679         if (reqc != null && !Context.outerLinkExists(env, reqc, thisc)) {
680             se = new SuperExpression(where, new NullExpression(where));
681             env.error(where, "no.default.outer.arg", reqc, getClassDefinition());
682         }
683         if (se == null) {
684             se = new SuperExpression(where);
685         }
686         return new MethodExpression(where, se, idInit, new Expression[0]);
687     }
688 
689     /**
690      * Inline the field
691      */
692     void inline(Environment env) throws ClassNotFound {
693         switch (status) {
694           case PARSED:
695             check(env);
696             inline(env);
697             break;
698 
699           case CHECKED:
700             if (env.dump()) {
701                 System.out.println("[inline field " + getClassDeclaration().getName() + "." + getName() + "]");
702             }
703             status = INLINING;
704             env = new Environment(env, this);
705 
706             if (isMethod()) {
707                 if ((!isNative()) && (!isAbstract())) {
708                     Statement s = (Statement)getValue();
709                     Context ctx = new Context((Context)null, this);
710                     for (Enumeration e = args.elements() ; e.hasMoreElements() ;) {
711                         LocalMember local = (LocalMember)e.nextElement();
712                         ctx.declare(env, local);
713                     }
714                     setValue(s.inline(env, ctx));
715                 }
716             } else if (isInnerClass()) {
717                 // some classes are checked and inlined separately
718                 ClassDefinition nc = getInnerClass();
719                 if (nc instanceof SourceClass && !nc.isLocal()
720                     && nc.isInsideLocal()) {
721                     status = INLINING;
722                     ((SourceClass)nc).inlineLocalClass(env);
723                 }
724                 status = INLINED;
725                 break;
726             } else {
727                 if (getValue() != null)  {
728                     Context ctx = new Context((Context)null, this);
729                     if (!isStatic()) {
730                         // Cf. "thisArg" in SourceClass.checkMembers().
731                         Context ctxInst = new Context(ctx, this);
732                         LocalMember thisArg =
733                                     ((SourceClass)clazz).getThisArgument();
734                         ctxInst.declare(env, thisArg);
735                         setValue(((Expression)getValue())
736                                     .inlineValue(env, ctxInst));
737                     } else {
738                         setValue(((Expression)getValue())
739                                     .inlineValue(env, ctx));
740                     }
741                 }
742             }
743             if (env.dump()) {
744                 System.out.println("[inlined field " + getClassDeclaration().getName() + "." + getName() + "]");
745                 if (getValue() != null) {
746                     getValue().print(System.out);
747                     System.out.println();
748                 } else {
749                     System.out.println("<empty>");
750                 }
751             }
752             status = INLINED;
753             break;
754         }
755     }
756 
757     /**
758      * Get the value of the field (or null if the value can't be determined)
759      */
760     public Node getValue(Environment env) throws ClassNotFound {
761         Node value = getValue();
762         if (value != null && status != INLINED) {
763             // be sure to get the imports right:
764             env = ((SourceClass)clazz).setupEnv(env);
765             inline(env);
766             value = (status == INLINED) ? getValue() : null;
767         }
768         return value;
769     }
770 
771     public boolean isInlineable(Environment env, boolean fromFinal) throws ClassNotFound {
772         if (super.isInlineable(env, fromFinal)) {
773             getValue(env);
774             return (status == INLINED) && !getClassDefinition().getError();
775         }
776         return false;
777     }
778 
779 
780     /**
781      * Get the initial value of the field
782      */
783     public Object getInitialValue() {
784         if (isMethod() || (getValue() == null) || (!isFinal()) || (status != INLINED)) {
785             return null;
786         }
787         return ((Expression)getValue()).getValue();
788     }
789 
790     /**
791      * Generate code
792      */
793     public void code(Environment env, Assembler asm) throws ClassNotFound {
794         switch (status) {
795           case PARSED:
796             check(env);
797             code(env, asm);
798             return;
799 
800           case CHECKED:
801             inline(env);
802             code(env, asm);
803             return;
804 
805           case INLINED:
806             // Actually generate code
807             if (env.dump()) {
808                 System.out.println("[code field " + getClassDeclaration().getName() + "." + getName() + "]");
809             }
810             if (isMethod() && (!isNative()) && (!isAbstract())) {
811                 env = new Environment(env, this);
812                 Context ctx = new Context((Context)null, this);
813                 Statement s = (Statement)getValue();
814 
815                 for (Enumeration e = args.elements() ; e.hasMoreElements() ; ) {
816                     LocalMember f = (LocalMember)e.nextElement();
817                     ctx.declare(env, f);
818                     //ctx.declare(env, (LocalMember)e.nextElement());
819                 }
820 
821                 /*
822                 if (isConstructor() && ((s == null) || (s.firstConstructor() == null))) {
823                     ClassDeclaration c = getClassDefinition().getSuperClass();
824                     if (c != null) {
825                         MemberDefinition field = c.getClassDefinition(env).matchMethod(env, getClassDefinition(), idInit);
826                         asm.add(getWhere(), opc_aload, new Integer(0));
827                         asm.add(getWhere(), opc_invokespecial, field);
828                         asm.add(getWhere(), opc_pop);
829                     }
830 
831                     // Output initialization code
832                     for (MemberDefinition f = getClassDefinition().getFirstMember() ; f != null ; f = f.getNextMember()) {
833                         if (!f.isStatic()) {
834                             f.codeInit(env, ctx, asm);
835                         }
836                     }
837                 }
838                 */
839                 if (s != null) {
840                     s.code(env, ctx, asm);
841                 }
842                 if (getType().getReturnType().isType(TC_VOID) && !isInitializer()) {
843                    asm.add(getWhere(), opc_return, true);
844                 }
845             }
846             return;
847         }
848     }
849 
850     public void codeInit(Environment env, Context ctx, Assembler asm) throws ClassNotFound {
851         if (isMethod()) {
852             return;
853         }
854         switch (status) {
855           case PARSED:
856             check(env);
857             codeInit(env, ctx, asm);
858             return;
859 
860           case CHECKED:
861             inline(env);
862             codeInit(env, ctx, asm);
863             return;
864 
865           case INLINED:
866             // Actually generate code
867             if (env.dump()) {
868                 System.out.println("[code initializer  " + getClassDeclaration().getName() + "." + getName() + "]");
869             }
870             if (getValue() != null) {
871                 Expression e = (Expression)getValue();
872                 // The JLS Section 8.5 specifies that static (non-final)
873                 // initializers should be executed in textual order.  Eliding
874                 // initializations to default values can interfere with this,
875                 // so the tests for !e.equalsDefault() have been eliminated,
876                 // below.
877                 if (isStatic()) {
878                     if (getInitialValue() == null) {
879                         // removed: && !e.equalsDefault()) {
880                         e.codeValue(env, ctx, asm);
881                         asm.add(getWhere(), opc_putstatic, this);
882                     }
883                 } else { // removed: if (!e.equalsDefault()) {
884                     // This code doesn't appear to be reached for
885                     // instance initializers.  Code for these is generated
886                     // in the makeVarInits() method of the class
887                     // MethodExpression.
888                     asm.add(getWhere(), opc_aload, new Integer(0));
889                     e.codeValue(env, ctx, asm);
890                     asm.add(getWhere(), opc_putfield, this);
891                 }
892             }
893             return;
894         }
895     }
896 
897     /**
898      * Print for debugging
899      */
900     public void print(PrintStream out) {
901         super.print(out);
902         if (getValue() != null) {
903             getValue().print(out);
904             out.println();
905         }
906     }
907 }