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/java8/grammar/Lambda.ast:11 027 * @production LambdaBody : {@link ASTNode}; 028 029 */ 030 public abstract class LambdaBody extends ASTNode<ASTNode> implements Cloneable { 031 /** 032 * @declaredat ASTNode:1 033 */ 034 public LambdaBody() { 035 super(); 036 } 037 /** 038 * Initializes the child array to the correct size. 039 * Initializes List and Opt nta children. 040 * @apilevel internal 041 * @ast method 042 * @declaredat ASTNode:10 043 */ 044 public void init$Children() { 045 } 046 /** 047 * @apilevel low-level 048 * @declaredat ASTNode:15 049 */ 050 protected int numChildren() { 051 return 0; 052 } 053 /** 054 * @apilevel internal 055 * @declaredat ASTNode:21 056 */ 057 public boolean mayHaveRewrite() { 058 return false; 059 } 060 /** 061 * @apilevel internal 062 * @declaredat ASTNode:27 063 */ 064 public void flushAttrCache() { 065 super.flushAttrCache(); 066 enclosingLambda_reset(); 067 lookupVariable_String_reset(); 068 } 069 /** 070 * @apilevel internal 071 * @declaredat ASTNode:35 072 */ 073 public void flushCollectionCache() { 074 super.flushCollectionCache(); 075 } 076 /** 077 * @apilevel internal 078 * @declaredat ASTNode:41 079 */ 080 public void flushRewriteCache() { 081 super.flushRewriteCache(); 082 } 083 /** 084 * @apilevel internal 085 * @declaredat ASTNode:47 086 */ 087 public LambdaBody clone() throws CloneNotSupportedException { 088 LambdaBody node = (LambdaBody) super.clone(); 089 return node; 090 } 091 /** 092 * Create a deep copy of the AST subtree at this node. 093 * The copy is dangling, i.e. has no parent. 094 * @return dangling copy of the subtree at this node 095 * @apilevel low-level 096 * @deprecated Please use treeCopy or treeCopyNoTransform instead 097 * @declaredat ASTNode:58 098 */ 099 @Deprecated 100 public abstract LambdaBody fullCopy(); 101 /** 102 * Create a deep copy of the AST subtree at this node. 103 * The copy is dangling, i.e. has no parent. 104 * @return dangling copy of the subtree at this node 105 * @apilevel low-level 106 * @declaredat ASTNode:66 107 */ 108 public abstract LambdaBody treeCopyNoTransform(); 109 /** 110 * Create a deep copy of the AST subtree at this node. 111 * The subtree of this node is traversed to trigger rewrites before copy. 112 * The copy is dangling, i.e. has no parent. 113 * @return dangling copy of the subtree at this node 114 * @apilevel low-level 115 * @declaredat ASTNode:74 116 */ 117 public abstract LambdaBody treeCopy(); 118 /** 119 * @attribute syn 120 * @aspect PreciseRethrow 121 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:43 122 */ 123 @ASTNodeAnnotation.Attribute 124 public abstract boolean modifiedInScope(Variable var); 125 /** 126 * @attribute syn 127 * @aspect LambdaBody 128 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaBody.jrag:29 129 */ 130 @ASTNodeAnnotation.Attribute 131 public abstract boolean isBlockBody(); 132 /** 133 * @attribute syn 134 * @aspect LambdaBody 135 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaBody.jrag:30 136 */ 137 @ASTNodeAnnotation.Attribute 138 public abstract boolean isExprBody(); 139 /** 140 * @attribute syn 141 * @aspect LambdaExpr 142 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:71 143 */ 144 @ASTNodeAnnotation.Attribute 145 public abstract boolean congruentTo(FunctionDescriptor f); 146 /** 147 * @attribute syn 148 * @aspect LambdaToClass 149 * @declaredat /home/jesper/git/extendj/java8/backend/LambdaToClass.jrag:68 150 */ 151 @ASTNodeAnnotation.Attribute 152 public abstract Block toBlock(); 153 /** 154 * @attribute inh 155 * @aspect EnclosingLambda 156 * @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:29 157 */ 158 /** 159 * @attribute inh 160 * @aspect EnclosingLambda 161 * @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:29 162 */ 163 @ASTNodeAnnotation.Attribute 164 public LambdaExpr enclosingLambda() { 165 ASTNode$State state = state(); 166 if (enclosingLambda_computed) { 167 return enclosingLambda_value; 168 } 169 boolean intermediate = state.INTERMEDIATE_VALUE; 170 state.INTERMEDIATE_VALUE = false; 171 int num = state.boundariesCrossed; 172 boolean isFinal = this.is$Final(); 173 enclosingLambda_value = getParent().Define_enclosingLambda(this, null); 174 if (isFinal && num == state().boundariesCrossed) { 175 enclosingLambda_computed = true; 176 } else { 177 } 178 state.INTERMEDIATE_VALUE |= intermediate; 179 180 return enclosingLambda_value; 181 } 182 /** 183 * @apilevel internal 184 */ 185 protected boolean enclosingLambda_computed = false; 186 /** 187 * @apilevel internal 188 */ 189 protected LambdaExpr enclosingLambda_value; 190 /** 191 * @apilevel internal 192 */ 193 private void enclosingLambda_reset() { 194 enclosingLambda_computed = false; 195 enclosingLambda_value = null; 196 } 197 /** 198 * @attribute inh 199 * @aspect VariableScope 200 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 201 */ 202 /** 203 * @attribute inh 204 * @aspect VariableScope 205 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 206 */ 207 @ASTNodeAnnotation.Attribute 208 public SimpleSet lookupVariable(String name) { 209 Object _parameters = name; 210 if (lookupVariable_String_values == null) lookupVariable_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 211 ASTNode$State state = state(); 212 if (lookupVariable_String_values.containsKey(_parameters)) { 213 return (SimpleSet) lookupVariable_String_values.get(_parameters); 214 } 215 boolean intermediate = state.INTERMEDIATE_VALUE; 216 state.INTERMEDIATE_VALUE = false; 217 int num = state.boundariesCrossed; 218 boolean isFinal = this.is$Final(); 219 SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name); 220 if (isFinal && num == state().boundariesCrossed) { 221 lookupVariable_String_values.put(_parameters, lookupVariable_String_value); 222 } else { 223 } 224 state.INTERMEDIATE_VALUE |= intermediate; 225 226 return lookupVariable_String_value; 227 } 228 /** 229 * @apilevel internal 230 */ 231 protected java.util.Map lookupVariable_String_values; 232 /** 233 * @apilevel internal 234 */ 235 private void lookupVariable_String_reset() { 236 lookupVariable_String_values = null; 237 } 238 /** 239 * @attribute inh 240 * @aspect TypeCheck 241 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:31 242 */ 243 /** 244 * @attribute inh 245 * @aspect TypeCheck 246 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:31 247 */ 248 @ASTNodeAnnotation.Attribute 249 public TypeDecl unknownType() { 250 TypeDecl unknownType_value = getParent().Define_unknownType(this, null); 251 252 return unknownType_value; 253 } 254 /** 255 * @apilevel internal 256 */ 257 public ASTNode rewriteTo() { 258 return super.rewriteTo(); 259 } 260 }