Attachment 185509 Details for Bug 331334 – Proposed fix

[patch] Proposed fix

patch_331334.txt (text/plain), 21.41 KB, created by Olivier Thomann

on 2010-12-19 19:52:18 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Olivier Thomann

Created: 2010-12-19 19:52:18 EST

Size: 21.41 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core
>Index: compiler/org/eclipse/jdt/internal/compiler/ClassFile.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java,v
>retrieving revision 1.203
>diff -u -r1.203 ClassFile.java
>--- compiler/org/eclipse/jdt/internal/compiler/ClassFile.java	27 Oct 2010 02:55:30 -0000	1.203
>+++ compiler/org/eclipse/jdt/internal/compiler/ClassFile.java	20 Dec 2010 00:49:12 -0000
>@@ -823,6 +823,9 @@
> 					case SyntheticMethodBinding.SwitchTable :
> 						// generate a method info to define the switch table synthetic method
> 						addSyntheticSwitchTable(syntheticMethod);
>+						break;
>+					case SyntheticMethodBinding.TooManyEnumsConstants :
>+						addSyntheticEnumInitializationMethod(syntheticMethod);
> 				}
> 			}
> 		}
>@@ -918,6 +921,29 @@
> 		this.contents[methodAttributeOffset] = (byte) attributeNumber;
> 	}
> 
>+	public void addSyntheticEnumInitializationMethod(SyntheticMethodBinding methodBinding) {
>+		generateMethodInfoHeader(methodBinding);
>+		int methodAttributeOffset = this.contentsOffset;
>+		// this will add exception attribute, synthetic attribute, deprecated attribute,...
>+		int attributeNumber = generateMethodInfoAttributes(methodBinding);
>+		// Code attribute
>+		int codeAttributeOffset = this.contentsOffset;
>+		attributeNumber++; // add code attribute
>+		generateCodeAttributeHeader();
>+		this.codeStream.init(this);
>+		this.codeStream.generateSyntheticBodyForEnumInitializationMethod(methodBinding);
>+		completeCodeAttributeForSyntheticMethod(
>+			methodBinding,
>+			codeAttributeOffset,
>+			((SourceTypeBinding) methodBinding.declaringClass)
>+				.scope
>+				.referenceCompilationUnit()
>+				.compilationResult
>+				.getLineSeparatorPositions());
>+		// update the number of attributes
>+		this.contents[methodAttributeOffset++] = (byte) (attributeNumber >> 8);
>+		this.contents[methodAttributeOffset] = (byte) attributeNumber;
>+	}
> 	/**
> 	 * INTERNAL USE-ONLY
> 	 * Generate the byte for a problem method info that correspond to a synthetic method that
>Index: compiler/org/eclipse/jdt/internal/compiler/ast/Clinit.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Clinit.java,v
>retrieving revision 1.61
>diff -u -r1.61 Clinit.java
>--- compiler/org/eclipse/jdt/internal/compiler/ast/Clinit.java	9 Nov 2010 19:59:19 -0000	1.61
>+++ compiler/org/eclipse/jdt/internal/compiler/ast/Clinit.java	20 Dec 2010 00:49:12 -0000
>@@ -26,6 +26,7 @@
> import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
> import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
> import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
>+import org.eclipse.jdt.internal.compiler.lookup.SyntheticMethodBinding;
> import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
> import org.eclipse.jdt.internal.compiler.parser.Parser;
> import org.eclipse.jdt.internal.compiler.problem.AbortMethod;
>@@ -191,16 +192,44 @@
> 		// generate static fields/initializers/enum constants
> 		final FieldDeclaration[] fieldDeclarations = declaringType.fields;
> 		BlockScope lastInitializerScope = null;
>+		int remainingFieldCount = 0;
> 		if (TypeDeclaration.kind(declaringType.modifiers) == TypeDeclaration.ENUM_DECL) {
>-			int enumCount = 0;
>-			int remainingFieldCount = 0;
>-			if (fieldDeclarations != null) {
>+			int enumCount = declaringType.enumConstantsCounter;
>+			if (enumCount > 2000) {
>+				// generate synthetic methods to initialize all the enum constants
>+				int begin = -1;
>+				int count = 0;
>+				if (fieldDeclarations != null) {
>+					int max = fieldDeclarations.length;
>+					for (int i = 0; i < max; i++) {
>+						FieldDeclaration fieldDecl = fieldDeclarations[i];
>+						if (fieldDecl.isStatic()) {
>+							if (fieldDecl.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {
>+								if (begin == -1) {
>+									begin = i;
>+								}
>+								count++;
>+								if (count > 2000) {
>+									SyntheticMethodBinding syntheticMethod = declaringType.binding.addSyntheticMethodForEnumInitialization(begin, i);
>+									codeStream.invoke(Opcodes.OPC_invokestatic, syntheticMethod, null /* default declaringClass */);
>+									begin = -1;
>+									count = 0;
>+								}
>+							}
>+						}
>+					}
>+					if (count != 0) {
>+						// add last synthetic method
>+						SyntheticMethodBinding syntheticMethod = declaringType.binding.addSyntheticMethodForEnumInitialization(begin, max);
>+						codeStream.invoke(Opcodes.OPC_invokestatic, syntheticMethod, null /* default declaringClass */);
>+					}
>+				}
>+			} else if (fieldDeclarations != null) {
> 				for (int i = 0, max = fieldDeclarations.length; i < max; i++) {
> 					FieldDeclaration fieldDecl = fieldDeclarations[i];
> 					if (fieldDecl.isStatic()) {
> 						if (fieldDecl.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {
> 							fieldDecl.generateCode(staticInitializerScope, codeStream);
>-							enumCount++;
> 						} else {
> 							remainingFieldCount++;
> 						}
>@@ -228,20 +257,24 @@
> 			codeStream.fieldAccess(Opcodes.OPC_putstatic, declaringType.enumValuesSyntheticfield, null /* default declaringClass */);
> 			if (remainingFieldCount != 0) {
> 				// if fields that are not enum constants need to be generated (static initializer/static field)
>-				for (int i = 0, max = fieldDeclarations.length; i < max; i++) {
>+				for (int i = 0, max = fieldDeclarations.length; i < max && remainingFieldCount >= 0; i++) {
> 					FieldDeclaration fieldDecl = fieldDeclarations[i];
> 					switch (fieldDecl.getKind()) {
> 						case AbstractVariableDeclaration.ENUM_CONSTANT :
> 							break;
> 						case AbstractVariableDeclaration.INITIALIZER :
>-							if (!fieldDecl.isStatic())
>+							if (!fieldDecl.isStatic()) {
> 								break;
>+							}
>+							remainingFieldCount--;
> 							lastInitializerScope = ((Initializer) fieldDecl).block.scope;
> 							fieldDecl.generateCode(staticInitializerScope, codeStream);
> 							break;
> 						case AbstractVariableDeclaration.FIELD :
>-							if (!fieldDecl.binding.isStatic())
>+							if (!fieldDecl.binding.isStatic()) {
> 								break;
>+							}
>+							remainingFieldCount--;
> 							lastInitializerScope = null;
> 							fieldDecl.generateCode(staticInitializerScope, codeStream);
> 							break;
>Index: compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java,v
>retrieving revision 1.101
>diff -u -r1.101 FieldDeclaration.java
>--- compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java	1 Jul 2010 04:39:20 -0000	1.101
>+++ compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java	20 Dec 2010 00:49:12 -0000
>@@ -94,7 +94,7 @@
> 	int pc = codeStream.position;
> 	boolean isStatic;
> 	if (this.initialization != null
>-		&& !((isStatic = this.binding.isStatic()) && this.binding.constant() != Constant.NotAConstant)) {
>+			&& !((isStatic = this.binding.isStatic()) && this.binding.constant() != Constant.NotAConstant)) {
> 		// non-static field, need receiver
> 		if (!isStatic)
> 			codeStream.aload_0();
>Index: compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java,v
>retrieving revision 1.164
>diff -u -r1.164 TypeDeclaration.java
>--- compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java	21 Jun 2010 09:47:48 -0000	1.164
>+++ compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java	20 Dec 2010 00:49:13 -0000
>@@ -55,6 +55,7 @@
> 	public TypeDeclaration enclosingType; // for member types only
> 
> 	public FieldBinding enumValuesSyntheticfield; 	// for enum
>+	public int enumConstantsCounter;
> 
> 	// 1.5 support
> 	public TypeParameter[] typeParameters;
>Index: compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java,v
>retrieving revision 1.179
>diff -u -r1.179 CodeStream.java
>--- compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java	9 Nov 2010 19:59:19 -0000	1.179
>+++ compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java	20 Dec 2010 00:49:15 -0000
>@@ -15,10 +15,13 @@
> import org.eclipse.jdt.internal.compiler.CompilationResult;
> import org.eclipse.jdt.internal.compiler.ast.ASTNode;
> import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
>+import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
> import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
> import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;
> import org.eclipse.jdt.internal.compiler.ast.Expression;
>+import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
> import org.eclipse.jdt.internal.compiler.ast.OperatorIds;
>+import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
> import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
> import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo;
> import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
>@@ -2445,7 +2448,24 @@
> 	aload_2();
> 	areturn();
> }
>-
>+public void generateSyntheticBodyForEnumInitializationMethod(SyntheticMethodBinding methodBinding) {
>+	// no local used
>+	this.maxLocals = 0;
>+	// generate all enum constants
>+	SourceTypeBinding sourceTypeBinding = (SourceTypeBinding) methodBinding.declaringClass;
>+	TypeDeclaration typeDeclaration = sourceTypeBinding.scope.referenceContext;
>+	BlockScope staticInitializerScope = typeDeclaration.staticInitializerScope;
>+	FieldDeclaration[] fieldDeclarations = typeDeclaration.fields;
>+	for (int i = methodBinding.startIndex, max = methodBinding.endIndex; i < max; i++) {
>+		FieldDeclaration fieldDecl = fieldDeclarations[i];
>+		if (fieldDecl.isStatic()) {
>+			if (fieldDecl.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {
>+				fieldDecl.generateCode(staticInitializerScope, this);
>+			}
>+		}
>+	}
>+	return_();
>+}
> public void generateSyntheticBodyForFieldReadAccess(SyntheticMethodBinding accessMethod) {
> 	initializeMaxLocals(accessMethod);
> 	FieldBinding fieldBinding = accessMethod.targetReadField;
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java,v
>retrieving revision 1.183
>diff -u -r1.183 SourceTypeBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java	17 Dec 2010 06:40:13 -0000	1.183
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java	20 Dec 2010 00:49:15 -0000
>@@ -480,6 +480,18 @@
> 	}
> 	return accessMethod;
> }
>+public SyntheticMethodBinding addSyntheticMethodForEnumInitialization(int begin, int end) {
>+	if (this.synthetics == null)
>+		this.synthetics = new HashMap[MAX_SYNTHETICS];
>+	if (this.synthetics[SourceTypeBinding.METHOD_EMUL] == null)
>+		this.synthetics[SourceTypeBinding.METHOD_EMUL] = new HashMap(5);
>+
>+	SyntheticMethodBinding accessMethod = new SyntheticMethodBinding(this, begin, end);
>+	SyntheticMethodBinding[] accessors = new SyntheticMethodBinding[2]; 
>+	this.synthetics[SourceTypeBinding.METHOD_EMUL].put(accessMethod.selector, accessors);
>+	accessors[0] = accessMethod;
>+	return accessMethod;
>+}
> /* Add a new synthetic access method for access to <targetMethod>.
>  * Must distinguish access method used for super access from others (need to use invokespecial bytecode)
> 	Answer the new method or the existing method if one already existed.
>@@ -1500,7 +1512,6 @@
> public ReferenceBinding[] superInterfaces() {
> 	return this.superInterfaces;
> }
>-
> public SyntheticMethodBinding[] syntheticMethods() {
> 	if (this.synthetics == null 
> 			|| this.synthetics[SourceTypeBinding.METHOD_EMUL] == null 
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/SyntheticMethodBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SyntheticMethodBinding.java,v
>retrieving revision 1.26
>diff -u -r1.26 SyntheticMethodBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/SyntheticMethodBinding.java	7 Sep 2010 13:39:18 -0000	1.26
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/SyntheticMethodBinding.java	20 Dec 2010 00:49:16 -0000
>@@ -21,9 +21,13 @@
> 	public FieldBinding targetWriteField;		// write access to a field
> 	public MethodBinding targetMethod;			// method or constructor
> 	public TypeBinding targetEnumType; 			// enum type
>-
>+	
> 	public int purpose;
> 
>+	// fields used to generate enum constants when too many
>+	public int startIndex;
>+	public int endIndex;
>+
> 	public final static int FieldReadAccess = 1; 		// field read
> 	public final static int FieldWriteAccess = 2; 		// field write
> 	public final static int SuperFieldReadAccess = 3; // super field read
>@@ -35,6 +39,7 @@
> 	public final static int EnumValues = 9; // enum #values()
> 	public final static int EnumValueOf = 10; // enum #valueOf(String)
> 	public final static int SwitchTable = 11; // switch table method
>+	public final static int TooManyEnumsConstants = 12; // too many enum constants
> 
> 	public int sourceStart = 0; // start position of the matching declaration
> 	public int index; // used for sorting access methods in the class file
>@@ -265,6 +270,26 @@
> 		}
> 	}
> 	
>+	/**
>+	 * Construct enum special methods: values or valueOf methods
>+	 */
>+	public SyntheticMethodBinding(SourceTypeBinding declaringEnum, int startIndex, int endIndex) {
>+		this.declaringClass = declaringEnum;
>+		SyntheticMethodBinding[] knownAccessMethods = declaringEnum.syntheticMethods();
>+		this.index = knownAccessMethods == null ? 0 : knownAccessMethods.length;
>+		StringBuffer buffer = new StringBuffer();
>+		buffer.append(' ').append(TypeConstants.SYNTHETIC_ACCESS_METHOD_PREFIX).append(this.index);
>+		this.selector = String.valueOf(buffer).toCharArray(); 
>+		this.modifiers = ClassFileConstants.AccPrivate | ClassFileConstants.AccStatic;
>+		this.tagBits |= (TagBits.AnnotationResolved | TagBits.DeprecatedAnnotationResolved);
>+		this.purpose = SyntheticMethodBinding.TooManyEnumsConstants;
>+		this.thrownExceptions = Binding.NO_EXCEPTIONS;
>+		this.returnType = TypeBinding.VOID;
>+		this.parameters = Binding.NO_PARAMETERS;
>+		this.startIndex = startIndex;
>+		this.endIndex = endIndex;
>+	}
>+
> 	// Create a synthetic method that will simply call the super classes method.
> 	// Used when a public method is inherited from a non-public class into a public class.
> 	// See https://bugs.eclipse.org/bugs/show_bug.cgi?id=288658
>Index: compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java,v
>retrieving revision 1.421
>diff -u -r1.421 Parser.java
>--- compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java	27 Oct 2010 02:55:30 -0000	1.421
>+++ compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java	20 Dec 2010 00:49:19 -0000
>@@ -8277,92 +8277,93 @@
> protected void dispatchDeclarationIntoEnumDeclaration(int length) {
> 
> 	if (length == 0)
>-      return;
>-   int[] flag = new int[length + 1]; //plus one -- see <HERE>
>-   int size1 = 0, size2 = 0, size3 = 0;
>-   TypeDeclaration enumDeclaration = (TypeDeclaration) this.astStack[this.astPtr - length];
>-   boolean hasAbstractMethods = false;
>-   for (int i = length - 1; i >= 0; i--) {
>-      ASTNode astNode = this.astStack[this.astPtr--];
>-      if (astNode instanceof AbstractMethodDeclaration) {
>-         //methods and constructors have been regrouped into one single list
>-         flag[i] = 2;
>-         size2++;
>-		if (((AbstractMethodDeclaration) astNode).isAbstract()) {
>-			hasAbstractMethods = true;
>-		}
>-      } else if (astNode instanceof TypeDeclaration) {
>-         flag[i] = 3;
>-         size3++;
>-      } else if (astNode instanceof FieldDeclaration) {
>-         flag[i] = 1;
>-         size1++;
>-//         if(astNode instanceof EnumConstant) {
>-//            EnumConstant constant = (EnumConstant) astNode;
>-//            ((AllocationExpression)constant.initialization).type = new SingleTypeReference(enumDeclaration.name,
>-//                  (((long) enumDeclaration.sourceStart) << 32) + enumDeclaration.sourceEnd);
>-//         }
>-      }
>-   }
>-
>-   //arrays creation
>-   if (size1 != 0) {
>-      enumDeclaration.fields = new FieldDeclaration[size1];
>-   }
>-   if (size2 != 0) {
>-      enumDeclaration.methods = new AbstractMethodDeclaration[size2];
>-      if (hasAbstractMethods) enumDeclaration.bits |= ASTNode.HasAbstractMethods;
>-   }
>-   if (size3 != 0) {
>-      enumDeclaration.memberTypes = new TypeDeclaration[size3];
>-   }
>-
>-   //arrays fill up
>-   size1 = size2 = size3 = 0;
>-   int flagI = flag[0], start = 0;
>-   int length2;
>-   for (int end = 0; end <= length; end++) //<HERE> the plus one allows to
>-      {
>-      if (flagI != flag[end]) //treat the last element as a ended flag.....
>-         { //array copy
>-         switch (flagI) {
>-            case 1 :
>-               size1 += (length2 = end - start);
>-               System.arraycopy(
>-                  this.astStack,
>-                  this.astPtr + start + 1,
>-                  enumDeclaration.fields,
>-                  size1 - length2,
>-                  length2);
>-               break;
>-            case 2 :
>-               size2 += (length2 = end - start);
>-               System.arraycopy(
>-                  this.astStack,
>-                  this.astPtr + start + 1,
>-                  enumDeclaration.methods,
>-                  size2 - length2,
>-                  length2);
>-               break;
>-            case 3 :
>-               size3 += (length2 = end - start);
>-               System.arraycopy(
>-                  this.astStack,
>-                  this.astPtr + start + 1,
>-                  enumDeclaration.memberTypes,
>-                  size3 - length2,
>-                  length2);
>-               break;
>-         }
>-         flagI = flag[start = end];
>-      }
>-   }
>-
>-   if (enumDeclaration.memberTypes != null) {
>-      for (int i = enumDeclaration.memberTypes.length - 1; i >= 0; i--) {
>-         enumDeclaration.memberTypes[i].enclosingType = enumDeclaration;
>-      }
>-   }}
>+		return;
>+	int[] flag = new int[length + 1]; //plus one -- see <HERE>
>+	int size1 = 0, size2 = 0, size3 = 0;
>+	TypeDeclaration enumDeclaration = (TypeDeclaration) this.astStack[this.astPtr - length];
>+	boolean hasAbstractMethods = false;
>+	int enumConstantsCounter = 0;
>+	for (int i = length - 1; i >= 0; i--) {
>+		ASTNode astNode = this.astStack[this.astPtr--];
>+		if (astNode instanceof AbstractMethodDeclaration) {
>+			//methods and constructors have been regrouped into one single list
>+			flag[i] = 2;
>+			size2++;
>+			if (((AbstractMethodDeclaration) astNode).isAbstract()) {
>+				hasAbstractMethods = true;
>+			}
>+		} else if (astNode instanceof TypeDeclaration) {
>+			flag[i] = 3;
>+			size3++;
>+		} else if (astNode instanceof FieldDeclaration) {
>+			flag[i] = 1;
>+			size1++;
>+			if (((FieldDeclaration) astNode).getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {
>+				enumConstantsCounter++;
>+			}
>+		}
>+	}
>+
>+	//arrays creation
>+	if (size1 != 0) {
>+		enumDeclaration.fields = new FieldDeclaration[size1];
>+	}
>+	if (size2 != 0) {
>+		enumDeclaration.methods = new AbstractMethodDeclaration[size2];
>+		if (hasAbstractMethods) enumDeclaration.bits |= ASTNode.HasAbstractMethods;
>+	}
>+	if (size3 != 0) {
>+		enumDeclaration.memberTypes = new TypeDeclaration[size3];
>+	}
>+
>+	//arrays fill up
>+	size1 = size2 = size3 = 0;
>+	int flagI = flag[0], start = 0;
>+	int length2;
>+	for (int end = 0; end <= length; end++) //<HERE> the plus one allows to
>+	{
>+		if (flagI != flag[end]) //treat the last element as a ended flag.....
>+		{ //array copy
>+			switch (flagI) {
>+				case 1 :
>+					size1 += (length2 = end - start);
>+					System.arraycopy(
>+							this.astStack,
>+							this.astPtr + start + 1,
>+							enumDeclaration.fields,
>+							size1 - length2,
>+							length2);
>+					break;
>+				case 2 :
>+					size2 += (length2 = end - start);
>+					System.arraycopy(
>+							this.astStack,
>+							this.astPtr + start + 1,
>+							enumDeclaration.methods,
>+							size2 - length2,
>+							length2);
>+					break;
>+				case 3 :
>+					size3 += (length2 = end - start);
>+					System.arraycopy(
>+							this.astStack,
>+							this.astPtr + start + 1,
>+							enumDeclaration.memberTypes,
>+							size3 - length2,
>+							length2);
>+					break;
>+			}
>+			flagI = flag[start = end];
>+		}
>+	}
>+
>+	if (enumDeclaration.memberTypes != null) {
>+		for (int i = enumDeclaration.memberTypes.length - 1; i >= 0; i--) {
>+			enumDeclaration.memberTypes[i].enclosingType = enumDeclaration;
>+		}
>+	}
>+	enumDeclaration.enumConstantsCounter = enumConstantsCounter;
>+}
> protected CompilationUnitDeclaration endParse(int act) {
> 
> 	this.lastAct = act;

Actions: View | Diff

Attachments on bug 331334: 184033 | 185509 | 186117