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