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 an ExplicitConstructorInvocation. 
024     * <p> Only occurs as the first Stmt in a ConstructorDecl. 
025     * <p> Name resolution sets the decl field to the callee.
026     */
027    
028    public class ConstructorInvocation extends Stmt
029    {
030      /**
031       * superCall is true implies call is "super(...)",
032       * superCall is false implies call is "this(...)".
033       */
034      public boolean superCall;
035    
036    
037      /**
038       * The enclosing instance is the object expression before a super
039       * call ( <enclosingInstance>.super(...) ).  This field may be null
040       * if there is no such expression.
041       *
042       * @note If the supertype in question is an inner class, then the
043       * type checker will infer a [<C>.]this expression if no expression
044       * is present and place it in this slot.  (See ThisExpr for how to
045       * distinguish inferred this expressions.)<p>
046       */
047      public Expr enclosingInstance;
048    
049    
050      //@ invariant enclosingInstance != null && superCall ==> locDot != Location.NULL;
051      public int locDot;
052    
053    
054      //@ invariant locKeyword != javafe.util.Location.NULL;
055      public int locKeyword;
056    
057      //@ invariant locOpenParen != javafe.util.Location.NULL;
058      public int locOpenParen;
059    
060    
061      public /*@ non_null @*/ ExprVec args;
062    
063    
064      public ConstructorDecl decl;
065    
066      private void postCheck() {
067        if (decl != null) {
068          // Any invariants here...???
069        }
070      }
071    
072      public int getStartLoc() {
073        if (enclosingInstance == null) return locKeyword;
074        else return enclosingInstance.getStartLoc();
075      }
076    
077      public int getEndLoc() { 
078        if (args.size()<1)
079          return super.getEndLoc();
080    
081        return args.elementAt(args.size()-1).getEndLoc();
082      }
083    
084      //@ requires enclosingInstance != null && superCall ==> locDot != Location.NULL;
085      //
086      //@ requires locKeyword != javafe.util.Location.NULL;
087      //@ requires locOpenParen != javafe.util.Location.NULL;
088      //@ ensures \result != null;
089      public static ConstructorInvocation make(boolean superCall, 
090                                               Expr enclosingInstance, 
091                                               int locDot, 
092                                               int locKeyword, 
093                                               int locOpenParen, 
094                                               /*@ non_null @*/ ExprVec args) {
095         //@ set I_will_establish_invariants_afterwards = true;
096         ConstructorInvocation result = new ConstructorInvocation();
097         result.superCall = superCall;
098         result.enclosingInstance = enclosingInstance;
099         result.locDot = locDot;
100         result.locKeyword = locKeyword;
101         result.locOpenParen = locOpenParen;
102         result.args = args;
103         return result;
104      }
105    
106    
107    // Generated boilerplate constructors:
108    
109      /**
110       * Construct a raw ConstructorInvocation whose class invariant(s) have not
111       * yet been established.  It is the caller's job to
112       * initialize the returned node's fields so that any
113       * class invariants hold.
114       */
115      //@ requires I_will_establish_invariants_afterwards;
116      protected ConstructorInvocation() {}    //@ nowarn Invariant,NonNullInit;
117    
118    
119    // Generated boilerplate methods:
120    
121      public final int childCount() {
122         int sz = 0;
123         if (this.args != null) sz += this.args.size();
124         return sz + 1;
125      }
126    
127      public final Object childAt(int index) {
128              /*throws IndexOutOfBoundsException*/
129         if (index < 0)
130            throw new IndexOutOfBoundsException("AST child index " + index);
131         int indexPre = index;
132    
133         int sz;
134    
135         if (index == 0) return this.enclosingInstance;
136         else index--;
137    
138         sz = (this.args == null ? 0 : this.args.size());
139         if (0 <= index && index < sz)
140            return this.args.elementAt(index);
141         else index -= sz;
142    
143         throw new IndexOutOfBoundsException("AST child index " + indexPre);
144      }   //@ nowarn Exception;
145    
146      public final String toString() {
147         return "[ConstructorInvocation"
148            + " superCall = " + this.superCall
149            + " enclosingInstance = " + this.enclosingInstance
150            + " locDot = " + this.locDot
151            + " locKeyword = " + this.locKeyword
152            + " locOpenParen = " + this.locOpenParen
153            + " args = " + this.args
154            + "]";
155      }
156    
157      public final int getTag() {
158         return TagConstants.CONSTRUCTORINVOCATION;
159      }
160    
161      public final void accept(Visitor v) { v.visitConstructorInvocation(this); }
162    
163      public final Object accept(VisitorArgResult v, Object o) {return v.visitConstructorInvocation(this, o); }
164    
165      public void check() {
166         super.check();
167         if (this.enclosingInstance != null)
168            this.enclosingInstance.check();
169         for(int i = 0; i < this.args.size(); i++)
170            this.args.elementAt(i).check();
171         postCheck();
172      }
173    
174    }