001    /* This file was generated with JastAdd2 (http://jastadd.org) version R20130213 */
002    package AST;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.*;
007    import beaver.*;
008    import java.util.ArrayList;
009    import java.util.zip.*;
010    import java.io.*;
011    import java.io.FileNotFoundException;
012    import java.util.Collection;
013    /**
014     * @production TypeAccess : {@link Access} ::= <span class="component">&lt;Package:String&gt;</span> <span class="component">&lt;ID:String&gt;</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:23
017     */
018    public class TypeAccess extends Access implements Cloneable {
019      /**
020       * @apilevel low-level
021       */
022      public void flushCache() {
023      }
024      /**
025       * @apilevel internal
026       */
027      public void flushCollectionCache() {
028      }
029      /**
030       * @apilevel internal
031       */
032      @SuppressWarnings({"unchecked", "cast"})
033      public TypeAccess clone() throws CloneNotSupportedException {
034        TypeAccess node = (TypeAccess)super.clone();
035        node.decls_computed = false;
036        node.decls_value = null;
037        node.decl_computed = false;
038        node.decl_value = null;
039        node.type_computed = false;
040        node.type_value = null;
041        node.in$Circle(false);
042        node.is$Final(false);
043        return node;
044      }
045    /**
046     * @apilevel internal
047     */
048      @SuppressWarnings({"unchecked", "cast"})
049    public TypeAccess copy() {
050      
051      try {
052        TypeAccess node = (TypeAccess) clone();
053        node.parent = null;
054        if(children != null)
055          node.children = (ASTNode[]) children.clone();
056        
057        return node;
058      } catch (CloneNotSupportedException e) {
059        throw new Error("Error: clone not supported for " + getClass().getName());
060      }
061      
062    }/**
063     * Create a deep copy of the AST subtree at this node.
064     * The copy is dangling, i.e. has no parent.
065     * @return dangling copy of the subtree at this node
066     * @apilevel low-level
067     */
068      @SuppressWarnings({"unchecked", "cast"})
069    public TypeAccess fullCopy() {
070      
071      TypeAccess tree = (TypeAccess) copy();
072      if (children != null) {
073        for (int i = 0; i < children.length; ++i) {
074          
075          ASTNode child = (ASTNode) children[i];
076          if(child != null) {
077            child = child.fullCopy();
078            tree.setChild(child, i);
079          }
080        }
081      }
082      return tree;
083      
084    }  /**
085       * @ast method 
086       * @aspect AccessControl
087       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/AccessControl.jrag:128
088       */
089      public void accessControl() {
090        super.accessControl();
091        TypeDecl hostType = hostType();
092        if(hostType != null && !hostType.isUnknown() && !type().accessibleFrom(hostType)) {
093          error("" + this + " in " + hostType().fullName() + " can not access type " + type().fullName());
094        }
095        else if((hostType == null || hostType.isUnknown())  && !type().accessibleFromPackage(hostPackage())) {
096          error("" + this + " can not access type " + type().fullName());
097        }
098      }
099      /**
100       * @ast method 
101       * @aspect NameCheck
102       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:160
103       */
104      public void nameCheck() {
105        if(isQualified() && !qualifier().isTypeAccess() && !qualifier().isPackageAccess())
106          error("can not access the type named " + decl().typeName() + " in this context");
107        if(decls().isEmpty())
108          error("no visible type named " + typeName());
109        if(decls().size() > 1) {
110          StringBuffer s = new StringBuffer();
111          s.append("several types named " + name() + ":");
112          for(Iterator iter = decls().iterator(); iter.hasNext(); ) {
113            TypeDecl t = (TypeDecl)iter.next();
114            s.append(" " + t.typeName());
115          }
116          error(s.toString());
117        }
118      }
119      /**
120       * @ast method 
121       * @aspect NodeConstructors
122       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NodeConstructors.jrag:23
123       */
124      public TypeAccess(String name, int start, int end) {
125        this(name);
126        this.start = this.IDstart = start;
127        this.end = this.IDend = end;
128      }
129      /**
130       * @ast method 
131       * @aspect NodeConstructors
132       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NodeConstructors.jrag:44
133       */
134      public TypeAccess(String typeName) {
135        this("", typeName);
136      }
137      /**
138       * @ast method 
139       * @aspect PrettyPrint
140       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:483
141       */
142      public void toString(StringBuffer s) {
143        if(decl().isReferenceType())
144          s.append(nameWithPackage());
145        else
146          s.append(decl().name());
147      }
148      /**
149       * @ast method 
150       * @aspect Annotations
151       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Annotations.jrag:328
152       */
153      public void checkModifiers() {
154        if(decl().isDeprecated() &&
155           !withinDeprecatedAnnotation() &&
156           (hostType() == null || hostType().topLevelType() != decl().topLevelType()) &&
157           !withinSuppressWarnings("deprecation"))
158          warning(decl().typeName() + " has been deprecated");
159      }
160      /**
161       * @ast method 
162       * @aspect GenericsTypeAnalysis
163       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:298
164       */
165      public boolean isRaw() {
166        /*
167        if(hasNextAccess())
168          return false;
169        */
170        ASTNode parent = getParent();
171        while(parent instanceof AbstractDot)
172          parent = parent.getParent();
173        if(parent instanceof ParTypeAccess)
174          return false;
175        if(parent instanceof ImportDecl)
176          return false;
177        /*
178        Access a = this;
179        while(a.isTypeAccess() && hasNextAccess())
180          a = a.nextAccess();
181        if(a.isThisAccess() || a.isSuperAccess())
182          return false;
183        */
184        return true;
185      }
186      /**
187       * @ast method 
188       * @aspect GenericsTypeCheck
189       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:438
190       */
191      public void typeCheck() {
192        TypeDecl type = type();
193        if(type.isRawType() && type.isNestedType() && type.enclosingType().isParameterizedType() && !type.enclosingType().isRawType())
194          error("Can not access a member type of a paramterized type as a raw type");
195      }
196      /**
197       * @ast method 
198       * 
199       */
200      public TypeAccess() {
201        super();
202    
203    
204      }
205      /**
206       * Initializes the child array to the correct size.
207       * Initializes List and Opt nta children.
208       * @apilevel internal
209       * @ast method
210       * @ast method 
211       * 
212       */
213      public void init$Children() {
214      }
215      /**
216       * @ast method 
217       * 
218       */
219      public TypeAccess(String p0, String p1) {
220        setPackage(p0);
221        setID(p1);
222      }
223      /**
224       * @ast method 
225       * 
226       */
227      public TypeAccess(beaver.Symbol p0, beaver.Symbol p1) {
228        setPackage(p0);
229        setID(p1);
230      }
231      /**
232       * @apilevel low-level
233       * @ast method 
234       * 
235       */
236      protected int numChildren() {
237        return 0;
238      }
239      /**
240       * @apilevel internal
241       * @ast method 
242       * 
243       */
244      public boolean mayHaveRewrite() {
245        return false;
246      }
247      /**
248       * Replaces the lexeme Package.
249       * @param value The new value for the lexeme Package.
250       * @apilevel high-level
251       * @ast method 
252       * 
253       */
254      public void setPackage(String value) {
255        tokenString_Package = value;
256      }
257      /**
258       * @apilevel internal
259       * @ast method 
260       * 
261       */
262      
263      /**
264       * @apilevel internal
265       */
266      protected String tokenString_Package;
267      /**
268       * @ast method 
269       * 
270       */
271      
272      public int Packagestart;
273      /**
274       * @ast method 
275       * 
276       */
277      
278      public int Packageend;
279      /**
280       * JastAdd-internal setter for lexeme Package using the Beaver parser.
281       * @apilevel internal
282       * @ast method 
283       * 
284       */
285      public void setPackage(beaver.Symbol symbol) {
286        if(symbol.value != null && !(symbol.value instanceof String))
287          throw new UnsupportedOperationException("setPackage is only valid for String lexemes");
288        tokenString_Package = (String)symbol.value;
289        Packagestart = symbol.getStart();
290        Packageend = symbol.getEnd();
291      }
292      /**
293       * Retrieves the value for the lexeme Package.
294       * @return The value for the lexeme Package.
295       * @apilevel high-level
296       * @ast method 
297       * 
298       */
299      public String getPackage() {
300        return tokenString_Package != null ? tokenString_Package : "";
301      }
302      /**
303       * Replaces the lexeme ID.
304       * @param value The new value for the lexeme ID.
305       * @apilevel high-level
306       * @ast method 
307       * 
308       */
309      public void setID(String value) {
310        tokenString_ID = value;
311      }
312      /**
313       * @apilevel internal
314       * @ast method 
315       * 
316       */
317      
318      /**
319       * @apilevel internal
320       */
321      protected String tokenString_ID;
322      /**
323       * @ast method 
324       * 
325       */
326      
327      public int IDstart;
328      /**
329       * @ast method 
330       * 
331       */
332      
333      public int IDend;
334      /**
335       * JastAdd-internal setter for lexeme ID using the Beaver parser.
336       * @apilevel internal
337       * @ast method 
338       * 
339       */
340      public void setID(beaver.Symbol symbol) {
341        if(symbol.value != null && !(symbol.value instanceof String))
342          throw new UnsupportedOperationException("setID is only valid for String lexemes");
343        tokenString_ID = (String)symbol.value;
344        IDstart = symbol.getStart();
345        IDend = symbol.getEnd();
346      }
347      /**
348       * Retrieves the value for the lexeme ID.
349       * @return The value for the lexeme ID.
350       * @apilevel high-level
351       * @ast method 
352       * 
353       */
354      public String getID() {
355        return tokenString_ID != null ? tokenString_ID : "";
356      }
357      /**
358       * @ast method 
359       * @aspect GenericsCodegen
360       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/GenericsCodegen.jrag:303
361       */
362        public void transformation() {
363        super.transformation();
364        if(type().elementType().isNestedType() && hostType() != null)
365          hostType().addUsedNestedType(type().elementType().erasure().sourceTypeDecl());
366      }
367      /**
368       * @ast method 
369       * @aspect TypeScopePropagation
370       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupType.jrag:238
371       */
372      private TypeDecl refined_TypeScopePropagation_TypeAccess_decl()
373    {
374        SimpleSet decls = decls();
375        if(decls.size() == 1) {
376          return (TypeDecl)decls.iterator().next();
377        }
378        return unknownType();
379      }
380      /**
381       * @apilevel internal
382       */
383      protected boolean decls_computed = false;
384      /**
385       * @apilevel internal
386       */
387      protected SimpleSet decls_value;
388      /**
389       * @attribute syn
390       * @aspect TypeScopePropagation
391       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupType.jrag:223
392       */
393      @SuppressWarnings({"unchecked", "cast"})
394      public SimpleSet decls() {
395        if(decls_computed) {
396          return decls_value;
397        }
398          ASTNode$State state = state();
399      int num = state.boundariesCrossed;
400      boolean isFinal = this.is$Final();
401        decls_value = decls_compute();
402      if(isFinal && num == state().boundariesCrossed){ decls_computed = true; }
403            return decls_value;
404      }
405      /**
406       * @apilevel internal
407       */
408      private SimpleSet decls_compute() {
409        if(packageName().equals(""))
410          return lookupType(name());
411        else {
412          TypeDecl typeDecl = lookupType(packageName(), name());
413          if(typeDecl != null)
414            return SimpleSet.emptySet.add(typeDecl);
415          return SimpleSet.emptySet;
416        }
417      }
418      /**
419       * @apilevel internal
420       */
421      protected boolean decl_computed = false;
422      /**
423       * @apilevel internal
424       */
425      protected TypeDecl decl_value;
426      /**
427       * @attribute syn
428       * @aspect GenericsTypeAnalysis
429       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:290
430       */
431      @SuppressWarnings({"unchecked", "cast"})
432      public TypeDecl decl() {
433        if(decl_computed) {
434          return decl_value;
435        }
436          ASTNode$State state = state();
437      int num = state.boundariesCrossed;
438      boolean isFinal = this.is$Final();
439        decl_value = decl_compute();
440      if(isFinal && num == state().boundariesCrossed){ decl_computed = true; }
441            return decl_value;
442      }
443      /**
444       * @apilevel internal
445       */
446      private TypeDecl decl_compute() {
447        TypeDecl decl = refined_TypeScopePropagation_TypeAccess_decl();
448        if(decl instanceof GenericTypeDecl && isRaw())
449          return ((GenericTypeDecl)decl).lookupParTypeDecl(new ArrayList());
450        return decl;
451      }
452      /**
453       * @attribute syn
454       * @aspect VariableScope
455       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupVariable.jrag:148
456       */
457      public SimpleSet qualifiedLookupVariable(String name) {
458        ASTNode$State state = state();
459        try {
460        if(type().accessibleFrom(hostType())) {
461          SimpleSet c = type().memberFields(name);
462          c = keepAccessibleFields(c);
463          if(type().isClassDecl() && c.size() == 1)
464            c = removeInstanceVariables(c);
465          return c;
466        }
467        return SimpleSet.emptySet;
468      }
469        finally {
470        }
471      }
472      /**
473       * @attribute syn
474       * @aspect PrettyPrint
475       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:800
476       */
477      public String dumpString() {
478        ASTNode$State state = state();
479        try {  return getClass().getName() + " [" + getPackage() + ", " + getID() + "]";  }
480        finally {
481        }
482      }
483      /**
484       * @attribute syn
485       * @aspect Names
486       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/QualifiedNames.jrag:21
487       */
488      public String name() {
489        ASTNode$State state = state();
490        try {  return getID();  }
491        finally {
492        }
493      }
494      /**
495       * @attribute syn
496       * @aspect Names
497       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/QualifiedNames.jrag:25
498       */
499      public String packageName() {
500        ASTNode$State state = state();
501        try {  return getPackage();  }
502        finally {
503        }
504      }
505      /**
506       * @attribute syn
507       * @aspect Names
508       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/QualifiedNames.jrag:49
509       */
510      public String nameWithPackage() {
511        ASTNode$State state = state();
512        try {  return getPackage().equals("") ? name() : (getPackage() + "." + name());  }
513        finally {
514        }
515      }
516      /**
517       * @attribute syn
518       * @aspect Names
519       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/QualifiedNames.jrag:62
520       */
521      public String typeName() {
522        ASTNode$State state = state();
523        try {  return isQualified() ? (qualifier().typeName() + "." + name()) : nameWithPackage();  }
524        finally {
525        }
526      }
527      /**
528       * @attribute syn
529       * @aspect AccessTypes
530       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:13
531       */
532      public boolean isTypeAccess() {
533        ASTNode$State state = state();
534        try {  return true;  }
535        finally {
536        }
537      }
538      /**
539       * @attribute syn
540       * @aspect SyntacticClassification
541       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/SyntacticClassification.jrag:56
542       */
543      public NameType predNameType() {
544        ASTNode$State state = state();
545        try {  return NameType.PACKAGE_OR_TYPE_NAME;  }
546        finally {
547        }
548      }
549      /**
550       * @apilevel internal
551       */
552      protected boolean type_computed = false;
553      /**
554       * @apilevel internal
555       */
556      protected TypeDecl type_value;
557      /**
558       * @attribute syn
559       * @aspect TypeAnalysis
560       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:279
561       */
562      @SuppressWarnings({"unchecked", "cast"})
563      public TypeDecl type() {
564        if(type_computed) {
565          return type_value;
566        }
567          ASTNode$State state = state();
568      int num = state.boundariesCrossed;
569      boolean isFinal = this.is$Final();
570        type_value = type_compute();
571      if(isFinal && num == state().boundariesCrossed){ type_computed = true; }
572            return type_value;
573      }
574      /**
575       * @apilevel internal
576       */
577      private TypeDecl type_compute() {  return decl();  }
578      /**
579       * @attribute syn
580       * @aspect TypeHierarchyCheck
581       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeHierarchyCheck.jrag:150
582       */
583      public boolean staticContextQualifier() {
584        ASTNode$State state = state();
585        try {  return true;  }
586        finally {
587        }
588      }
589      /**
590       * @attribute syn
591       * @aspect LookupParTypeDecl
592       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:1056
593       */
594      public boolean usesTypeVariable() {
595        ASTNode$State state = state();
596        try {  return decl().usesTypeVariable() || super.usesTypeVariable();  }
597        finally {
598        }
599      }
600      /**
601        * Builds a copy of this Access node where all occurrences
602        * of type variables in the original type parameter list have been replaced
603        * by the substitution type parameters.
604        *
605        * @return the substituted Access node
606        * @attribute syn
607       * @aspect TypeInference
608       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/TypeInference.jrag:406
609       */
610      public Access substituted(Collection<TypeVariable> original, List<TypeVariable> substitution) {
611        ASTNode$State state = state();
612        try {
613               TypeDecl decl = decl();
614               int i = 0;
615               for (TypeVariable typeVar : original) {
616                       if (typeVar == decl)
617                               return new TypeAccess(substitution.getChild(i).getID());
618                       i += 1;
619               }
620               return super.substituted(original, substitution);
621       }
622        finally {
623        }
624      }
625      /**
626       * @apilevel internal
627       */
628      public ASTNode rewriteTo() {
629        return super.rewriteTo();
630      }
631    }