001    /* Copyright 2000, 2001, Compaq Computer Corporation */
002    
003    /* IF THIS IS A JAVA FILE, DO NOT EDIT IT!  
004    
005       Most Java files in this directory which are part of the Javafe AST
006       are automatically generated using the astgen comment (see
007       ESCTools/Javafe/astgen) from the input file 'hierarchy.h'.  If you
008       wish to modify AST classes or introduce new ones, modify
009       'hierarchy.j.'
010     */
011    
012    package javafe.ast;
013    
014    import javafe.util.Assert;
015    import javafe.util.Location;
016    import javafe.util.ErrorSet;
017    
018    // Convention: unless otherwise noted, integer fields named "loc" refer
019    // to the location of the first character of the syntactic unit
020    
021    
022    /**
023     * Represents a Name occuring before an argument list.
024     * Is created by the parser, and then resolved to either an
025     * InstanceMethodAccess or ClassMethodAccess by the name resolution code.
026     *
027     * <p> Thus for the method call "x.y()", the "x.y" part is initially 
028     * represented as a MethodName, 
029     * and then resolved to a InstanceMethodAccess if "x" is a variable, 
030     * or resolved to a ClassMethodAccess if "x" is a type name.
031     */
032    
033    public class AmbiguousMethodInvocation extends Expr
034    {
035      public /*@ non_null @*/ Name name;
036    
037      public TypeModifierPragmaVec tmodifiers;
038    
039      //@ invariant locOpenParen != javafe.util.Location.NULL;
040      public int locOpenParen;
041    
042      public /*@ non_null @*/ ExprVec args;
043    
044      public int getStartLoc() { return name.getStartLoc(); }
045      public int getEndLoc() { 
046        if (args.size()<1)
047          return name.getEndLoc();
048    
049        return args.elementAt(args.size()-1).getEndLoc();
050      }
051    
052    
053    // Generated boilerplate constructors:
054    
055      /**
056       * Construct a raw AmbiguousMethodInvocation whose class invariant(s) have not
057       * yet been established.  It is the caller's job to
058       * initialize the returned node's fields so that any
059       * class invariants hold.
060       */
061      //@ requires I_will_establish_invariants_afterwards;
062      protected AmbiguousMethodInvocation() {}    //@ nowarn Invariant,NonNullInit;
063    
064    
065    // Generated boilerplate methods:
066    
067      public final int childCount() {
068         int sz = 0;
069         if (this.tmodifiers != null) sz += this.tmodifiers.size();
070         if (this.args != null) sz += this.args.size();
071         return sz + 1;
072      }
073    
074      public final Object childAt(int index) {
075              /*throws IndexOutOfBoundsException*/
076         if (index < 0)
077            throw new IndexOutOfBoundsException("AST child index " + index);
078         int indexPre = index;
079    
080         int sz;
081    
082         if (index == 0) return this.name;
083         else index--;
084    
085         sz = (this.tmodifiers == null ? 0 : this.tmodifiers.size());
086         if (0 <= index && index < sz)
087            return this.tmodifiers.elementAt(index);
088         else index -= sz;
089    
090         sz = (this.args == null ? 0 : this.args.size());
091         if (0 <= index && index < sz)
092            return this.args.elementAt(index);
093         else index -= sz;
094    
095         throw new IndexOutOfBoundsException("AST child index " + indexPre);
096      }   //@ nowarn Exception;
097    
098      public final String toString() {
099         return "[AmbiguousMethodInvocation"
100            + " name = " + this.name
101            + " tmodifiers = " + this.tmodifiers
102            + " locOpenParen = " + this.locOpenParen
103            + " args = " + this.args
104            + "]";
105      }
106    
107      public final int getTag() {
108         return TagConstants.AMBIGUOUSMETHODINVOCATION;
109      }
110    
111      public final void accept(Visitor v) { v.visitAmbiguousMethodInvocation(this); }
112    
113      public final Object accept(VisitorArgResult v, Object o) {return v.visitAmbiguousMethodInvocation(this, o); }
114    
115      public void check() {
116         super.check();
117         this.name.check();
118         if (this.tmodifiers != null)
119            for(int i = 0; i < this.tmodifiers.size(); i++)
120               this.tmodifiers.elementAt(i).check();
121         for(int i = 0; i < this.args.size(); i++)
122            this.args.elementAt(i).check();
123      }
124    
125      //@ requires locOpenParen != javafe.util.Location.NULL;
126      //@ ensures \result != null;
127      public static AmbiguousMethodInvocation make(/*@ non_null @*/ Name name, TypeModifierPragmaVec tmodifiers, int locOpenParen, /*@ non_null @*/ ExprVec args) {
128         //@ set I_will_establish_invariants_afterwards = true;
129         AmbiguousMethodInvocation result = new AmbiguousMethodInvocation();
130         result.name = name;
131         result.tmodifiers = tmodifiers;
132         result.locOpenParen = locOpenParen;
133         result.args = args;
134         return result;
135      }
136    }