001    /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */
002    package org.extendj.ast;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.Set;
007    import java.util.Collections;
008    import java.util.Collection;
009    import java.util.ArrayList;
010    import beaver.*;
011    import java.util.*;
012    import java.io.ByteArrayOutputStream;
013    import java.io.PrintStream;
014    import java.lang.reflect.InvocationTargetException;
015    import java.lang.reflect.Method;
016    import org.jastadd.util.*;
017    import java.util.zip.*;
018    import java.io.*;
019    import org.jastadd.util.PrettyPrintable;
020    import org.jastadd.util.PrettyPrinter;
021    import java.io.FileNotFoundException;
022    import java.io.BufferedInputStream;
023    import java.io.DataInputStream;
024    /**
025     * @ast node
026     * @declaredat /home/jesper/git/extendj/java4/grammar/Java.ast:30
027     * @production ArrayAccess : {@link Access} ::= <span class="component">{@link Expr}</span>;
028    
029     */
030    public class ArrayAccess extends Access implements Cloneable {
031      /**
032       * @aspect Java4PrettyPrint
033       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:432
034       */
035      public void prettyPrint(PrettyPrinter out) {
036        out.print("[");
037        out.print(getExpr());
038        out.print("]");
039      }
040      /**
041       * @aspect TypeCheck
042       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:159
043       */
044      public void typeCheck() {
045        if (isQualified() && !qualifier().type().isArrayDecl() && !qualifier().type().isUnknown()) {
046          errorf("the type %s of the indexed element is not an array", qualifier().type().name());
047        }
048        if (!getExpr().type().unaryNumericPromotion().isInt() || !getExpr().type().isIntegralType()) {
049          errorf("array index must be int after unary numeric promotion which %s is not",
050              getExpr().type().typeName());
051        }
052      }
053      /**
054       * @aspect CodeGeneration
055       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:377
056       */
057      public void emitStore(CodeGeneration gen) {
058        gen.emit(type().arrayStore());
059      }
060      /**
061       * @aspect CreateBCode
062       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:459
063       */
064      public void createPushAssignmentResult(CodeGeneration gen) {
065        type().emitDup_x2(gen);
066      }
067      /**
068       * @declaredat ASTNode:1
069       */
070      public ArrayAccess() {
071        super();
072      }
073      /**
074       * Initializes the child array to the correct size.
075       * Initializes List and Opt nta children.
076       * @apilevel internal
077       * @ast method
078       * @declaredat ASTNode:10
079       */
080      public void init$Children() {
081        children = new ASTNode[1];
082      }
083      /**
084       * @declaredat ASTNode:13
085       */
086      public ArrayAccess(Expr p0) {
087        setChild(p0, 0);
088      }
089      /**
090       * @apilevel low-level
091       * @declaredat ASTNode:19
092       */
093      protected int numChildren() {
094        return 1;
095      }
096      /**
097       * @apilevel internal
098       * @declaredat ASTNode:25
099       */
100      public boolean mayHaveRewrite() {
101        return false;
102      }
103      /**
104       * @apilevel internal
105       * @declaredat ASTNode:31
106       */
107      public void flushAttrCache() {
108        super.flushAttrCache();
109        type_reset();
110      }
111      /**
112       * @apilevel internal
113       * @declaredat ASTNode:38
114       */
115      public void flushCollectionCache() {
116        super.flushCollectionCache();
117      }
118      /**
119       * @apilevel internal
120       * @declaredat ASTNode:44
121       */
122      public void flushRewriteCache() {
123        super.flushRewriteCache();
124      }
125      /**
126       * @apilevel internal
127       * @declaredat ASTNode:50
128       */
129      public ArrayAccess clone() throws CloneNotSupportedException {
130        ArrayAccess node = (ArrayAccess) super.clone();
131        return node;
132      }
133      /**
134       * @apilevel internal
135       * @declaredat ASTNode:57
136       */
137      public ArrayAccess copy() {
138        try {
139          ArrayAccess node = (ArrayAccess) clone();
140          node.parent = null;
141          if (children != null) {
142            node.children = (ASTNode[]) children.clone();
143          }
144          return node;
145        } catch (CloneNotSupportedException e) {
146          throw new Error("Error: clone not supported for " + getClass().getName());
147        }
148      }
149      /**
150       * Create a deep copy of the AST subtree at this node.
151       * The copy is dangling, i.e. has no parent.
152       * @return dangling copy of the subtree at this node
153       * @apilevel low-level
154       * @deprecated Please use treeCopy or treeCopyNoTransform instead
155       * @declaredat ASTNode:76
156       */
157      @Deprecated
158      public ArrayAccess fullCopy() {
159        return treeCopyNoTransform();
160      }
161      /**
162       * Create a deep copy of the AST subtree at this node.
163       * The copy is dangling, i.e. has no parent.
164       * @return dangling copy of the subtree at this node
165       * @apilevel low-level
166       * @declaredat ASTNode:86
167       */
168      public ArrayAccess treeCopyNoTransform() {
169        ArrayAccess tree = (ArrayAccess) copy();
170        if (children != null) {
171          for (int i = 0; i < children.length; ++i) {
172            ASTNode child = (ASTNode) children[i];
173            if (child != null) {
174              child = child.treeCopyNoTransform();
175              tree.setChild(child, i);
176            }
177          }
178        }
179        return tree;
180      }
181      /**
182       * Create a deep copy of the AST subtree at this node.
183       * The subtree of this node is traversed to trigger rewrites before copy.
184       * The copy is dangling, i.e. has no parent.
185       * @return dangling copy of the subtree at this node
186       * @apilevel low-level
187       * @declaredat ASTNode:106
188       */
189      public ArrayAccess treeCopy() {
190        doFullTraversal();
191        return treeCopyNoTransform();
192      }
193      /**
194       * @apilevel internal
195       * @declaredat ASTNode:113
196       */
197      protected boolean is$Equal(ASTNode node) {
198        return super.is$Equal(node);    
199      }
200      /**
201       * Replaces the Expr child.
202       * @param node The new node to replace the Expr child.
203       * @apilevel high-level
204       */
205      public void setExpr(Expr node) {
206        setChild(node, 0);
207      }
208      /**
209       * Retrieves the Expr child.
210       * @return The current node used as the Expr child.
211       * @apilevel high-level
212       */
213      @ASTNodeAnnotation.Child(name="Expr")
214      public Expr getExpr() {
215        return (Expr) getChild(0);
216      }
217      /**
218       * Retrieves the Expr child.
219       * <p><em>This method does not invoke AST transformations.</em></p>
220       * @return The current node used as the Expr child.
221       * @apilevel low-level
222       */
223      public Expr getExprNoTransform() {
224        return (Expr) getChildNoTransform(0);
225      }
226      /**
227       * @aspect AutoBoxingCodegen
228       * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:449
229       */
230        public void createAssignSimpleLoadDest(CodeGeneration gen) {
231        prevExpr().createBCode(gen);
232        getExpr().createBCode(gen);
233        getExpr().type().emitCastTo(gen, typeInt());
234      }
235      /**
236       * @aspect AutoBoxingCodegen
237       * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:455
238       */
239        public void createAssignLoadDest(CodeGeneration gen) {
240        prevExpr().createBCode(gen);
241        gen.emitDup();
242        getExpr().createBCode(gen);
243        getExpr().type().emitCastTo(gen, typeInt());
244        typeInt().emitDup_x1(gen);
245        gen.emit(type().arrayLoad());
246      }
247      /**
248       * @aspect AutoBoxingCodegen
249       * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:442
250       */
251        public void createBCode(CodeGeneration gen) {
252        prevExpr().createBCode(gen);
253        getExpr().createBCode(gen);
254        getExpr().type().emitCastTo(gen, typeInt());
255        gen.emit(type().arrayLoad());
256      }
257      /**
258       * @attribute syn
259       * @aspect DA
260       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259
261       */
262      @ASTNodeAnnotation.Attribute
263      public boolean isDAafter(Variable v) {
264        boolean isDAafter_Variable_value = getExpr().isDAafter(v);
265    
266        return isDAafter_Variable_value;
267      }
268      /**
269       * @attribute syn
270       * @aspect DU
271       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783
272       */
273      @ASTNodeAnnotation.Attribute
274      public boolean isDUafter(Variable v) {
275        boolean isDUafter_Variable_value = getExpr().isDUafter(v);
276    
277        return isDUafter_Variable_value;
278      }
279      /**
280       * @attribute syn
281       * @aspect AccessTypes
282       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:63
283       */
284      @ASTNodeAnnotation.Attribute
285      public boolean isArrayAccess() {
286        boolean isArrayAccess_value = true;
287    
288        return isArrayAccess_value;
289      }
290      /**
291       * Defines the expected kind of name for the left hand side in a qualified
292       * expression.
293       * @attribute syn
294       * @aspect SyntacticClassification
295       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:58
296       */
297      @ASTNodeAnnotation.Attribute
298      public NameType predNameType() {
299        NameType predNameType_value = NameType.EXPRESSION_NAME;
300    
301        return predNameType_value;
302      }
303      /**
304       * @apilevel internal
305       */
306      protected boolean type_computed = false;
307      /**
308       * @apilevel internal
309       */
310      protected TypeDecl type_value;
311      /**
312       * @apilevel internal
313       */
314      private void type_reset() {
315        type_computed = false;
316        type_value = null;
317      }
318      /**
319       * @attribute syn
320       * @aspect TypeAnalysis
321       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302
322       */
323      @ASTNodeAnnotation.Attribute
324      public TypeDecl type() {
325        ASTNode$State state = state();
326        if (type_computed) {
327          return type_value;
328        }
329        boolean intermediate = state.INTERMEDIATE_VALUE;
330        state.INTERMEDIATE_VALUE = false;
331        int num = state.boundariesCrossed;
332        boolean isFinal = this.is$Final();
333        type_value = isQualified() ? qualifier().type().componentType() : unknownType();
334        if (isFinal && num == state().boundariesCrossed) {
335          type_computed = true;
336        } else {
337        }
338        state.INTERMEDIATE_VALUE |= intermediate;
339    
340        return type_value;
341      }
342      /**
343       * @attribute syn
344       * @aspect TypeCheck
345       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:36
346       */
347      @ASTNodeAnnotation.Attribute
348      public boolean isVariable() {
349        boolean isVariable_value = true;
350    
351        return isVariable_value;
352      }
353      /**
354       * @attribute syn
355       * @aspect PreciseRethrow
356       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149
357       */
358      @ASTNodeAnnotation.Attribute
359      public boolean modifiedInScope(Variable var) {
360        boolean modifiedInScope_Variable_value = getExpr().modifiedInScope(var);
361    
362        return modifiedInScope_Variable_value;
363      }
364      /**
365       * @attribute inh
366       * @aspect TypeAnalysis
367       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:307
368       */
369      /**
370       * @attribute inh
371       * @aspect TypeAnalysis
372       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:307
373       */
374      @ASTNodeAnnotation.Attribute
375      public TypeDecl unknownType() {
376        TypeDecl unknownType_value = getParent().Define_unknownType(this, null);
377    
378        return unknownType_value;
379      }
380      /**
381       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:37
382       * @apilevel internal
383       */
384      public boolean Define_isDest(ASTNode caller, ASTNode child) {
385        if (caller == getExprNoTransform()) {
386          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:56
387          return false;
388        }
389        else {
390          return getParent().Define_isDest(this, caller);
391        }
392      }
393      protected boolean canDefine_isDest(ASTNode caller, ASTNode child) {
394        return true;
395      }
396      /**
397       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47
398       * @apilevel internal
399       */
400      public boolean Define_isSource(ASTNode caller, ASTNode child) {
401        if (caller == getExprNoTransform()) {
402          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:57
403          return true;
404        }
405        else {
406          return getParent().Define_isSource(this, caller);
407        }
408      }
409      protected boolean canDefine_isSource(ASTNode caller, ASTNode child) {
410        return true;
411      }
412      /**
413       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46
414       * @apilevel internal
415       */
416      public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) {
417        if (caller == getExprNoTransform()) {
418          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:52
419          return unqualifiedScope().lookupMethod(name);
420        }
421        else {
422          return getParent().Define_lookupMethod(this, caller, name);
423        }
424      }
425      protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) {
426        return true;
427      }
428      /**
429       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:115
430       * @apilevel internal
431       */
432      public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) {
433        if (caller == getExprNoTransform()) {
434          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:122
435          return unqualifiedScope().hasPackage(packageName);
436        }
437        else {
438          return getParent().Define_hasPackage(this, caller, packageName);
439        }
440      }
441      protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) {
442        return true;
443      }
444      /**
445       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197
446       * @apilevel internal
447       */
448      public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) {
449        if (caller == getExprNoTransform()) {
450          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:332
451          return unqualifiedScope().lookupType(name);
452        }
453        else {
454          return getParent().Define_lookupType(this, caller, name);
455        }
456      }
457      protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) {
458        return true;
459      }
460      /**
461       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30
462       * @apilevel internal
463       */
464      public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) {
465        if (caller == getExprNoTransform()) {
466          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:223
467          return unqualifiedScope().lookupVariable(name);
468        }
469        else {
470          return getParent().Define_lookupVariable(this, caller, name);
471        }
472      }
473      protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) {
474        return true;
475      }
476      /**
477       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
478       * @apilevel internal
479       */
480      public NameType Define_nameType(ASTNode caller, ASTNode child) {
481        if (caller == getExprNoTransform()) {
482          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:145
483          return NameType.EXPRESSION_NAME;
484        }
485        else {
486          return getParent().Define_nameType(this, caller);
487        }
488      }
489      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
490        return true;
491      }
492      /**
493       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196
494       * @apilevel internal
495       */
496      public boolean Define_assignmentContext(ASTNode caller, ASTNode child) {
497        if (caller == getExprNoTransform()) {
498          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:282
499          return false;
500        }
501        else {
502          return getParent().Define_assignmentContext(this, caller);
503        }
504      }
505      protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) {
506        return true;
507      }
508      /**
509       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197
510       * @apilevel internal
511       */
512      public boolean Define_invocationContext(ASTNode caller, ASTNode child) {
513        if (caller == getExprNoTransform()) {
514          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:283
515          return false;
516        }
517        else {
518          return getParent().Define_invocationContext(this, caller);
519        }
520      }
521      protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) {
522        return true;
523      }
524      /**
525       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198
526       * @apilevel internal
527       */
528      public boolean Define_castContext(ASTNode caller, ASTNode child) {
529        if (caller == getExprNoTransform()) {
530          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:284
531          return false;
532        }
533        else {
534          return getParent().Define_castContext(this, caller);
535        }
536      }
537      protected boolean canDefine_castContext(ASTNode caller, ASTNode child) {
538        return true;
539      }
540      /**
541       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199
542       * @apilevel internal
543       */
544      public boolean Define_stringContext(ASTNode caller, ASTNode child) {
545        if (caller == getExprNoTransform()) {
546          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:285
547          return false;
548        }
549        else {
550          return getParent().Define_stringContext(this, caller);
551        }
552      }
553      protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) {
554        return true;
555      }
556      /**
557       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200
558       * @apilevel internal
559       */
560      public boolean Define_numericContext(ASTNode caller, ASTNode child) {
561        if (caller == getExprNoTransform()) {
562          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:286
563          return false;
564        }
565        else {
566          return getParent().Define_numericContext(this, caller);
567        }
568      }
569      protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) {
570        return true;
571      }
572      /**
573       * @apilevel internal
574       */
575      public ASTNode rewriteTo() {
576        return super.rewriteTo();
577      }
578    }