diff --git a/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java b/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
index 73434c0..e052931 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
@@ -427,9 +427,8 @@
 		TypeBinding[] annotationTypes = new TypeBinding[length];
 		for (int i = 0; i < length; i++) {
 			Annotation annotation = annotations[i];
-			annotation.recipient = recipient;
-			annotation.compilerAnnotation = new SourceAnnotation(annotation);
-			annotationTypes[i] = annotation.resolveType(scope);
+			annotation.recipient = recipient;			
+			annotationTypes[i] = annotation.resolveType(scope);			
 		}
 		// check duplicate annotations
 		for (int i = 0; i < length; i++) {
diff --git a/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java b/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java
index a48d8fa..1053019 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java
@@ -19,14 +19,14 @@
  */
 public abstract class Annotation extends Expression {
 	
-	final static MemberValuePair[] NoValuePairs = new MemberValuePair[0];
+	final static MemberValuePair[] NoValuePairs = new MemberValuePair[0];	
 	public int declarationSourceEnd;
 	public Binding recipient;	
 	public TypeReference type;
 	/** 
 	 *  The representation of this annotation in the type system. 
 	 */
-	public SourceAnnotation compilerAnnotation;
+	private SourceAnnotation compilerAnnotation = null;
 	
 	public static long getRetentionPolicy(char[] policyName) {
 		if (policyName == null || policyName.length == 0)
@@ -166,15 +166,21 @@
 	
 	public TypeBinding resolveType(BlockScope scope) {
 		
+		if(this.compilerAnnotation != null)
+			return this.resolvedType;		
+		
 		this.constant = NotAConstant;
 		
 		TypeBinding typeBinding = this.type.resolveType(scope);
-		if (typeBinding == null)
+		if (typeBinding == null){	
+			this.compilerAnnotation = new SourceAnnotation(this);
 			return null;
+		}
 		this.resolvedType = typeBinding;
 		// ensure type refers to an annotation type
 		if (!typeBinding.isAnnotationType()) {
 			scope.problemReporter().typeMismatchError(typeBinding, scope.getJavaLangAnnotationAnnotation(), this.type);
+			this.compilerAnnotation = new SourceAnnotation(this);
 			return null;
 		}
 
@@ -226,7 +232,8 @@
 			if (!foundValue && (method.modifiers & AccAnnotationDefault) == 0) {
 				scope.problemReporter().missingValueForAnnotationMember(this, selector);
 			}
-		}
+		}		
+		
 		// check unused pairs
 		for (int i = 0; i < pairsLength; i++) {
 			if (pairs[i] != null) {
@@ -299,8 +306,14 @@
 				scope.problemReporter().disallowedTargetForAnnotation(this);
 			}
 		}
+		this.compilerAnnotation = new SourceAnnotation(this);
 		return this.resolvedType;
 	}	
+	
+	public SourceAnnotation getCompilerAnnotation()
+	{	
+		return this.compilerAnnotation;
+	}
 		
 	public abstract void traverse(ASTVisitor visitor, BlockScope scope);
 	public abstract void traverse(ASTVisitor visitor, CompilationUnitScope scope);
diff --git a/compiler/org/eclipse/jdt/internal/compiler/ast/CompilationUnitDeclaration.java b/compiler/org/eclipse/jdt/internal/compiler/ast/CompilationUnitDeclaration.java
index 363754d..9df5ca3 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/ast/CompilationUnitDeclaration.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/ast/CompilationUnitDeclaration.java
@@ -119,6 +119,7 @@
 			}
 		}
 		if (type.binding != null) {
+			type.binding.finish();
 			// null out the type's scope backpointers
 			type.binding.scope = null;
 		}
diff --git a/compiler/org/eclipse/jdt/internal/compiler/classfmt/AnnotationInfo.java b/compiler/org/eclipse/jdt/internal/compiler/classfmt/AnnotationInfo.java
index 4a4ac3d..4b2430e 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/classfmt/AnnotationInfo.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/classfmt/AnnotationInfo.java
@@ -81,6 +81,10 @@
 	 * of this annotation. The data structure will not be flushed out.
 	 * 
 	 * The tag bits are derived from the following (supported) standard annotation. 
+	 * java.lang.annotation.Documented,
+	 * java.lang.annotation.Retention,
+	 * java.lang.annotation.Target, and
+	 * java.lang.Deprecated
 	 * 
 	 * @param expectRuntimeVisibleAnno <code>true</cod> to indicate that this is a runtime-visible annotation
 	 * @param toplevel <code>false</code> to indicate that an nested annotation is read. <code>true</code>
diff --git a/compiler/org/eclipse/jdt/internal/compiler/classfmt/ClassFileReader.java b/compiler/org/eclipse/jdt/internal/compiler/classfmt/ClassFileReader.java
index aa6e090..a28a9d4 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/classfmt/ClassFileReader.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/classfmt/ClassFileReader.java
@@ -323,27 +323,54 @@
  */
 private void decodeAnnotations(int offset, boolean runtimeVisible) {
 	int numberOfAnnotations = u2At(offset + 6);
-	int readOffset = offset + 8;
-	int index = 0;
-	if( numberOfAnnotations > 0 ){		
-		if( this.annotations == null )
-			this.annotations = new AnnotationInfo[numberOfAnnotations];
-		else{
-			index = this.annotations.length;
-			int newTotal = this.annotations.length + numberOfAnnotations;
-			final AnnotationInfo[] newAnnos = new AnnotationInfo[newTotal];
-			System.arraycopy(this.annotations, 0, newAnnos, 0, this.annotations.length);
-			this.annotations = newAnnos;
+	int readOffset = offset + 8;	
+	
+	if( numberOfAnnotations >  0 ){
+		int numStandardAnnotations = 0;
+		AnnotationInfo[] annos = new AnnotationInfo[numberOfAnnotations];
+		for( int i=0; i<numberOfAnnotations; i++ ){
+			// With the last parameter being 'false', the data structure 
+			// will not be flushed out. 
+			annos[i] = new AnnotationInfo( reference, readOffset, 
+										   this.constantPoolOffsets,
+										   runtimeVisible, false );
+			readOffset = annos[i].getLength() + readOffset;
+			final long standardTagBits = annos[i].getStandardAnnotationTagBits();
+			this.tagBits |= standardTagBits;
+			// annotation that can be represented by the tag bits
+			// will drop the data structure completely for memory sake.
+			if( standardTagBits != 0 ){	
+				annos[i] = null;
+				numStandardAnnotations ++;
+			}
 		}
+		
+		if( numStandardAnnotations != 0 ){ 	
+			if( numStandardAnnotations == numberOfAnnotations )
+				return;
+			
+			// need to resize
+			AnnotationInfo[] temp = new AnnotationInfo[numberOfAnnotations - numStandardAnnotations ];
+			int tmpIndex = 0;
+			for( int i=0; i<numberOfAnnotations; i++ ){
+				if( annos[i] != null )
+					temp[tmpIndex ++] = annos[i];
+			}
+			annos = temp;
+			numberOfAnnotations = numberOfAnnotations - numStandardAnnotations;
+		}		
+		
+		if( this.annotations == null )
+			this.annotations = annos;
+		else{	
+			
+			final int newTotal = this.annotations.length + numberOfAnnotations;
+			final AnnotationInfo[] newAnnos = new AnnotationInfo[newTotal];
+			System.arraycopy(this.annotations, 0, newAnnos, 0, this.annotations.length );
+			System.arraycopy(annos, 0, newAnnos, this.annotations.length, numberOfAnnotations);
+			this.annotations = newAnnos;
+		}		
 	}	
-	for (int i = 0; i < numberOfAnnotations; i++, index++) {
-		this.annotations[index] = new AnnotationInfo(reference, 
-											    	 readOffset, 
-													 this.constantPoolOffsets, 
-													 runtimeVisible, false);
-		readOffset = this.annotations[index].getLength() + readOffset;		
-		this.tagBits |= this.annotations[index].getStandardAnnotationTagBits();		
-	}
 }
 /**
  * Answer the char array that corresponds to the class name of the constant class.
diff --git a/compiler/org/eclipse/jdt/internal/compiler/classfmt/FieldInfo.java b/compiler/org/eclipse/jdt/internal/compiler/classfmt/FieldInfo.java
index da3a2e5..d6e08d8 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/classfmt/FieldInfo.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/classfmt/FieldInfo.java
@@ -88,35 +88,55 @@
  * annotation attribute.
  */
 private void decodeAnnotations(int offset, boolean runtimeVisible) {
-/*
-int actualOffset = offset + structOffset;
-String text = runtimeVisible ?  " runtime visible " : " runtime invisible ";
-System.err.println("decoding field_info" + text + "annotation at " + actualOffset);
-*/
 	int numberOfAnnotations = u2At(offset + 6);
-	int readOffset = offset + 8;
-	int index=0;
+	int readOffset = offset + 8;	
 	if( numberOfAnnotations > 0 ){		
+		int numStandardAnnotations = 0;
+		AnnotationInfo[] annos = new AnnotationInfo[numberOfAnnotations];
+		for (int i = 0; i < numberOfAnnotations; i++) {		
+			annos[i] = new AnnotationInfo(reference, 
+								          readOffset + structOffset, 
+										  this.constantPoolOffsets, 
+										  runtimeVisible, 
+										  false);
+			readOffset = annos[i].getLength() + readOffset;		
+			final long stdAnnotationTagBits = 
+				annos[i].getStandardAnnotationTagBits();
+			this.tagBits |= stdAnnotationTagBits;
+			// the tag bits represents the annotation, don't need a separate 
+			// data structure for that.
+			if(stdAnnotationTagBits != 0){
+				annos[i] = null;
+				numStandardAnnotations ++;
+			}
+		}
+		if( numStandardAnnotations != 0 ){ 
+			// all of them are standard annotations
+			if( numStandardAnnotations == numberOfAnnotations )
+				return;
+			else{ // need to resize	
+				AnnotationInfo[] temp = new AnnotationInfo[numberOfAnnotations - numStandardAnnotations ];
+				int tmpIndex = 0;
+				for( int i=0; i<numberOfAnnotations; i++ ){
+					if( annos[i] != null )
+						temp[tmpIndex ++] = annos[i];
+				}
+				annos = temp;
+				numberOfAnnotations = numberOfAnnotations - numStandardAnnotations;
+			}
+		}	
 		if( this.annotations == null )
-			this.annotations = new AnnotationInfo[numberOfAnnotations];
+			this.annotations = annos;
 		else{
-			int curlen = this.annotations.length;
-			index = curlen;
+			int curlen = this.annotations.length;			
 			int newTotal = curlen + numberOfAnnotations;
 			final AnnotationInfo[] newAnnos = new AnnotationInfo[newTotal];
 			System.arraycopy(this.annotations, 0, newAnnos, 0, curlen);
+			System.arraycopy(annos, 0, newAnnos, curlen, numberOfAnnotations);
 			this.annotations = newAnnos;
 		}
 	}	
-	for (int i = 0; i < numberOfAnnotations; i++, index++) {		
-		this.annotations[index] = new AnnotationInfo(reference, 
-											           readOffset + structOffset, 
-													   this.constantPoolOffsets, 
-													   runtimeVisible, 
-													   false);
-		readOffset = this.annotations[index].getLength() + readOffset;		
-		this.tagBits |= this.annotations[index].getStandardAnnotationTagBits();
-	}
+	
 }
 /**
  * Return the constant of the field.
diff --git a/compiler/org/eclipse/jdt/internal/compiler/classfmt/MethodInfo.java b/compiler/org/eclipse/jdt/internal/compiler/classfmt/MethodInfo.java
index 22a57bf..01ba4c3 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/classfmt/MethodInfo.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/classfmt/MethodInfo.java
@@ -150,12 +150,33 @@
  */
 private void decodeMethodAnnotations(int offset, boolean runtimeVisible){
 	int numberOfAnnotations = u2At(offset + 6);
-	final AnnotationInfo[] annos = decodeAnnotations(offset + 8, runtimeVisible, numberOfAnnotations);
+	AnnotationInfo[] annos = decodeAnnotations(offset + 8, runtimeVisible, numberOfAnnotations);
 	
 	if( numberOfAnnotations > 0 ){
 		if( runtimeVisible ){
+			int numStandardAnnotations = 0;			
 			for( int i=0; i<numberOfAnnotations; i++ ){
-				this.tagBits |= annos[i].getStandardAnnotationTagBits();
+				final long standardAnnoTagBits = annos[i].getStandardAnnotationTagBits();
+				this.tagBits |= standardAnnoTagBits;
+				if(standardAnnoTagBits != 0){
+					annos[i] = null;
+					numStandardAnnotations ++;
+				}
+			}
+			
+			if( numStandardAnnotations != 0 ){
+				if( numStandardAnnotations == numberOfAnnotations )
+					return;
+				
+				// need to resize			
+				AnnotationInfo[] temp = new AnnotationInfo[numberOfAnnotations - numStandardAnnotations ];
+				int tmpIndex = 0;
+				for( int i=0; i<numberOfAnnotations; i++ ){
+					if( annos[i] != null )
+						temp[tmpIndex ++] = annos[i];
+				}
+				annos = temp;
+				numberOfAnnotations = numberOfAnnotations - numStandardAnnotations;				
 			}
 		}
 		
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationMethodBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationMethodBinding.java
index baf203b..33d1eaa 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationMethodBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationMethodBinding.java
@@ -10,30 +10,52 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.lookup;
 
+import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
+
 /**
- * Annotation method that came from binary.
+ * Annotation method that came from binary or source
  * @author tyeung
  *
  */
-public class AnnotationMethodBinding extends BinaryMethodBinding 
+public class AnnotationMethodBinding extends MethodBinding 
 {
-	private Object defaultValue;
+	private Object defaultValue = null;
+	/**
+	 * 
+	 * @param modifiers
+	 * @param selector
+	 * @param returnType
+	 * @param declaringClass	
+	 * @param defaultValue <code>null</code> for source method. 
+	 */
 	public AnnotationMethodBinding(int modifiers,
 								   char[] selector, 
 								   TypeBinding returnType, 
-								   ReferenceBinding declaringClass,
-								   IAnnotationInstance[] methodAnnotation,
-								   IAnnotationInstance[][] parameterAnnotations,
+								   ReferenceBinding declaringClass,								  
 								   Object defaultValue)
 	{
-		super(modifiers, selector, 
-			 returnType, NoParameters, 
-			 NoExceptions, declaringClass,
-			 methodAnnotation, parameterAnnotations );
-		
+		super(modifiers, selector, returnType, NoParameters, NoExceptions, declaringClass );
 		this.defaultValue = defaultValue;
+		setDefaultValue();	
 	}
 	
+	private void setDefaultValue()
+	{			
+		if (this.declaringClass instanceof SourceTypeBinding) {
+			TypeDeclaration typeDecl = ((SourceTypeBinding)this.declaringClass).scope.referenceContext;
+			final AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(this);
+			if( methodDecl instanceof AnnotationMethodDeclaration){
+				this.defaultValue = SourceElementValuePair.getValue(((AnnotationMethodDeclaration)methodDecl).defaultValue);
+			}
+		}
+	}
+	
+	/**
+	 * @return the default value for this annotation method.
+	 *         Return <code>null</code> if there is no default value 
+	 */
 	public Object getDefaultValue()
 	{
 		return this.defaultValue;
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationUtils.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationUtils.java
new file mode 100644
index 0000000..e645e8b
--- /dev/null
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationUtils.java
@@ -0,0 +1,138 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    tyeung@bea.com - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.compiler.lookup;
+
+class AnnotationUtils {
+	/**
+	 * Build out the data structure representing the standard annotations.
+	 * @param annotationTagBits 
+	 * @param result to be filled by this method starting from index 0
+	 * @param env
+	 * @return the number of standard annotations found 
+	 */
+	static int buildStandardAnnotations(final long annotationTagBits, 
+										final IAnnotationInstance[] result,
+										final LookupEnvironment env)
+	{
+		int index = 0;
+		if( (annotationTagBits & TagBits.AnnotationTargetMASK) != 0 )
+			result[index++] = buildTargetAnnotation(annotationTagBits, env);
+		if( (annotationTagBits & TagBits.AnnotationRetentionMASK) != 0 ) 
+			result[index++] = buildRetentionAnnotation(annotationTagBits, env);
+		if( (annotationTagBits & TagBits.AnnotationDeprecated) != 0 )
+			result[index++] = buildMarkerAnnotation(TypeConstants.CharArray_JAVA_LANG_DEPRECATED_SIG, env);
+		if( (annotationTagBits & TagBits.AnnotationDocumented) != 0 )
+			result[index++] = buildMarkerAnnotation(TypeConstants.CharArray_JAVA_LANG_ANNOTATION_DOCUMENTED_SIG, env);
+		if( (annotationTagBits & TagBits.AnnotationInherited) != 0 )
+			result[index++] = buildMarkerAnnotation(TypeConstants.CharArray_JAVA_LANG_ANNOTATION_INHERITED_SIG, env);
+		if( (annotationTagBits & TagBits.AnnotationOverride) != 0 )
+			result[index++] = buildMarkerAnnotation(TypeConstants.CharArray_JAVA_LANG_OVERRIDE_SIG, env);
+		if( (annotationTagBits & TagBits.AnnotationSuppressWarnings) != 0 )
+			result[index++] = buildMarkerAnnotation(TypeConstants.CharArray_JAVA_LANG_SUPRESSWARNING_SIG, env);
+		return index;
+	}
+
+	static int getNumberOfStandardAnnotations(final long annotationTagBits)
+	{	
+		int count = 0;
+		if( (annotationTagBits & TagBits.AnnotationTargetMASK) != 0 ) count ++;		
+		if( (annotationTagBits & TagBits.AnnotationRetentionMASK) != 0 ) count ++;
+		if( (annotationTagBits & TagBits.AnnotationDeprecated) != 0 ) count ++;
+		if( (annotationTagBits & TagBits.AnnotationDocumented) != 0 ) count ++;
+		if( (annotationTagBits & TagBits.AnnotationInherited) != 0 ) count ++;
+		if( (annotationTagBits & TagBits.AnnotationOverride) != 0 ) count ++;
+		if( (annotationTagBits & TagBits.AnnotationSuppressWarnings) != 0 ) count ++;
+		
+		return count;	
+	}
+
+	private static IAnnotationInstance buildMarkerAnnotation(final char[] sig, final LookupEnvironment env)
+	{
+		final ReferenceBinding type = (ReferenceBinding)env.getTypeFromSignature(sig, 0, -1, false, null);
+		return new BinaryAnnotation(type, env);
+	}
+
+	private static IAnnotationInstance buildTargetAnnotation(final long bits, final LookupEnvironment env)
+	{	
+		final ReferenceBinding target = (ReferenceBinding)
+			env.getTypeFromSignature(TypeConstants.CharArray_JAVA_LANG_ANNOTATION_TARGET_SIG, 
+									 0, -1, false, null);
+		final BinaryAnnotation anno = new BinaryAnnotation(target, env);
+		if( (bits & TagBits.AnnotationTarget) != 0 )
+			return anno;
+		
+		ReferenceBinding elementType = (ReferenceBinding)
+			env.getTypeFromSignature(TypeConstants.CharArray_JAVA_LANG_ANNOTATION_ELEMENTTYPE_SIG, 
+					  							  0, -1, false, null);
+		int arraysize = 0;
+		if( (bits & TagBits.AnnotationForAnnotationType) != 0 ) arraysize ++;
+		if( (bits & TagBits.AnnotationForConstructor) != 0 ) arraysize ++;
+		if( (bits & TagBits.AnnotationForField) != 0 ) arraysize ++;
+		if( (bits & TagBits.AnnotationForLocalVariable) != 0 ) arraysize ++;
+		if( (bits & TagBits.AnnotationForMethod) != 0 ) arraysize ++;
+		if( (bits & TagBits.AnnotationForPackage) != 0 ) arraysize ++;
+		if( (bits & TagBits.AnnotationForParameter) != 0 ) arraysize ++;
+		if( (bits & TagBits.AnnotationForType) != 0 ) arraysize ++;
+		
+		final Object[] value = new Object[arraysize];
+		if( arraysize > 0 ){
+			elementType = BinaryTypeBinding.resolveType(elementType, env, false);
+			int index = 0;
+			if( (bits & TagBits.AnnotationForAnnotationType) != 0 ) 
+				value[index++] = elementType.getField(TypeConstants.UPPER_ANNOTATION_TYPE, true);
+			if( (bits & TagBits.AnnotationForConstructor) != 0 ) 
+				value[index++] = elementType.getField(TypeConstants.UPPER_CONSTRUCTOR, true);
+			if( (bits & TagBits.AnnotationForField) != 0 ) 
+				value[index++] = elementType.getField(TypeConstants.UPPER_FIELD, true);
+			if( (bits & TagBits.AnnotationForLocalVariable) != 0 ) 
+				value[index++] = elementType.getField(TypeConstants.UPPER_LOCAL_VARIABLE, true);
+			if( (bits & TagBits.AnnotationForMethod) != 0 ) 
+				value[index++] = elementType.getField(TypeConstants.UPPER_METHOD, true);
+			if( (bits & TagBits.AnnotationForPackage) != 0 )
+				value[index++] = elementType.getField(TypeConstants.UPPER_PACKAGE, true);
+			if( (bits & TagBits.AnnotationForParameter) != 0 ) 
+				value[index++] = elementType.getField(TypeConstants.UPPER_PARAMETER, true);
+			if( (bits & TagBits.AnnotationForType) != 0 ) 
+				value[index++] = elementType.getField(TypeConstants.TYPE, true);
+		}
+		
+		anno.pairs = new IElementValuePair[]{ new BinaryElementValuePair(anno, TypeConstants.VALUE, value) };
+		return anno;
+	}
+
+	private static IAnnotationInstance buildRetentionAnnotation(final long bits, final LookupEnvironment env)
+	{
+		final ReferenceBinding retention = (ReferenceBinding)
+		env.getTypeFromSignature(TypeConstants.CharArray_JAVA_LANG_ANNOTATION_RETENTION_SIG, 
+											  0, -1, false, null);
+		ReferenceBinding retentionPolicy = (ReferenceBinding)
+			env.getTypeFromSignature(TypeConstants.CharArray_JAVA_LANG_ANNOTATION_RETENTIONPOLICY_SIG, 
+					  							  0, -1, false, null);
+
+		final BinaryAnnotation anno = new BinaryAnnotation(retention, env);
+		
+		Object value = null; 	
+		{
+			retentionPolicy = BinaryTypeBinding.resolveType(retentionPolicy, env, false);		
+			if( (bits & TagBits.AnnotationRuntimeRetention) != 0 ) 
+				value = retentionPolicy.getField(TypeConstants.UPPER_RUNTIME, true);		
+			else if( (bits & TagBits.AnnotationClassRetention) != 0 ) 
+				value = retentionPolicy.getField(TypeConstants.UPPER_CLASS, true);
+			else if( (bits & TagBits.AnnotationSourceRetention) != 0 ) 
+				value = retentionPolicy.getField(TypeConstants.UPPER_SOURCE, true);
+			
+		}
+		anno.pairs = new IElementValuePair[]{ new BinaryElementValuePair(anno, TypeConstants.VALUE, value) };
+		return anno;
+
+	}
+
+}
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryAnnotation.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryAnnotation.java
index 067bdda..c5e8fd2 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryAnnotation.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryAnnotation.java
@@ -24,7 +24,7 @@
 	BinaryAnnotation(ReferenceBinding binding, LookupEnvironment env)
 	{ 
 		this.typeBinding = binding;
-		this.pairs = null;
+		this.pairs = TypeConstants.NoElementValuePairs;
 		this.env = env;		
 	}
 	
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
index e8a684f..615a923 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
@@ -47,10 +47,9 @@
 private MethodBinding[] methods;
 private ReferenceBinding[] memberTypes;
 protected TypeVariableBinding[] typeVariables;
-private IAnnotationInstance[] annotations;
 
 // For the link with the principle structure
-private LookupEnvironment environment;
+LookupEnvironment environment;
 
 public static ReferenceBinding resolveType(ReferenceBinding type, LookupEnvironment environment, boolean convertGenericToRawType) {
 	if (type instanceof UnresolvedReferenceBinding)
@@ -179,8 +178,6 @@
 	return availableMethods;
 }
 
-public IAnnotationInstance[] getAnnotations(){ return this.annotations; }
-
 void cachePartsFrom(IBinaryType binaryType, boolean needFieldsAndMethods) {
 	// default initialization for super-interfaces early, in case some aborting compilation error occurs,
 	// and still want to use binaries passed that point (e.g. type hierarchy resolver, see bug 63748).
@@ -308,7 +305,7 @@
 {	
 	final int len = pairs == null ? 0 : pairs.length; 
 	anno.pairs = NoElementValuePairs;
-	if( len > 1 ){
+	if( len > 0 ){
 		anno.pairs = new IElementValuePair[len]; 
 		for( int i = 0; i < len; i++ ){
 			anno.pairs[i] = new BinaryElementValuePair(anno, 
@@ -331,7 +328,8 @@
 	
 	else if( binaryValue instanceof IEnumConstantReference ){
 		final IEnumConstantReference ref = (IEnumConstantReference)binaryValue;
-		final ReferenceBinding enumType = environment.getTypeFromConstantPoolName(ref.getTypeName(), 0, -1, false);
+		ReferenceBinding enumType = (ReferenceBinding)environment.getTypeFromSignature(ref.getTypeName(), 0, -1, false, null);
+		enumType = BinaryTypeBinding.resolveType(enumType, this.environment, false);
 		return enumType.getField(ref.getEnumConstantName(), false);
 	}
 	else if( binaryValue instanceof Object[] ){
@@ -367,13 +365,9 @@
 					: environment.getTypeFromTypeSignature(new SignatureWrapper(fieldSignature), NoTypeVariables, this);
 				IAnnotationInstance[] fieldAnnos = createAnnotations(binaryField.getAnnotations());
 				FieldBinding field = 
-					new BinaryFieldBinding(
-						binaryField.getName(), 
-						type, 
-						binaryField.getModifiers() | AccUnresolved, 
-						this, 
-						binaryField.getConstant(),
-						fieldAnnos);
+					new FieldBinding( binaryField.getName(), type, binaryField.getModifiers() | AccUnresolved, 
+						  			  this, binaryField.getConstant() );				
+				field.setAnnotations(fieldAnnos);
 				field.id = i; // ordinal
 				if (use15specifics)
 					field.tagBits |= binaryField.getTagBits();
@@ -503,31 +497,18 @@
 	
 	final MethodBinding result;
 	if( method.isConstructor() )
-		result = new BinaryMethodBinding(methodModifiers, 
-				 						 parameters, 
-										 exceptions, 
-										 this, 
-										 methodAnnos,
-										 paramAnnotations);
+		result = new MethodBinding(methodModifiers, parameters, exceptions, this); 
+		
 	else{
-		if( isAnnotationType() ){			
-			result = new AnnotationMethodBinding(methodModifiers, 
-												 method.getSelector(), 
-												 returnType,
-												 this,
-												 methodAnnos,
-												 paramAnnotations,
-												 getMemberValue(method.getDefaultValue()));
+		if( isAnnotationType() ){	
+			if( method instanceof org.eclipse.jdt.internal.compiler.classfmt.MethodInfo )
+				result = new AnnotationMethodBinding(methodModifiers, method.getSelector(), returnType, this, getMemberValue(method.getDefaultValue()));
+			else
+				throw new IllegalStateException(method.getClass().getName());
 		}
-		else result = new BinaryMethodBinding(methodModifiers, 
-											  method.getSelector(), 
-											  returnType, 
-											  parameters, 
-											  exceptions, 
-											  this,
-											  methodAnnos,
-											  paramAnnotations); 
+		else result = new MethodBinding(methodModifiers, method.getSelector(), returnType, parameters, exceptions, this);
 	}
+	result.setExtendedModifiers(methodAnnos, paramAnnotations);
 	
 	if (use15specifics)
 		result.tagBits |= method.getTagBits();
@@ -918,6 +899,24 @@
 	this.tagBits &= ~HasUnresolvedTypeVariables;
 	return this.typeVariables;
 }
+
+public IAnnotationInstance[] getAnnotations()
+{	
+	final long annotationTagBits = getAnnotationTagBits();
+	// TODO: add a flag so we don't repeat this process.
+	final int numStdAnnotations = AnnotationUtils.getNumberOfStandardAnnotations(annotationTagBits);
+	if( numStdAnnotations == 0 ) return this.annotations;	
+	
+	final int nonStandard = this.annotations == null ? 0 : this.annotations.length;
+	final int total = numStdAnnotations + nonStandard;
+	final IAnnotationInstance[] result = new BinaryAnnotation[total];
+	final int index = AnnotationUtils.buildStandardAnnotations(annotationTagBits, result, this.environment);
+	if( nonStandard != 0 ){
+		System.arraycopy(this.annotations, 0, result, index, this.annotations.length);
+	}
+	return result;
+}
+
 public String toString() {
 	String s = ""; //$NON-NLS-1$
 
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java
index 258654e..a34180c 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java
@@ -24,20 +24,27 @@
 	super(null, null, 0, null);
 	// for creating problem field
 }
-public FieldBinding(char[] name, TypeBinding type, int modifiers, ReferenceBinding declaringClass, Constant constant) {
+
+public FieldBinding(char[] name, TypeBinding type, int modifiers, ReferenceBinding declaringClass, Constant constant)
+{
 	super(name, type, modifiers, constant);
 	this.declaringClass = declaringClass;
 }
+
 public FieldBinding(FieldDeclaration field, TypeBinding type, int modifiers, ReferenceBinding declaringClass) {
 	this(field.name, type, modifiers, declaringClass, null);
 	field.binding = this; // record binding in declaration
 }
+
 // special API used to change field declaring class for runtime visibility check
 public FieldBinding(FieldBinding initialFieldBinding, ReferenceBinding declaringClass) {
-	super(initialFieldBinding.name, initialFieldBinding.type, initialFieldBinding.modifiers, initialFieldBinding.constant());
+	super(initialFieldBinding.name, initialFieldBinding.type, initialFieldBinding.modifiers, 
+		  initialFieldBinding.constant());
 	this.declaringClass = declaringClass;
 	this.id = initialFieldBinding.id;
+	this.annotations = initialFieldBinding.annotations;
 }
+
 /* API
 * Answer the receiver's binding type from Binding.BindingID.
 */
@@ -188,11 +195,78 @@
 		TypeDeclaration typeDecl = ((SourceTypeBinding)originalField.declaringClass).scope.referenceContext;
 		FieldDeclaration fieldDecl = typeDecl.declarationOf(originalField);
 		if (fieldDecl != null)
-			ASTNode.resolveAnnotations(isStatic() ? typeDecl.staticInitializerScope : typeDecl.initializerScope, fieldDecl.annotations, originalField);
+			ASTNode.resolveAnnotations(isStatic() ? typeDecl.staticInitializerScope : typeDecl.initializerScope, fieldDecl.annotations, originalField);		
 	}
 	return originalField.tagBits;
 }
 
+private boolean isBinary()
+{
+	return this.declaringClass != null && this.declaringClass.isBinaryBinding();
+}
+
+public IAnnotationInstance[] getAnnotations()
+{
+	if(this.annotations == null )
+		buildAnnotations();
+	// binary annotations can be encoded in tag bits.
+	if( isBinary() ){
+		final int current = this.annotations.length;		
+		final long annotationTagBits = getAnnotationTagBits();
+		final int numStandardAnnos = AnnotationUtils.getNumberOfStandardAnnotations(annotationTagBits);		
+		if( numStandardAnnos == 0 )
+			return this.annotations;
+		else{
+			final LookupEnvironment env = ((BinaryTypeBinding)this.declaringClass).environment;
+			final int total = current + numStandardAnnos;
+			final BinaryAnnotation[] result = new BinaryAnnotation[total];
+			final int index = AnnotationUtils.buildStandardAnnotations(annotationTagBits, result, env);
+			if( current == 0 )
+				return result;
+			else{
+				System.arraycopy(this.annotations, 0, result, index, current);
+				return result;
+			}
+		}
+	}
+	else
+		return this.annotations;
+}
+
+void buildAnnotations()
+{
+	if( this.annotations != null ) return;
+	this.annotations = NoAnnotations;
+	FieldBinding originalField = this.original();
+	// length field of an array don't have a declaring class.
+	if( originalField.declaringClass != null && originalField.declaringClass instanceof SourceTypeBinding){				
+		TypeDeclaration typeDecl = ((SourceTypeBinding)originalField.declaringClass).scope.referenceContext;
+		FieldDeclaration fieldDecl = typeDecl.declarationOf(originalField);
+		
+		if (fieldDecl != null){
+			final Annotation[] fieldAnnos = fieldDecl.annotations;
+			final int len = fieldAnnos == null ? 0 : fieldAnnos.length;
+			if( len > 0 )
+			{
+				this.annotations = new IAnnotationInstance[len];
+				for( int i = 0; i < len; i++ ){
+					final BlockScope scope = isStatic() ? typeDecl.staticInitializerScope : typeDecl.initializerScope;
+					fieldAnnos[i].resolveType(scope);
+					this.annotations[i] = fieldAnnos[i].getCompilerAnnotation();
+				}
+			}
+		}
+	}	
+}
+
+protected void setAnnotations(final IAnnotationInstance[] annos )
+{
+	if( annos == null )
+		this.annotations = NoAnnotations;
+	else
+		this.annotations = annos;
+}
+	
 /* Answer true if the receiver has default visibility
 */
 
@@ -281,28 +355,4 @@
 	}
 	return null;		
 }
-
-public IAnnotationInstance[] getAnnotations() { 	
-	// make sure we check the annotations for problems
-	getAnnotationTagBits();				
-	IAnnotationInstance[] result = NoAnnotations;
-	// length field of an array don't have a declaring class.
-	if( this.declaringClass != null && !this.declaringClass.isBinaryBinding() ){				
-		TypeDeclaration typeDecl = ((SourceTypeBinding)this.declaringClass).scope.referenceContext;
-		FieldDeclaration fieldDecl = typeDecl.declarationOf(this);
-		
-		if (fieldDecl != null){
-			final Annotation[] fieldAnnos = fieldDecl.annotations;
-			final int len = fieldAnnos == null ? 0 : fieldAnnos.length;
-			if( len > 0 )
-			{
-				result = new IAnnotationInstance[len];
-				for( int i = 0; i < len; i++ ){
-					result[i] = fieldAnnos[i].compilerAnnotation;
-				}
-			}
-		}
-	}
-	return result;
-}
 }
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/LocalVariableBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/LocalVariableBinding.java
index 1fa40ad..a9c0105 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/LocalVariableBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/LocalVariableBinding.java
@@ -40,6 +40,7 @@
 	public LocalVariableBinding(char[] name, TypeBinding type, int modifiers, boolean isArgument) {
 		super(name, type, modifiers, isArgument ? Constant.NotAConstant : null);
 		this.isArgument = isArgument;
+		this.annotations = null;
 	}
 	
 	// regular local variable or argument
@@ -47,6 +48,7 @@
 
 		this(declaration.name, type, modifiers, isArgument);
 		this.declaration = declaration;
+		this.annotations = null;
 	}
 
 	/* API
@@ -132,21 +134,29 @@
 	}
 	
 	public IAnnotationInstance[] getAnnotations()
-	{		
+	{
+		if(this.annotations != null) 
+			return this.annotations;
+		buildAnnotations();
+		return this.annotations;
+	}
+	
+	private void buildAnnotations()
+	{
+		this.annotations = NoAnnotations;
 		if( this.isArgument && this.declaration != null){
 			final Annotation[] argAnnos = declaration.annotations;
 			final int numAnnotations = argAnnos == null ? 0 : argAnnos.length;
-			IAnnotationInstance[] result = NoAnnotations;
+			
 			if( numAnnotations > 0 ){
-				result = new SourceAnnotation[numAnnotations];
+				this.annotations = new SourceAnnotation[numAnnotations];
 				// check for errors
 				ASTNode.resolveAnnotations(declaringScope, argAnnos, this);
 				for( int j=0; j<numAnnotations; j++ ){
-					result[j] = new SourceAnnotation(argAnnos[j]);
+					this.annotations[j] = new SourceAnnotation(argAnnos[j]);
 				}
 			}		
 		}
-		return null;
 	}
 
 	public String toString() {
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
index aa1d252..e4ea865 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
@@ -14,20 +14,38 @@
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Annotation;
-import org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Argument;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
 import org.eclipse.jdt.internal.compiler.codegen.ConstantPool;
 
-public class MethodBinding extends Binding implements BaseTypes, TypeConstants {
-	
+public class MethodBinding extends Binding implements BaseTypes, TypeConstants 
+{		
+	protected static final IAnnotationInstance[][] NoAnnotationsAtAll = new IAnnotationInstance[0][0];
 	public int modifiers;
 	public char[] selector;
 	public TypeBinding returnType;
 	public TypeBinding[] parameters;
 	public ReferenceBinding[] thrownExceptions;
 	public ReferenceBinding declaringClass;
-	public TypeVariableBinding[] typeVariables = NoTypeVariables;
+	public TypeVariableBinding[] typeVariables = NoTypeVariables;	
+	
+	/**
+	 * In the majority of the time, there will no annotations at all.
+	 * We will try to optimized the storage by packing both
+	 * method and parameter annotation into one field. 
+	 * 
+	 * If there are no annotations and no parameter annotations, 
+	 * this will be a zero-length array. 
+	 * If this is an array of size 1, then method annotations are intialized and there 
+	 * may or may not be parameter annotations. 
+	 * If there are ever any parameter annotations, this will be an array of size > 1. 
+	 * </code>null</code> in the array means not initialized.
+	 * If the field is <code>null</code> this means it is not initalized at all.
+	 * Binary types should always initialize this field;
+	 * Method annotations are always at index 0 and parameter annotations 
+	 * always start at index 1 if they are ever present.
+	 */
+	protected IAnnotationInstance[][] extendedModifiers = null;
 	char[] signature;
 	public long tagBits;
 	
@@ -35,6 +53,7 @@
 	// for creating problem or synthetic method
 }
 public MethodBinding(int modifiers, char[] selector, TypeBinding returnType, TypeBinding[] parameters, ReferenceBinding[] thrownExceptions, ReferenceBinding declaringClass) {
+
 	this.modifiers = modifiers;
 	this.selector = selector;
 	this.returnType = returnType;
@@ -49,18 +68,23 @@
 				this.modifiers |= AccStrictfp;
 	}
 }
+
+// constructor for creating binding representing constructor
 public MethodBinding(int modifiers, TypeBinding[] parameters, ReferenceBinding[] thrownExceptions, ReferenceBinding declaringClass) {
 	this(modifiers, TypeConstants.INIT, VoidBinding, parameters, thrownExceptions, declaringClass);
 }
+
 // special API used to change method declaring class for runtime visibility check
-public MethodBinding(MethodBinding initialMethodBinding, ReferenceBinding declaringClass) {
+protected MethodBinding(MethodBinding initialMethodBinding, ReferenceBinding declaringClass) {
 	this.modifiers = initialMethodBinding.modifiers;
 	this.selector = initialMethodBinding.selector;
 	this.returnType = initialMethodBinding.returnType;
 	this.parameters = initialMethodBinding.parameters;
 	this.thrownExceptions = initialMethodBinding.thrownExceptions;
 	this.declaringClass = declaringClass;
+	this.extendedModifiers = initialMethodBinding.extendedModifiers;
 }
+
 /* Answer true if the argument types & the receiver's parameters are equal
 */
 public final boolean areParametersEqual(MethodBinding method) {
@@ -367,6 +391,165 @@
 	return modifiers & AccJustFlag;
 }
 
+void buildAnnotations()
+{
+	if( this.extendedModifiers != null ) return;
+	IAnnotationInstance[] methodAnnotations = buildMethodAnnotations();
+	IAnnotationInstance[][] paramAnnotations = buildParamAnnotations();
+	setExtendedModifiers(methodAnnotations, paramAnnotations);
+}
+
+public void setExtendedModifiers(final IAnnotationInstance[] methodAnnotations, 
+								 final IAnnotationInstance[][] parameterAnnotations )
+{
+	final int numMethodAnnos = methodAnnotations == null ?  0 : methodAnnotations.length;
+	final int numParams = parameterAnnotations == null ? 0 : parameterAnnotations.length; 
+	if( numMethodAnnos == 0 && numParams == 0 )
+		this.extendedModifiers = NoAnnotationsAtAll;
+	else if( numParams == 0 )
+		// no even going to create that spot.
+		this.extendedModifiers = new IAnnotationInstance[][]{ methodAnnotations };
+	else{
+		this.extendedModifiers = new IAnnotationInstance[numParams + 1][]; 
+		this.extendedModifiers[0] = methodAnnotations;
+		int extModIndex = 1;
+		for( int pIndex=0; pIndex<numParams; pIndex++, extModIndex ++ ){
+			this.extendedModifiers[extModIndex] = parameterAnnotations[pIndex];
+			if( this.extendedModifiers[extModIndex] == null )
+				this.extendedModifiers[extModIndex] = NoAnnotations;
+		}
+	}	
+}
+
+private IAnnotationInstance[] buildMethodAnnotations()
+{
+	IAnnotationInstance[] methodAnno = NoAnnotations;	
+	MethodBinding originalMethod = this.original();
+	if(!isBinary())
+	{
+		TypeDeclaration typeDecl = ((SourceTypeBinding)originalMethod.declaringClass).scope.referenceContext;		
+		AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(originalMethod);
+					
+		if (methodDecl != null){
+			final int len = methodDecl.annotations == null ? 0 : methodDecl.annotations.length;
+			if( len > 0 ){
+				methodAnno = new IAnnotationInstance[len];
+				for( int i=0; i<len; i++ ){
+					methodDecl.annotations[i].resolveType(methodDecl.scope);
+					methodAnno[i] = methodDecl.annotations[i].getCompilerAnnotation();
+				}
+			}			
+		}		
+	}
+	return methodAnno;
+}
+
+private IAnnotationInstance[][] buildParamAnnotations()
+{
+	IAnnotationInstance[][] result = null;
+	MethodBinding originalMethod = this.original();
+	if(!isBinary())
+	{
+		TypeDeclaration typeDecl = ((SourceTypeBinding)originalMethod.declaringClass).scope.referenceContext;
+		AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(originalMethod);		
+		if(methodDecl != null ){
+			final Argument[] args = methodDecl.arguments;
+			final int numArgs = args == null ? 0 : args.length;
+			for( int argIndex=0; argIndex<numArgs; argIndex++ )
+			{
+				final Argument arg = args[argIndex];
+				final Annotation[] argAnnos = arg.annotations;
+				final int numAnnotations = argAnnos == null ? 0 : argAnnos.length;				
+				if( numAnnotations > 0 ){
+					if( result == null ){
+						result = new IAnnotationInstance[numArgs][];
+						for( int i=0; i<numArgs; i++ )
+							result[i] = NoAnnotations;
+					}
+					result[argIndex] = new SourceAnnotation[numAnnotations];
+					// check for errors
+					ASTNode.resolveAnnotations(methodDecl.scope, argAnnos, this);
+					for( int j=0; j<numAnnotations; j++ ){
+						argAnnos[j].resolveType(methodDecl.scope);
+						result[argIndex][j] = argAnnos[j].getCompilerAnnotation();
+					}
+				}	
+			}
+		}
+	}
+	
+	return result;
+}
+
+private boolean isBinary()
+{
+	final MethodBinding originalMethod = this.original();
+	return originalMethod.declaringClass != null &&
+		   originalMethod.declaringClass.isBinaryBinding();
+}
+
+/**
+ * @return the annotations annotating this method.
+ *         Return a zero-length array if none is found.
+ */
+public IAnnotationInstance[] getAnnotations()
+{	
+	if( this.extendedModifiers == null )
+		buildAnnotations();
+	final boolean isBinary = isBinary();	
+	// part of the binary annotations are in the tag bits
+	if( isBinary ){
+		final long stdAnnoTagBits = getAnnotationTagBits();
+		final int numStandardAnnotations = AnnotationUtils.getNumberOfStandardAnnotations(stdAnnoTagBits);
+		final int current = this.extendedModifiers.length == 0 ? 0 : 
+							this.extendedModifiers[0].length;		
+		if( numStandardAnnotations == 0 ){
+			if(this.extendedModifiers.length == 0) 
+				return NoAnnotations;
+			else
+				return this.extendedModifiers[0];
+		}
+		else{			
+			final LookupEnvironment env = ((BinaryTypeBinding)this.declaringClass).environment;
+			final int total = numStandardAnnotations + current;
+			final BinaryAnnotation[] result = new BinaryAnnotation[total];
+			final int index = AnnotationUtils.buildStandardAnnotations(stdAnnoTagBits, result, env);
+			if( current == 0 )
+				return result;
+			else{
+				System.arraycopy(this.extendedModifiers[0], 0, result, index, current);
+				return result;
+			}
+		}
+	}
+	else{
+		if( this.extendedModifiers.length == 0 )
+			return NoAnnotations;
+		else
+			return this.extendedModifiers[0];
+	}
+}
+
+/**
+ * @param index the index of the parameter of interest
+ * @return the annotations on the <code>index</code>th parameter
+ * @throws ArrayIndexOutOfBoundsException when <code>index</code> is not valid 
+ */
+public IAnnotationInstance[] getParameterAnnotations(final int index)
+{
+	getAnnotationTagBits();
+	final int len = this.extendedModifiers.length;
+	if( len < 2 )
+		return NoAnnotations;
+	else{
+		final int extModIndex = index + 1;
+		if( extModIndex < 1 || extModIndex >= len )
+			throw new ArrayIndexOutOfBoundsException("length = " + len + " index = " + index );   //$NON-NLS-1$ //$NON-NLS-2$
+		return this.extendedModifiers[extModIndex];
+	}
+}
+
+
 /**
  * Compute the tagbits for standard annotations. For source types, these could require
  * lazily resolving corresponding annotation nodes, in case of forward references.
@@ -378,93 +561,11 @@
 		TypeDeclaration typeDecl = ((SourceTypeBinding)originalMethod.declaringClass).scope.referenceContext;
 		AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(originalMethod);
 		if (methodDecl != null)
-			ASTNode.resolveAnnotations(methodDecl.scope, methodDecl.annotations, originalMethod);
+			ASTNode.resolveAnnotations(methodDecl.scope, methodDecl.annotations, originalMethod);		
 	}
 	return originalMethod.tagBits;
 }
 
-/**
- * @return the annotations annotating this method.
- *         Return a zero-length array if none is found.
- */
-public IAnnotationInstance[] getAnnotations() 
-{	
-	// make sure they are checked for problems/
-	// this call will also initialize the 'compilerAnnotation' field.
-	getAnnotationTagBits();
-	IAnnotationInstance[] methodAnno = NoAnnotations;	
-	if(this.declaringClass != null && this.declaringClass instanceof SourceTypeBinding )
-	{
-		TypeDeclaration typeDecl = ((SourceTypeBinding)declaringClass).scope.referenceContext;		
-		AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(this);
-					
-		if (methodDecl != null){
-			final int len = methodDecl.annotations == null ? 0 : methodDecl.annotations.length;
-			if( len > 0 ){
-				methodAnno = new IAnnotationInstance[len];
-				for( int i=0; i<len; i++ ){
-					methodAnno[i] = methodDecl.annotations[i].compilerAnnotation;
-				}
-			}			
-		}		
-	}
-	return methodAnno;
-}
-
-/**
- * @param index the index of the parameter of interest
- * @return the annotations on the <code>index</code>th parameter
- * @throws ArrayIndexOutOfBoundsException when <code>index</code> is not valid 
- */
-public IAnnotationInstance[] getParameterAnnotations(final int index)
-{	
-	IAnnotationInstance[] result = NoAnnotations;
-	if(this.declaringClass != null && this.declaringClass instanceof SourceTypeBinding )
-	{
-		TypeDeclaration typeDecl = ((SourceTypeBinding)this.declaringClass).scope.referenceContext;
-		AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(this);
-		if(methodDecl != null ){
-			final Argument[] args = methodDecl.arguments;
-			final int numArgs = args == null ? 0 : args.length;
-			if( numArgs == 0 || index < 0 || index >= numArgs )
-				throw new IllegalArgumentException("number of parameters = " + numArgs + //$NON-NLS-1$ 
-						   						   " index = " + index ); //$NON-NLS-1$	
-			final Argument arg = args[index];
-			final Annotation[] argAnnos = arg.annotations;
-			final int numAnnotations = argAnnos == null ? 0 : argAnnos.length;
-			
-			if( numAnnotations > 0 ){
-				result = new SourceAnnotation[numAnnotations];
-				// check for errors
-				ASTNode.resolveAnnotations(methodDecl.scope, argAnnos, this);
-				for( int j=0; j<numAnnotations; j++ ){
-					result[j] = argAnnos[j].compilerAnnotation;
-				}
-			}	
-		}
-	}
-	
-	return result;
-}
-
-/**
- * @return the default value iff this is an annotation method.
- *         Return <code>null</code> if there is no default value or 
- *         if this is not an annotaion method. 
- */
-public Object getDefaultValue()
-{
-	if(this.declaringClass != null && this.declaringClass instanceof SourceTypeBinding )
-	{
-		TypeDeclaration typeDecl = ((SourceTypeBinding)this.declaringClass).scope.referenceContext;
-		final AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(this);
-		if( methodDecl instanceof AnnotationMethodDeclaration){
-			return SourceElementValuePair.getValue(((AnnotationMethodDeclaration)methodDecl).defaultValue);
-		}
-	}
-	return null;
-}
-
 public TypeVariableBinding getTypeVariable(char[] variableName) {
 	for (int i = this.typeVariables.length; --i >= 0;)
 		if (CharOperation.equals(this.typeVariables[i].sourceName, variableName))
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodScope.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodScope.java
index 1114282..715795f 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodScope.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodScope.java
@@ -293,12 +293,10 @@
 			if (declaringClass.isInterface()) // interface or annotation type
 				modifiers |= AccPublic | AccAbstract;		
 			
-			method.binding = new MethodBinding(modifiers, 
-											   method.selector, 
-											   null, 
-											   null, 
-											   null, 
-											   declaringClass);
+			if( declaringClass.isAnnotationType() )
+				method.binding = new AnnotationMethodBinding(modifiers, method.selector, null, declaringClass, null);
+			else
+				method.binding = new MethodBinding(modifiers, method.selector, null, null, null, declaringClass);
 			checkAndSetModifiersForMethod(method.binding);
 		}
 		this.isStatic = method.binding.isStatic();
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedMethodBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedMethodBinding.java
index 734662a..47deacd 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedMethodBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedMethodBinding.java
@@ -154,9 +154,4 @@
 	{
 		return original().getParameterAnnotations(index);
 	}
-	
-	public Object getDefaultValue()
-	{
-		return original().getDefaultValue();
-	}
 }
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java
index d534a2f..db4f742 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java
@@ -36,6 +36,7 @@
 	char[] fileName;
 	char[] constantPoolName;
 	char[] signature;
+	protected IAnnotationInstance[] annotations;
 
 public FieldBinding[] availableFields() {
 	return fields();
@@ -861,6 +862,6 @@
  */
 public IAnnotationInstance[] getAnnotations()
 {
-	return NoAnnotations;
+	return this.annotations;
 }
 }
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceAnnotation.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceAnnotation.java
index 80398a1..3ccbb33 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceAnnotation.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceAnnotation.java
@@ -2,6 +2,8 @@
 
 import org.eclipse.jdt.internal.compiler.ast.Annotation;
 import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
+import org.eclipse.jdt.internal.compiler.ast.NormalAnnotation;
+import org.eclipse.jdt.internal.compiler.ast.SingleMemberAnnotation;
 
 /**
  * Annotation that came from source.
@@ -9,27 +11,38 @@
  *
  */
 public class SourceAnnotation implements IAnnotationInstance, TypeConstants
-{
-	private final Annotation astAnnotation;
+{	
+	private ReferenceBinding type;
 	private final IElementValuePair[] pairs;
 	
 	public SourceAnnotation(Annotation astAnnotation)
-	{
-		this.astAnnotation = astAnnotation;
-		final MemberValuePair[] astPairs = astAnnotation.memberValuePairs();
-		int numberOfPairs = astPairs == null ? 0 : astPairs.length;
-		if( numberOfPairs == 0 )
-			this.pairs = NoElementValuePairs;
-		else{
-			this.pairs = new SourceElementValuePair[numberOfPairs];
-			for( int i=0; i<numberOfPairs; i++ ){
-				this.pairs[i] = new SourceElementValuePair(astPairs[i]);
+	{	
+		this.type = (ReferenceBinding)astAnnotation.resolvedType;
+		if( astAnnotation instanceof NormalAnnotation ){
+			final MemberValuePair[] astPairs = ((NormalAnnotation)astAnnotation).memberValuePairs;
+			final int numberOfPairs = astPairs == null ? 0 : astPairs.length;			
+			if( numberOfPairs > 0 ){
+				this.pairs = new SourceElementValuePair[numberOfPairs];
+				for( int i=0; i<numberOfPairs; i++ ){
+					this.pairs[i] = new SourceElementValuePair(astPairs[i]);
+				}				
 			}
-		}	
+			else
+				this.pairs = NoElementValuePairs;
+		}
+		else if( astAnnotation instanceof SingleMemberAnnotation ){
+			final MemberValuePair astPair = ((SingleMemberAnnotation)astAnnotation).singlePair;
+			if( astPair != null )
+				this.pairs = new SourceElementValuePair[]{ new SourceElementValuePair(astPair) };
+			else
+				this.pairs = NoElementValuePairs;
+		}
+		else 
+			this.pairs = NoElementValuePairs;
 	}
 	
 	public ReferenceBinding getAnnotationType() {	
-		return (ReferenceBinding)this.astAnnotation.resolvedType;
+		return this.type;
 	}
 	
 	public IElementValuePair[] getElementValuePairs() { return this.pairs; }
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceElementValuePair.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceElementValuePair.java
index 3c0e84b..8fab89b 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceElementValuePair.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceElementValuePair.java
@@ -4,37 +4,40 @@
 import org.eclipse.jdt.internal.compiler.ast.ArrayInitializer;
 import org.eclipse.jdt.internal.compiler.ast.ClassLiteralAccess;
 import org.eclipse.jdt.internal.compiler.ast.Expression;
+import org.eclipse.jdt.internal.compiler.ast.FieldReference;
 import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
+import org.eclipse.jdt.internal.compiler.ast.NameReference;
+import org.eclipse.jdt.internal.compiler.ast.Reference;
+import org.eclipse.jdt.internal.compiler.env.IConstants;
 import org.eclipse.jdt.internal.compiler.impl.Constant;
 
 public class SourceElementValuePair implements IElementValuePair 
-{
-	private final MemberValuePair astPair;
-	private Object value = null;
+{	
+	private final char[] name;	
+	private final MethodBinding binding;
+	private final Object value;
 	
 	SourceElementValuePair(final MemberValuePair pair)
 	{
-		this.astPair = pair;
+		this.name = pair.name;
+		this.binding = pair.binding;
+		this.value = getValue(pair.value);		
 	}
 	
 	public char[] getMemberName()
-	{ return this.astPair.name; }
+	{ return this.name; }
 	
 	public MethodBinding getMethodBinding() {
-		return this.astPair.binding;
+		return this.binding;
 	}
 	
 	public TypeBinding getType() {
-		if(this.astPair.binding == null) return null;
-		return this.astPair.binding.returnType;
+		if(this.binding == null) return null;
+		return this.binding.returnType;
 	}
 	
 	public Object getValue() {
-		if( this.value != null ) return this.value;
-		
-		final Expression expression = this.astPair.value;
-		this.value = getValue(expression);
-		return this.value;
+		return this.value;	
 	}
 	
 	static Object getValue(Expression expression)
@@ -42,10 +45,24 @@
 		if( expression == null ) return null;
 		Constant constant = expression.constant;
 		// literals would hit this case.
-		if( constant != null ) return constant;
+		if( constant != null && constant != Constant.NotAConstant) return constant;
 			
 		if( expression instanceof Annotation )
-			return new SourceAnnotation( (Annotation)expression );            
+			return new SourceAnnotation( (Annotation)expression );      
+		else if(expression instanceof Reference){
+            FieldBinding fieldBinding = null;
+            if(expression instanceof FieldReference )
+                fieldBinding = ((FieldReference)expression).fieldBinding();
+            else if(expression instanceof NameReference ){
+                final Binding binding = ((NameReference)expression).binding;
+                if( binding != null && binding.kind() == Binding.FIELD )
+                    fieldBinding = (FieldBinding)binding;
+            }
+
+            if( fieldBinding != null && (fieldBinding.modifiers & IConstants.AccEnum) > 0 ){
+				return fieldBinding;
+            }
+        }
 
         else if( expression instanceof ArrayInitializer )
         {
@@ -61,8 +78,7 @@
             final ClassLiteralAccess classLiteral = (ClassLiteralAccess)expression;
 			return classLiteral.targetType;            
         }        
-        // something that isn't a compile time constant.
-        else
-            return null;
+        // something that isn't a compile time constant.        
+        return null;
 	}
 }
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
index 018dc2b..0992443 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
@@ -634,19 +634,25 @@
 	return this.tagBits;
 }
 
-public IAnnotationInstance[] getAnnotations() {
-	// make sure we first go resolve the annoations and report any problems found.
-	getAnnotationTagBits();
+public IAnnotationInstance[] getAnnotations()
+{
+	if( this.annotations == null )
+		buildAnnotations();
+	return this.annotations;
+}
+
+private void buildAnnotations()
+{
+	if( this.annotations != null ) return;
+	this.annotations = NoAnnotations;
 	final TypeDeclaration typeDecl = this.scope.referenceContext;
 	final int numAnnotations = typeDecl.annotations == null ? 0 : typeDecl.annotations.length;
-	if( numAnnotations == 0 )
-		return NoAnnotations;
-	else{
-		final IAnnotationInstance[] instances = new IAnnotationInstance[numAnnotations];
-		for( int i=0; i<numAnnotations; i++ ){
-			instances[i] = new SourceAnnotation(typeDecl.annotations[i]);
+	if( numAnnotations > 0 ){
+		this.annotations = new IAnnotationInstance[numAnnotations];
+		for( int i=0; i<numAnnotations; i++ ){		
+			typeDecl.annotations[i].resolveType(typeDecl.staticInitializerScope);			
+			this.annotations[i] = typeDecl.annotations[i].getCompilerAnnotation();			
 		}
-		return instances;
 	}
 }
 
@@ -910,12 +916,8 @@
 		this.synthetics[RECEIVER_TYPE_EMUL].put(targetField, fieldMap);
 	}
 	FieldBinding updatedField = (FieldBinding) fieldMap.get(newDeclaringClass);
-	if (updatedField == null){
-		if( targetField instanceof BinaryFieldBinding )
-			updatedField = new BinaryFieldBinding((BinaryFieldBinding)targetField, newDeclaringClass);
-		else
-			updatedField = new FieldBinding(targetField, newDeclaringClass);
-			
+	if (updatedField == null){		
+		updatedField = new FieldBinding( targetField, newDeclaringClass);
 		fieldMap.put(newDeclaringClass, updatedField);
 	}
 	return updatedField;
@@ -933,11 +935,7 @@
 	}
 	MethodBinding updatedMethod = (MethodBinding) methodMap.get(newDeclaringClass);
 	if (updatedMethod == null){
-		if( targetMethod instanceof BinaryMethodBinding )
-			updatedMethod = new BinaryMethodBinding((BinaryMethodBinding)targetMethod, newDeclaringClass);
-		else
-			updatedMethod = new MethodBinding(targetMethod, newDeclaringClass);	
-			
+		updatedMethod = new MethodBinding(targetMethod, newDeclaringClass);	
 		methodMap.put(newDeclaringClass, updatedMethod);
 	}
 	return updatedMethod;
@@ -1385,4 +1383,19 @@
 	for (int i = memberTypes.length; --i >= 0;)
 		 ((SourceTypeBinding) memberTypes[i]).verifyMethods(verifier);
 }
+/*
+ * Called when the ast information is about to be null-ed out.
+ */
+public void finish()
+{
+	buildAnnotations();
+	if(this.methods != null){
+		for( int i=0, len=this.methods.length; i<len; i++ )
+			this.methods[i].buildAnnotations();
+	}
+	if(this.fields != null){
+		for( int i=0, len=this.fields.length; i<len; i++)
+			this.fields[i].buildAnnotations();
+	}
+}
 }
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeConstants.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeConstants.java
index 6ba984f..5f3c9cd 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeConstants.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeConstants.java
@@ -33,6 +33,15 @@
 	char[] CharArray_JAVA_IO_OBJECTINPUTSTREAM = "java.io.ObjectInputStream".toCharArray(); //$NON-NLS-1$
 	char[] CharArray_JAVA_IO_OBJECTOUTPUTSTREAM = "java.io.ObjectOutputStream".toCharArray(); //$NON-NLS-1$
 	char[] CharArray_JAVA_IO_OBJECTSTREAMFIELD = "java.io.ObjectStreamField".toCharArray(); //$NON-NLS-1$
+	char[] CharArray_JAVA_LANG_DEPRECATED_SIG = "Ljava/lang/Deprecated;".toCharArray();  //$NON-NLS-1$	
+	char[] CharArray_JAVA_LANG_OVERRIDE_SIG = "Ljava/lang/Override;".toCharArray();  //$NON-NLS-1$
+	char[] CharArray_JAVA_LANG_SUPRESSWARNING_SIG = "Ljava/lang/SupressWarning;".toCharArray();  //$NON-NLS-1$
+	char[] CharArray_JAVA_LANG_ANNOTATION_DOCUMENTED_SIG = "Ljava/lang/annotation/Documented;".toCharArray();  //$NON-NLS-1$
+	char[] CharArray_JAVA_LANG_ANNOTATION_INHERITED_SIG = "Ljava/lang/annotation/Inherited;".toCharArray();  //$NON-NLS-1$
+	char[] CharArray_JAVA_LANG_ANNOTATION_RETENTION_SIG = "Ljava/lang/annotation/Retention;".toCharArray();  //$NON-NLS-1$
+	char[] CharArray_JAVA_LANG_ANNOTATION_TARGET_SIG = "Ljava/lang/annotation/Target;".toCharArray();  //$NON-NLS-1$
+	char[] CharArray_JAVA_LANG_ANNOTATION_RETENTIONPOLICY_SIG = "Ljava/lang/annotation/RetentionPolicy;".toCharArray();  //$NON-NLS-1$
+	char[] CharArray_JAVA_LANG_ANNOTATION_ELEMENTTYPE_SIG = "Ljava/lang/annotation/ElementType;".toCharArray();  //$NON-NLS-1$
 	char[] ANONYM_PREFIX = "new ".toCharArray(); //$NON-NLS-1$
 	char[] ANONYM_SUFFIX = "(){}".toCharArray(); //$NON-NLS-1$
     char[] WILDCARD_NAME = { '?' };
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/VariableBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/VariableBinding.java
index 6efe750..dbcc32f 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/VariableBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/VariableBinding.java
@@ -12,7 +12,7 @@
 
 import org.eclipse.jdt.internal.compiler.impl.Constant;
 
-public abstract class VariableBinding extends Binding {
+public abstract class VariableBinding extends Binding implements TypeConstants {
     
 	public int modifiers;
 	public TypeBinding type;
@@ -20,6 +20,7 @@
 	private Constant constant;
 	public int id; // for flow-analysis (position in flowInfo bit vector)
 	public long tagBits;
+	protected IAnnotationInstance[] annotations;
 
 	public VariableBinding(char[] name, TypeBinding type, int modifiers, Constant constant) {
 		this.name = name;
@@ -55,7 +56,10 @@
 	 * @return the annotations iff this is a field, enum constant or parameter.
 	 * Return null otherwise.
 	 */
-	public abstract IAnnotationInstance[] getAnnotations();
+	public IAnnotationInstance[] getAnnotations()
+	{		
+		return this.annotations; 
+	}
 	
 	public String toString() {
 		String s = (type != null) ? type.debugName() : "UNDEFINED TYPE"; //$NON-NLS-1$
diff --git a/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java b/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
index 984bf04..52aba01 100644
--- a/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
+++ b/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
@@ -269,7 +269,7 @@
 		if (binding != null) {
 			return binding;
 		}
-		binding = new PackageBinding(packageBinding);
+		binding = new PackageBinding(packageBinding, this);
 		this.bindingTables.compilerBindingsToASTBindings.put(packageBinding, binding);
 		return binding;
 	}
@@ -362,6 +362,7 @@
 	}
 	
 	synchronized IResolvedAnnotation getAnnotationInstance(org.eclipse.jdt.internal.compiler.lookup.IAnnotationInstance internalInstance){
+		if( internalInstance == null ) return null;
 		IResolvedAnnotation domInstance = 
 			(IResolvedAnnotation) this.bindingTables.compilerBindingsToASTBindings.get(internalInstance);
 		if (domInstance != null) {
@@ -1426,7 +1427,7 @@
 			org.eclipse.jdt.internal.compiler.ast.Annotation internalAstNode = 
 				(org.eclipse.jdt.internal.compiler.ast.Annotation) oldNode;
 			
-			IResolvedAnnotation domAnnotation = this.getAnnotationInstance(internalAstNode.compilerAnnotation);
+			IResolvedAnnotation domAnnotation = this.getAnnotationInstance(internalAstNode.getCompilerAnnotation());
 			if (domAnnotation == null) {
 				return null;
 			}
diff --git a/dom/org/eclipse/jdt/core/dom/MethodBinding.java b/dom/org/eclipse/jdt/core/dom/MethodBinding.java
index 2c4009e..dadc4a6 100644
--- a/dom/org/eclipse/jdt/core/dom/MethodBinding.java
+++ b/dom/org/eclipse/jdt/core/dom/MethodBinding.java
@@ -422,7 +422,7 @@
 		if( isAnnotationMember() ){
 			final Object internalObject = 
 				((org.eclipse.jdt.internal.compiler.lookup.AnnotationMethodBinding)this.binding).getDefaultValue();
-			return ResolvedMemberValuePair.buildDOMValue(internalObject, this.binding.returnType, this.resolver);
+			return ResolvedMemberValuePair.buildDOMValue(internalObject, this.resolver);
 		}
 		return null;
 	}
diff --git a/dom/org/eclipse/jdt/core/dom/PackageBinding.java b/dom/org/eclipse/jdt/core/dom/PackageBinding.java
index 0bba13a..eb5bea3 100644
--- a/dom/org/eclipse/jdt/core/dom/PackageBinding.java
+++ b/dom/org/eclipse/jdt/core/dom/PackageBinding.java
@@ -30,7 +30,7 @@
 	private String name;
 	private String[] components;
 		
-	PackageBinding(org.eclipse.jdt.internal.compiler.lookup.PackageBinding binding) {
+	PackageBinding(org.eclipse.jdt.internal.compiler.lookup.PackageBinding binding, BindingResolver resolver) {
 		this.binding = binding;
 	}
 	
@@ -149,8 +149,7 @@
 	}
 	
 	public IResolvedAnnotation[] getAnnotations() {
-		// TODO Auto-generated method stub
-		throw new RuntimeException("Not implemented yet"); //$NON-NLS-1$
+		throw new UnsupportedOperationException("NYI"); //$NON-NLS-1$
 	}
 
 	/* 
diff --git a/dom/org/eclipse/jdt/core/dom/ResolvedAnnotation.java b/dom/org/eclipse/jdt/core/dom/ResolvedAnnotation.java
index 7b6b991..ced5457 100644
--- a/dom/org/eclipse/jdt/core/dom/ResolvedAnnotation.java
+++ b/dom/org/eclipse/jdt/core/dom/ResolvedAnnotation.java
@@ -10,6 +10,13 @@
  *******************************************************************************/
 package org.eclipse.jdt.core.dom;
 
+import java.util.Arrays;
+import java.util.Comparator;
+
+import org.eclipse.jdt.core.compiler.CharOperation;
+import org.eclipse.jdt.internal.compiler.lookup.AnnotationMethodBinding;
+import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
+
 /**
  * Internal class
  */
@@ -19,10 +26,16 @@
 	private final org.eclipse.jdt.internal.compiler.lookup.IAnnotationInstance internalAnnotation;
 	private final BindingResolver bindingResolver;
 	
+	/**	 
+	 * @param anno
+	 * @param resolver
+	 */
 	ResolvedAnnotation(org.eclipse.jdt.internal.compiler.lookup.IAnnotationInstance anno, 
 	  				   BindingResolver resolver )
 	{
 		internalAnnotation = anno;
+		if( internalAnnotation == null )
+			throw new IllegalStateException();
 		bindingResolver = resolver;
 	}
 	
@@ -35,17 +48,76 @@
 	public IResolvedMemberValuePair[] getDeclaredMemberValuePairs() {
 		final org.eclipse.jdt.internal.compiler.lookup.IElementValuePair[] internalPair =
 			this.internalAnnotation.getElementValuePairs();
-		final int len = internalPair.length;
+		final int len = internalPair.length;		
 		IResolvedMemberValuePair[] pairs = ResolvedMemberValuePair.NoPair;
-		for( int i=0; i<len; i++ ){
-			pairs[i] = new ResolvedMemberValuePair(internalPair[i],this.bindingResolver);
+		if( len > 0 )
+		{
+			pairs = new ResolvedMemberValuePair[len];
+			for( int i=0; i<len; i++ ){
+				pairs[i] = new ResolvedMemberValuePair(internalPair[i],this.bindingResolver);
+			}
 		}
 		return pairs;
 	}
 	
 	public IResolvedMemberValuePair[] getAllMemberValuePairs() {
-		// TODO missing implementation
-		throw new RuntimeException("Not implemented yet"); //$NON-NLS-1$
+		final ReferenceBinding typeBinding = this.internalAnnotation.getAnnotationType();
+		IResolvedMemberValuePair[] pairs = ResolvedMemberValuePair.NoPair;
+		final org.eclipse.jdt.internal.compiler.lookup.MethodBinding[] methods = typeBinding.methods();
+		final int len = methods == null ? 0 : methods.length;
+		if(typeBinding != null && len > 0 ){
+			final org.eclipse.jdt.internal.compiler.lookup.IElementValuePair[] internalPair = 
+				this.internalAnnotation.getElementValuePairs();
+			final int declaredLen = internalPair == null ? 0 : internalPair.length;
+			final Object[] names = declaredLen < len ? new Object[declaredLen] : null;
+			for( int i=0; i<declaredLen; i++ ){
+				pairs[i] = new ResolvedMemberValuePair(internalPair[i], this.bindingResolver);
+				names[i] = internalPair[i].getMemberName();
+			}
+			if( declaredLen < len ){
+				final MemberComparator comparator = new MemberComparator();
+				Arrays.sort(names, comparator);
+				int pIndex = declaredLen;
+				for( int i=0; i<len; i++, pIndex++ ){
+					final char[] selector = methods[i].selector;
+					final int index = Arrays.binarySearch(names, selector, comparator);
+					if( index < 0 )
+						pairs[pIndex] = new ResolvedDefaultValuePair((AnnotationMethodBinding)methods[i], this.bindingResolver);
+				}				
+			}			
+		}
+		return pairs;
 	}
 	
+	public String toString()
+	{
+		final ITypeBinding annoType = getAnnotationType();	
+	    
+		final StringBuffer buffer = new StringBuffer();		
+		buffer.append('@');
+		if(annoType != null)
+			buffer.append(annoType.getName());
+		buffer.append('(');
+		final IResolvedMemberValuePair[] pairs = getDeclaredMemberValuePairs();		
+		for( int i = 0, len = pairs.length; i<len; i++ ){
+			if( i != 0 )
+				buffer.append(", "); //$NON-NLS-1$
+			buffer.append(pairs[i].toString());
+		}
+		buffer.append(')');
+		return buffer.toString();
+		
+	}
+	
+	private static class MemberComparator implements Comparator
+	{
+		public int compare(Object arg0, Object arg1) 
+		{
+			// throws ClassCastException if either one of the arguments is not 
+			// a char[]
+			final char[] c0 = (char[])arg0;
+			final char[] c1 = (char[])arg1;
+			return CharOperation.compareWith(c0, c1);
+		}
+	}
 }
diff --git a/dom/org/eclipse/jdt/core/dom/ResolvedDefaultValuePair.java b/dom/org/eclipse/jdt/core/dom/ResolvedDefaultValuePair.java
new file mode 100644
index 0000000..b7da76e
--- /dev/null
+++ b/dom/org/eclipse/jdt/core/dom/ResolvedDefaultValuePair.java
@@ -0,0 +1,80 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    tyeung@bea.com - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.core.dom;
+
+import org.eclipse.jdt.core.dom.BindingResolver;
+import org.eclipse.jdt.core.dom.IMethodBinding;
+import org.eclipse.jdt.core.dom.IResolvedMemberValuePair;
+
+/**
+ * Member value pair which compose of default values.
+ */
+class ResolvedDefaultValuePair implements IResolvedMemberValuePair
+{	
+	private final org.eclipse.jdt.internal.compiler.lookup.MethodBinding method;
+	private final Object domValue;
+	private final BindingResolver bindingResolver;
+	
+	ResolvedDefaultValuePair(org.eclipse.jdt.internal.compiler.lookup.AnnotationMethodBinding binding, final BindingResolver resolver )
+	{	
+		this.method = binding;
+		this.domValue = ResolvedMemberValuePair.buildDOMValue(binding.getDefaultValue(), resolver);
+		this.bindingResolver = resolver;
+	}
+	public String getName() {
+		return new String( this.method.selector ); 
+	}
+	
+	public IMethodBinding getMemberBinding() {
+		return this.bindingResolver.getMethodBinding(this.method);
+	}
+	
+	public Object getValue() {
+		return this.domValue;
+	}	
+	
+	public void toString(StringBuffer buffer) {
+		buffer.append(getName());
+		buffer.append(" = "); //$NON-NLS-1$		
+		appendValue(getValue(), buffer);		
+	}
+	
+	static void appendValue(Object value, StringBuffer buffer) {
+		if( value instanceof Object[] ){
+			appendValue((Object[])value, buffer);
+		}
+		else{
+			if(value instanceof ITypeBinding ){
+				buffer.append( ((ITypeBinding)value).getName() );
+				buffer.append( ".class" ); //$NON-NLS-1$
+			}
+			else
+				buffer.append(value);
+		}
+	}
+	
+	private static void appendValue(Object[] values, StringBuffer buffer) {		
+		buffer.append('{');
+		for( int i=0, len=values.length; i<len; i++ ){
+			if( i != 0 )
+				buffer.append(", "); //$NON-NLS-1$
+			appendValue(values[i], buffer);
+			
+		}				
+		buffer.append('}');
+	}
+	
+	public String toString() {
+		final StringBuffer buffer = new StringBuffer();
+		toString(buffer);
+		return buffer.toString();
+	}
+}
diff --git a/dom/org/eclipse/jdt/core/dom/ResolvedMemberValuePair.java b/dom/org/eclipse/jdt/core/dom/ResolvedMemberValuePair.java
index 5959802..2c4b8b7 100644
--- a/dom/org/eclipse/jdt/core/dom/ResolvedMemberValuePair.java
+++ b/dom/org/eclipse/jdt/core/dom/ResolvedMemberValuePair.java
@@ -18,78 +18,79 @@
  */
 class ResolvedMemberValuePair implements IResolvedMemberValuePair
 {	
-	static final ResolvedMemberValuePair[] NoPair = new ResolvedMemberValuePair[0]; 
+	static final ResolvedMemberValuePair[] NoPair = new ResolvedMemberValuePair[0]; 	
 	private static final Object NoValue = new Object();
+	private static final Object[] EmptyArray = new Object[0];
+	
 	private final org.eclipse.jdt.internal.compiler.lookup.IElementValuePair internalPair;
 	private Object value = null; 
 	private final BindingResolver bindingResolver;
 	
 	ResolvedMemberValuePair(final org.eclipse.jdt.internal.compiler.lookup.IElementValuePair pair, 
-					 BindingResolver resolver)
-	{	
+					 		BindingResolver resolver) {	
 		this.internalPair = pair;
 		this.bindingResolver = resolver;		
 	}
 	
-	private void init()
-	{
-		final org.eclipse.jdt.internal.compiler.lookup.TypeBinding type = this.internalPair.getType();
-		this.value =  buildDOMValue(this.internalPair.getValue(), type, this.bindingResolver);
+	private void init() {		
+		this.value =  buildDOMValue(this.internalPair.getValue(), this.bindingResolver);
 		if( this.value == null )
 			this.value = NoValue;
 	}
 	
 	static Object buildDOMValue(final Object internalObject, 
-			  				    org.eclipse.jdt.internal.compiler.lookup.TypeBinding type,
-			  				    BindingResolver resolver)
-	{
-		if( internalObject == null || type == null ) return null;
-		switch(type.id)
-		{
-		case TypeIds.T_boolean:
-			return new Boolean( ((Constant)internalObject).booleanValue() );			
-		case TypeIds.T_byte:
-			return new Byte( ((Constant)internalObject).byteValue() );			
-		case TypeIds.T_char:
-			return new Character( ((Constant)internalObject).charValue() );
-		case TypeIds.T_double:
-			return new Double( ((Constant)internalObject).doubleValue() );			
-		case TypeIds.T_float:
-			return new Float( ((Constant)internalObject).floatValue() );
-		case TypeIds.T_int:
-			return new Integer( ((Constant)internalObject).intValue() );			
-		case TypeIds.T_long:
-			return new Long( ((Constant)internalObject).longValue() );			
-		case TypeIds.T_short:
-			return new Short( ((Constant)internalObject).shortValue() );
-		case TypeIds.T_JavaLangString:
-			return internalObject;
-		case TypeIds.T_JavaLangClass:
-			return resolver.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding)internalObject);
-		}	
+			  				    BindingResolver resolver) {
+		if( internalObject == null ) return null;
 		
-		if( type.isAnnotationType() ){
+		if( internalObject instanceof Constant )
+		{
+			final Constant constant = (Constant)internalObject;
+			switch( constant.typeID() )
+			{
+			case TypeIds.T_boolean:
+				return new Boolean( constant.booleanValue() );			
+			case TypeIds.T_byte:
+				return new Byte( constant.byteValue() );			
+			case TypeIds.T_char:
+				return new Character( constant.charValue() );
+			case TypeIds.T_double:
+				return new Double( constant.doubleValue() );			
+			case TypeIds.T_float:
+				return new Float( constant.floatValue() );
+			case TypeIds.T_int:
+				return new Integer( constant.intValue() );			
+			case TypeIds.T_long:
+				return new Long( constant.longValue() );			
+			case TypeIds.T_short:
+				return new Short( constant.shortValue() );
+			case TypeIds.T_JavaLangString:
+				return constant.stringValue();
+			}
+		}
+		else if( internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.TypeBinding){
+			return resolver.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding)internalObject);
+		}
+		if( internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.IAnnotationInstance ) {
 			return new ResolvedAnnotation(
 					(org.eclipse.jdt.internal.compiler.lookup.IAnnotationInstance)internalObject, 
 					resolver);
 		}
-		else if( type.isEnum() ){
+		else if( internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.FieldBinding ) {
 			return resolver.getVariableBinding((org.eclipse.jdt.internal.compiler.lookup.FieldBinding)internalObject);
 		}
-		else if( type.isArrayType() ){
+		else if( internalObject instanceof Object[] ) {
 			final Object[] iElements = (Object[])internalObject;
 			final int len = iElements.length;
-			Object[] values = null;
-			if( len > 0){
-				final org.eclipse.jdt.internal.compiler.lookup.TypeBinding elementType =
-					((org.eclipse.jdt.internal.compiler.lookup.ArrayBinding)type).leafComponentType;
+			Object[] values = EmptyArray;
+			if( len > 0){			
 				values = new Object[len];
 				for( int i=0; i<len; i++ ){
-					values[i] = buildDOMValue(iElements[i], elementType, resolver);
+					values[i] = buildDOMValue(iElements[i], resolver);
 				}
 			}
-		}
-		throw new IllegalStateException(); // should never get here.		
+			return values;
+		}		
+		throw new IllegalStateException(internalObject.toString()); // should never get here.		
 	}
 	
 	public String getName() {
@@ -106,4 +107,17 @@
 			init();
 		return value == NoValue ? null : this.value;
 	}	
+	
+	public void toString(StringBuffer buffer) {
+		buffer.append(getName());
+		buffer.append(" = "); //$NON-NLS-1$		
+		ResolvedDefaultValuePair.appendValue(getValue(), buffer);		
+	}
+	
+	public String toString() {
+		final StringBuffer buffer = new StringBuffer();
+		toString(buffer);
+		return buffer.toString();
+	}
 }
+
diff --git a/model/org/eclipse/jdt/core/JavaCore.java b/model/org/eclipse/jdt/core/JavaCore.java
index 4f32ee9..0dd1e6c 100644
--- a/model/org/eclipse/jdt/core/JavaCore.java
+++ b/model/org/eclipse/jdt/core/JavaCore.java
@@ -1019,6 +1019,7 @@
 	 * Add a compilation participant listener dynamically.  It is not necessary
 	 * to call this for listeners registered with the compilationParticipants
 	 * extension point.
+	 * 
 	 * @param icp the listener
 	 * @param eventMask the set of events for which the listener will be notified,
 	 * built by ORing together values from CompilationParticipantEvent.
@@ -1534,15 +1535,20 @@
 	 * listeners that have requested notification of at least one of
 	 * the events in the flags mask.
 	 * The first time this is called, it loads listeners from plugins,
-	 * which may cause plugins to be loaded.  If this is called on
-	 * multiple threads simultaneously, or if loading a plugin causes
-	 * this to be reentered, it may return an incomplete list of listeners,
-	 * but it is guaranteed not to crash or deadlock.
+	 * which may cause plugins to be loaded.  
+	 * 
+	 * <p>
+	 * Note that a deadlock situation can occur if a plugin's <code>start()</code> 
+	 * method blocks on a thread that calls <code>getCompilationParticipants()</code>.  
+	 * See <code>JavaModelManager.CompilationParticipants.getCompilationParticipants()</code>
+	 * for a complete description of the circumstances under which this deadlock can occur.
+	 * 
 	 * @param eventMask an ORed combination of values from ICompilationParticipant.
 	 * @return an immutable list of ICompilationParticipant.
+	 * @see JavaModelManager.CompilationParticipants#getCompilationParticipants
 	 */
 	public static List getCompilationParticipants(int eventMask) {
-		return JavaModelManager.getJavaModelManager().getCompilationParticipants().get(eventMask);
+		return JavaModelManager.getJavaModelManager().getCompilationParticipants().getCompilationParticipants(eventMask);
 	}
 	
 	/**
diff --git a/model/org/eclipse/jdt/internal/core/CompilationUnit.java b/model/org/eclipse/jdt/internal/core/CompilationUnit.java
index d0a6af5..b7136bb 100644
--- a/model/org/eclipse/jdt/internal/core/CompilationUnit.java
+++ b/model/org/eclipse/jdt/internal/core/CompilationUnit.java
@@ -16,9 +16,7 @@
 import org.eclipse.core.runtime.*;
 import org.eclipse.jdt.core.*;
 import org.eclipse.jdt.core.compiler.CharOperation;
-import org.eclipse.jdt.core.compiler.ICompilationParticipant;
 import org.eclipse.jdt.core.compiler.IProblem;
-import org.eclipse.jdt.core.compiler.PostReconcileCompilationEvent;
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.internal.compiler.ASTVisitor;
 import org.eclipse.jdt.internal.compiler.IProblemFactory;
@@ -27,10 +25,8 @@
 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
 import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
 import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
-import org.eclipse.jdt.internal.core.JavaModelManager.PerWorkingCopyInfo;
 import org.eclipse.jdt.internal.core.util.MementoTokenizer;
 import org.eclipse.jdt.internal.core.util.Util;
-
 /**
  * @see ICompilationUnit
  */
@@ -44,19 +40,7 @@
 	
 	protected String name;
 	public WorkingCopyOwner owner;
-	
-	/** 
-	 * indicates if a NoOpProblemRequestor should be used when 
-	 *  calling getPerWorkingCopyInfo
-	 */
-	private boolean useNoOpProblemRequestor = false;
 
-	/**
-	 * indicates if we should treat this working copy as inconsistent
-	 * even if there wasn't a change in the underlying buffer.
-	 */
-	private boolean forceInconsistent = false;
-	
 	
 /**
  * Constructs a handle to a compilation unit with the given name in the
@@ -773,12 +757,8 @@
  * Returns the per working copy info for the receiver, or null if none exist.
  * Note: the use count of the per working copy info is NOT incremented.
  */
-public JavaModelManager.PerWorkingCopyInfo getPerWorkingCopyInfo() {
-	
-	if ( useNoOpProblemRequestor )
-		return new PerWorkingCopyInfo( this, NO_OP_PROBLEM_REQUESTOR );
-	else
-		return JavaModelManager.getJavaModelManager().getPerWorkingCopyInfo(this, false/*don't create*/, false/*don't record usage*/, null/*no problem requestor needed*/);
+public JavaModelManager.PerWorkingCopyInfo getPerWorkingCopyInfo() {	
+	return JavaModelManager.getJavaModelManager().getPerWorkingCopyInfo(this, false/*don't create*/, false/*don't record usage*/, null/*no problem requestor needed*/);
 }
 
 /*
@@ -921,10 +901,7 @@
  * @see IOpenable#isConsistent()
  */
 public boolean isConsistent() {
-	if ( forceInconsistent )
-		return false;
-	else	
-		return JavaModelManager.getJavaModelManager().getElementsOutOfSynchWithBuffers().get(this) == null;
+	return JavaModelManager.getJavaModelManager().getElementsOutOfSynchWithBuffers().get(this) == null;
 }
 /**
  * 
@@ -1111,54 +1088,8 @@
 	
 	
 	ReconcileWorkingCopyOperation op = null;
-	List l = JavaCore.getCompilationParticipants(ICompilationParticipant.POST_RECONCILE_EVENT);	
-	if ( l != null && l.size() > 0 ) {	
-		// we always need an AST to pass into compilation participants
-		op = new ReconcileWorkingCopyOperation(this, true /*createAST*/, AST.JLS3, forceProblemDetection, workingCopyOwner);	
-
-		// TODO:  try not to use these two try-catch blocks here...
-		try {
-		    try {
-				useNoOpProblemRequestor = true;
-				forceInconsistent = ! this.isConsistent();
-				op.runOperation(monitor);
-			}
-			finally {
-				useNoOpProblemRequestor = false;
-			}
-						
-			Iterator it = l.iterator();
-			while ( it.hasNext() ) {
-				ICompilationParticipant p = (ICompilationParticipant)it.next();
-				PostReconcileCompilationEvent prce = new PostReconcileCompilationEvent( this, op.ast, getJavaProject() ); 
-				p.notify( prce );
-				// TODO: do something with the result of notify...
-			}
-
-			// save off the original AST
-			org.eclipse.jdt.core.dom.CompilationUnit originalAst = op.ast;
-
-			// if there were ICompilationParticipants, we will reconcile again and return the ast from the second reconcile
-			// this causes the client to receive an AST that is correct with respect to any changes that occurred in the 
-			// ast as a result of files being added by compilation participants.  This second reconcile also causes any 
-			// problems to be reported to the correct problemRequestor, instead of the no-op problemRequestor. 
-			op = new ReconcileWorkingCopyOperation(this, createAST, astLevel, forceProblemDetection, workingCopyOwner);
-			op.runOperation(monitor);
-			
-			// if the original AST was null, assume that the working copy was consistent.
-			// and return null. 
-			if ( originalAst == null )
-				return null;	
-		}
-		finally {
-			forceInconsistent = false;
-		}
-	}
-	else 
-	{
-		op = new ReconcileWorkingCopyOperation(this, createAST, astLevel, forceProblemDetection, workingCopyOwner);
-		op.runOperation(monitor);
-	}
+	op = new ReconcileWorkingCopyOperation(this, createAST, astLevel, forceProblemDetection, workingCopyOwner);
+	op.runOperation(monitor);
 
 	return op.ast;
 }
@@ -1236,14 +1167,4 @@
 	((CompilationUnitElementInfo) getElementInfo()).timestamp = timeStamp;
 }
 
-
-
-private final static NoOpProblemRequestor  NO_OP_PROBLEM_REQUESTOR = new NoOpProblemRequestor();
-private final static class NoOpProblemRequestor implements IProblemRequestor {
-	public void    acceptProblem(IProblem problem) { /* no-op */ }
-	public void    beginReporting()                { /* no-op */ }
-	public void    endReporting()                  { /* no-op */ }
-	public boolean isActive()                      { return true; } 
-}
-
 }
diff --git a/model/org/eclipse/jdt/internal/core/JavaModelManager.java b/model/org/eclipse/jdt/internal/core/JavaModelManager.java
index e76004e..26fd646 100644
--- a/model/org/eclipse/jdt/internal/core/JavaModelManager.java
+++ b/model/org/eclipse/jdt/internal/core/JavaModelManager.java
@@ -174,14 +174,24 @@
 		 * listeners that have requested notification of at least one of
 		 * the events in the flags mask.
 		 * The first time this is called, it loads listeners from plugins,
-		 * which may cause plugins to be loaded.  If this is called on
-		 * multiple threads simultaneously, or if loading a plugin causes
-		 * this to be reentered, it may return an incomplete list of listeners,
-		 * but it is guaranteed not to crash or deadlock.
+		 * which may cause plugins to be loaded.  
+		 * 
+		 * <p>
+		 * The initialization of ICompilationParticipants  is synchronized.  A deadlock may 
+		 * occur if all of the following conditions are true:  
+		 *  
+		 *  <li>A plugin defines <code>ICompilationParticipants</code></li>
+		 *  <li>That plugin's <code>start()</code> method spawns a thread which causes 
+		 *  <code>getCompilationParticipants()</code> to be invoked</li>
+		 *  <li>The <code>start()</code> method blocks waiting for the spawned thread to complete.</li> 
+		 *  
+		 *  Note that a build and reconcile operations will cause <code>getCompilationParticipants()</code> to 
+		 *  be called.
+		 *  
 		 * @param eventMask an ORed combination of values from ICompilationParticipant.
 		 * @return an immutable list of ICompilationParticipant.
 		 */
-		public List get(int eventMask) {
+		public List getCompilationParticipants(int eventMask) {
 			initPlugins();
 			List filteredICPs = new ArrayList();
 			Iterator it;
@@ -204,16 +214,15 @@
 			return Collections.unmodifiableList(filteredICPs);
 		}
 		
-		private void initPlugins() {
-			synchronized (this) {
-				if (null != pluginCPs) {
-					return;
-				}
-				pluginCPs = new HashMap();
+		private synchronized void initPlugins() {
+			if (null != pluginCPs) {
+				return;
 			}
+			pluginCPs = new HashMap();
+
 			IExtensionPoint extension = Platform.getExtensionRegistry().getExtensionPoint(
 					JavaCore.PLUGIN_ID, COMPILATION_PARTICIPANT_EXTPOINT_ID);
-			if (extension == null)
+			if (extension == null) 
 				return;
 			IExtension[] extensions = extension.getExtensions();
 			for(int iExtension = 0; iExtension < extensions.length; iExtension++){
diff --git a/model/org/eclipse/jdt/internal/core/ReconcileWorkingCopyOperation.java b/model/org/eclipse/jdt/internal/core/ReconcileWorkingCopyOperation.java
index 3cec2ff..75a069d 100644
--- a/model/org/eclipse/jdt/internal/core/ReconcileWorkingCopyOperation.java
+++ b/model/org/eclipse/jdt/internal/core/ReconcileWorkingCopyOperation.java
@@ -10,22 +10,25 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.core;
 
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 
 import org.eclipse.core.runtime.OperationCanceledException;
 import org.eclipse.jdt.core.*;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.compiler.ICompilationParticipant;
+import org.eclipse.jdt.core.compiler.PostReconcileCompilationEvent;
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
-import org.eclipse.jdt.internal.core.util.Messages;
+import org.eclipse.jdt.internal.core.util.Util;
 
 /**
  * Reconcile a working copy and signal the changes through a delta.
  */
 public class ReconcileWorkingCopyOperation extends JavaModelOperation {
-	public static boolean PERF = false;
-	
+		
 	boolean createAST;
 	int astLevel;
 	boolean forceProblemDetection;
@@ -47,9 +50,11 @@
 		if (this.progressMonitor != null){
 			if (this.progressMonitor.isCanceled()) 
 				throw new OperationCanceledException();
-			this.progressMonitor.beginTask(Messages.element_reconciling, 2); 
+			this.progressMonitor.beginTask(Util.bind("element.reconciling"), 2); //$NON-NLS-1$
 		}
 	
+		notifyCompilationParticipants();
+		
 		CompilationUnit workingCopy = getWorkingCopy();
 		boolean wasConsistent = workingCopy.isConsistent();
 		try {
@@ -120,5 +125,22 @@
 		return status;
 	}
 
+	private void notifyCompilationParticipants() {
+		
+		List l = JavaCore.getCompilationParticipants(ICompilationParticipant.POST_RECONCILE_EVENT);	
 
+		CompilationUnit workingCopy = getWorkingCopy();
+		
+		// we want to go through ICompilationParticipant only if there are participants
+		// and the compilation unit is not consistent or we are forcing problem detection
+		if ( ( l != null && l.size() > 0 ) && ( !workingCopy.isConsistent() || forceProblemDetection )) {	
+			PostReconcileCompilationEvent prce = new PostReconcileCompilationEvent( workingCopy, workingCopy.getJavaProject() );
+			Iterator it = l.iterator();
+			while ( it.hasNext() ) {
+				ICompilationParticipant p = (ICompilationParticipant)it.next(); 
+				p.notify( prce );
+				// TODO: do something with the result of notify...
+			}
+		}
+	}
 }
diff --git a/model/org/eclipse/jdt/internal/core/builder/AbstractImageBuilder.java b/model/org/eclipse/jdt/internal/core/builder/AbstractImageBuilder.java
index d2ff2cb..d941f25 100644
--- a/model/org/eclipse/jdt/internal/core/builder/AbstractImageBuilder.java
+++ b/model/org/eclipse/jdt/internal/core/builder/AbstractImageBuilder.java
@@ -226,15 +226,13 @@
 /**
  *  notify the ICompilationParticipants of the pre-build event 
  */
-private Set notifyCompilationParticipants(ICompilationUnit[] sourceUnits) {
+private  void notifyCompilationParticipants(ICompilationUnit[] sourceUnits, Set newFiles, Set deletedFiles, Map extraDependencies ) {
 	List cps = JavaCore
 			.getCompilationParticipants( ICompilationParticipant.PRE_BUILD_EVENT );
 	if ( cps.isEmpty() ) {
-		return Collections.EMPTY_SET;
+		return;
 	}
 
-	extraDependencyMap = new HashMap();
-	
 	IFile[] files = new IFile[sourceUnits.length];
 	for ( int i = 0; i < files.length; i++ ) {
 		if ( sourceUnits[i] instanceof SourceFile ) {
@@ -247,7 +245,6 @@
 	PreBuildCompilationEvent pbce = new PreBuildCompilationEvent( files,
 			javaBuilder.javaProject );
 
-	Set newFiles = new HashSet();
 	java.util.Iterator it = cps.iterator();
 	while ( it.hasNext() ) {
 		ICompilationParticipant p = ( ICompilationParticipant ) it.next();
@@ -262,10 +259,25 @@
 					newFiles.add( f[i] );
 			}
 			
-			mergeMaps( pbcr.getNewDependencies(), extraDependencyMap );
+			f = pbcr.getDeletedFiles();
+			if ( f != null ) { 
+				for ( int i = 0; i < f.length; i++ ) 
+					deletedFiles.add( f[i] );
+			}
+			
+			mergeMaps( pbcr.getNewDependencies(), extraDependencies );
 		}
 	}
-	return newFiles;
+	
+	if ( newFiles.size() > 0 ) {
+		Set newFiles_2 = new HashSet();
+		Set deletedFiles_2 = new HashSet();
+		ICompilationUnit[] newFileArray = ifileSet2SourceFileArray( newFiles );
+		notifyCompilationParticipants( newFileArray, newFiles_2, deletedFiles_2, extraDependencies );
+		newFiles.addAll( newFiles_2 );
+		deletedFiles.addAll( deletedFiles_2 );
+	}
+	
 }	
 
 /** 
@@ -299,27 +311,80 @@
  */
 protected ClasspathMultiDirectory getSourceLocationForFile(IFile file) {
 	ClasspathMultiDirectory md = null;
-	if ( file.exists() ) {
-		md = sourceLocations[0];
-		if ( sourceLocations.length > 1 ) {
-			IPath sourceFileFullPath = file.getFullPath();
-			for ( int j = 0, m = sourceLocations.length; j < m; j++ ) {
-				if ( sourceLocations[j].sourceFolder.getFullPath()
-						.isPrefixOf( sourceFileFullPath ) ) {
-					md = sourceLocations[j];
-					if ( md.exclusionPatterns == null
-							&& md.inclusionPatterns == null )
-						break;
-					if ( !Util.isExcluded( file, md.inclusionPatterns,
-							md.exclusionPatterns ) )
-						break;
-				}
+	md = sourceLocations[0];
+	if ( sourceLocations.length > 1 ) {
+		IPath sourceFileFullPath = file.getFullPath();
+		for ( int j = 0, m = sourceLocations.length; j < m; j++ ) {
+			if ( sourceLocations[j].sourceFolder.getFullPath()
+					.isPrefixOf( sourceFileFullPath ) ) {
+				md = sourceLocations[j];
+				if ( md.exclusionPatterns == null
+						&& md.inclusionPatterns == null )
+					break;
+				if ( !Util.isExcluded( file, md.inclusionPatterns,
+						md.exclusionPatterns ) )
+					break;
 			}
 		}
 	}
 	return md;
 }
 
+/**
+ * copies IFile entries in a Set<IFile> into SourceFile entries into a SourceFile[]. 
+ * Copying starts at the specified start position.
+ */
+private void ifileSet2SourceFileArray( Set ifiles, SourceFile[] sourceFiles, int start ) {
+	Iterator it = ifiles.iterator();
+	while ( it.hasNext() ) {
+		IFile f = ( IFile ) it.next();
+		sourceFiles[start++] = new SourceFile( f, getSourceLocationForFile( f ) );
+	}	
+}
+
+/**
+ *  Given a Set<IFile>, this method returns a SourceFile[] where each entry 
+ *  in the array corresponds to an entry in the set.
+ */
+private SourceFile[] ifileSet2SourceFileArray( Set ifiles ) {
+	SourceFile[] sf = new SourceFile[ ifiles.size() ];
+	ifileSet2SourceFileArray( ifiles, sf, 0 );
+	return sf;
+}
+
+private SourceFile[] updateSourceUnits( SourceFile[] units, Set newFiles, Set deletedFiles ) {
+	if ( newFiles.size() == 0 && deletedFiles.size() == 0 )
+		return units;
+	else if ( deletedFiles.size() == 0 ) {
+		// files have only been added
+		SourceFile[] newUnits = new SourceFile[ units.length + newFiles.size() ];
+		System.arraycopy( units, 0, newUnits, 0, units.length );
+		ifileSet2SourceFileArray( newFiles, newUnits, units.length );
+		return newUnits;
+	}
+	else {
+		// files have been added & deleted.  Deal with deleted files first.  If 
+		// someone reports that a file has been added and deleted, then it will be 
+		// added.
+		HashSet unitSet = new HashSet();
+		for ( int i=0; i<units.length; i++ )
+			unitSet.add( units[i].getFile() );
+		Iterator it = deletedFiles.iterator();
+		while ( it.hasNext() )	{
+			IFile f = (IFile) it.next();
+			if ( unitSet.contains( f ) )
+				unitSet.remove( f );
+			handleFileDeletedByCompilationParticipant( f );
+		}
+		unitSet.addAll( newFiles );
+		return ifileSet2SourceFileArray( unitSet );
+	}
+}
+
+protected void handleFileDeletedByCompilationParticipant( IFile f )
+{
+	// noop
+}
 
 void compile(SourceFile[] units, SourceFile[] additionalUnits) {
 	if (units.length == 0) return;
@@ -344,20 +409,14 @@
 	try {
 		inCompiler = true;
 		
-		// notify compilation participants, and add any new files created
-		// by the participants into the set of files being compiled. 
-		Set newFiles = notifyCompilationParticipants( units );
-		if ( newFiles != null && newFiles.size() > 0 ) {
-				SourceFile[] newUnits = new SourceFile[units.length + newFiles.size()];
-				System.arraycopy( units, 0, newUnits, 0, units.length );
-				Iterator it = newFiles.iterator();
-				int idx = units.length;
-				while ( it.hasNext() ) {
-					IFile f = ( IFile ) it.next();
-					newUnits[idx++] = new SourceFile( f, getSourceLocationForFile( f ) );
-				}
-				units = newUnits;
-		}
+		// notify compilation participants, 
+		Set newFiles = new HashSet();
+		Set deletedFiles = new HashSet();
+		extraDependencyMap = new HashMap();
+		notifyCompilationParticipants( units, newFiles, deletedFiles, extraDependencyMap );
+
+		// update units array with the new & deleted files
+		units = updateSourceUnits( units, newFiles, deletedFiles );
 		
 		compiler.compile(units);
 		
@@ -397,33 +456,21 @@
 	char[][] simpleRefs = result.simpleNameReferences;
 	
 	if ( extraDependencyMap != null && extraDependencyMap.size() > 0 ) {
-		//IFile f = javaBuilder.currentProject.getFile( new String( result.fileName ));
 		IFile f = ResourcesPlugin.getWorkspace().getRoot().getFile( new Path( new String( result.fileName ) ));
 		Set s  = (Set)extraDependencyMap.get( f );
 		if ( s != null && s.size() > 0 ) {
-			// Set<String>
-			Set simpleNameSet = new HashSet();
-			Set qualifiedNameSet = new HashSet();
+			NameSet simpleNameSet = new NameSet( simpleRefs.length + s.size() );
+			QualifiedNameSet qualifiedNameSet = new QualifiedNameSet( qualifiedRefs.length + s.size() );
 
 			//
 			// add in all of the existing refs to the sets to filter out duplicates
 			//
-			for ( int i = 0; i< simpleRefs.length; i++ ) {
-				simpleNameSet.add( new String( simpleRefs[i] ) );
-			}
-			
-			for ( int i = 0; i< qualifiedRefs.length; i++ ) {
-				
-				StringBuffer sb = new StringBuffer();
-				int len = qualifiedRefs[i].length - 1;
-				for ( int j = 0; j < len; j++ ) {
-					sb.append( qualifiedRefs[i][j] );
-					sb.append( "." );  //$NON-NLS-1$
-				}
-				sb.append( qualifiedRefs[i][len] );
-				qualifiedNameSet.add( sb.toString() );
-			}
-			
+			for ( int i = 0; i< simpleRefs.length; i++ ) 
+				simpleNameSet.add( simpleRefs[i] );
+
+			for ( int i = 0; i< qualifiedRefs.length; i++ ) 
+				qualifiedNameSet.add( qualifiedRefs[i] );
+
 			//
 			// get all of the the parts of the new dependencies into sets
 			// for  a dependency "a.b.c.d", we want the qualifiedNameSet to include
@@ -432,47 +479,34 @@
 			//
 			Iterator it = s.iterator();
 			while ( it.hasNext() ) {
-				String rpart = (String) it.next();
-				int idx = rpart.indexOf( '.', 0 );
-				while ( idx > -1 ) {
-					qualifiedNameSet.add( rpart );
-					String lpart = rpart.substring( 0, idx );
-					rpart = rpart.substring( idx + 1, rpart.length() );
-					simpleNameSet.add( lpart );
-					idx = rpart.indexOf( '.', idx + 1 );
+				char[] array = ((String) it.next() ).toCharArray();
+				char[][] parts = CharOperation.splitOn('.', array );
+				for ( int i = 0; i<parts.length; i++ )
+					simpleNameSet.add( parts[i] );
+				
+				for( int i = parts.length - 1; i > 0; --i ) {
+					qualifiedNameSet.add( parts );
+					parts = CharOperation.subarray( parts, 0, i );
 				}
-				simpleNameSet.add( rpart );
 			}
-
+	
 			//
-			// now turn the set of simple names into a char[][]
+			// strip out any null entries in the arrays retrieved from the sets.
 			//
-			char[][] newSimpleNameArray = new char[ simpleNameSet.size() ][];
-			it = simpleNameSet.iterator(); 
-			int i = 0;
-			while ( it.hasNext() ) {
-				String str = (String) it.next();
-				newSimpleNameArray[i] = str.toCharArray();
-				i++;
-			}
+			simpleRefs = new char[ simpleNameSet.elementSize][];
+			char[][] names = simpleNameSet.names;
+			int j = 0;
+			for ( int i = 0; i<names.length; i++ )
+				if ( names[i] != null)
+					simpleRefs[j++] = names[i];
 			
-			//
-			//  turn the set of qnames into a char[][][]
-			//
-			char[][][] newQualifiedNameArray = new char[ qualifiedNameSet.size() ][][];
-			it = qualifiedNameSet.iterator();
-			i = 0;
-			while ( it.hasNext() ) {
-				String str = (String) it.next();
-				String[] parts = str.split( "\\." ); //$NON-NLS-1$
-				newQualifiedNameArray[i] = new char[ parts.length ][];
-				for ( int j = 0; j < parts.length; j++ ) {
-					newQualifiedNameArray[i][j] = parts[j].toCharArray();	
-				}
-				i++;
-			}
-			qualifiedRefs = newQualifiedNameArray;
-			simpleRefs = newSimpleNameArray;
+			qualifiedRefs = new char[ qualifiedNameSet.elementSize ][][];
+			j = 0;
+			char[][][] qnames = qualifiedNameSet.qualifiedNames;
+			for ( int i = 0; i< qnames.length; i++ )
+				if ( qnames[i] != null )
+					qualifiedRefs[j++] = qnames[i];
+			
 		}
 	}
 		
diff --git a/model/org/eclipse/jdt/internal/core/builder/BatchImageBuilder.java b/model/org/eclipse/jdt/internal/core/builder/BatchImageBuilder.java
index b623720..e026e78 100644
--- a/model/org/eclipse/jdt/internal/core/builder/BatchImageBuilder.java
+++ b/model/org/eclipse/jdt/internal/core/builder/BatchImageBuilder.java
@@ -14,7 +14,8 @@
 import org.eclipse.core.runtime.*;
 
 import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.internal.core.util.Messages;
+import org.eclipse.jdt.core.compiler.ICompilationParticipant;
+import org.eclipse.jdt.core.compiler.CleanCompilationEvent;
 import org.eclipse.jdt.internal.core.util.Util;
 
 import java.util.*;
@@ -31,12 +32,12 @@
 		System.out.println("FULL build"); //$NON-NLS-1$
 
 	try {
-		notifier.subTask(Messages.build_cleaningOutput); 
+		notifier.subTask(Util.bind("build.cleaningOutput")); //$NON-NLS-1$
 		JavaBuilder.removeProblemsAndTasksFor(javaBuilder.currentProject);
 		cleanOutputFolders(true);
 		notifier.updateProgressDelta(0.1f);
 
-		notifier.subTask(Messages.build_analyzingSources); 
+		notifier.subTask(Util.bind("build.analyzingSources")); //$NON-NLS-1$
 		ArrayList sourceFiles = new ArrayList(33);
 		addAllSourceFiles(sourceFiles);
 		notifier.updateProgressDelta(0.15f);
@@ -98,13 +99,33 @@
 	}
 }
 
+private void notifyCompilationParticipantsOfClean()
+{
+	List cps = JavaCore.getCompilationParticipants( 
+			ICompilationParticipant.CLEAN_EVENT );
+		
+	if ( cps.isEmpty() ) 
+		return;
+
+	CleanCompilationEvent pbce = new CleanCompilationEvent(	javaBuilder.javaProject );
+
+	java.util.Iterator it = cps.iterator();
+	while ( it.hasNext() ) {
+		ICompilationParticipant p = ( ICompilationParticipant ) it.next();
+		p.notify( pbce );
+	}
+}
+	
 protected void cleanOutputFolders(boolean copyBack) throws CoreException {
 	boolean deleteAll = JavaCore.CLEAN.equals(
 		javaBuilder.javaProject.getOption(JavaCore.CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER, true));
 	if (deleteAll) {
+		
+		notifyCompilationParticipantsOfClean();
+		
 		ArrayList visited = new ArrayList(sourceLocations.length);
 		for (int i = 0, l = sourceLocations.length; i < l; i++) {
-			notifier.subTask(Messages.build_cleaningOutput); 
+			notifier.subTask(Util.bind("build.cleaningOutput")); //$NON-NLS-1$
 			ClasspathMultiDirectory sourceLocation = sourceLocations[i];
 			if (sourceLocation.hasIndependentOutputFolder) {
 				IContainer outputFolder = sourceLocation.binaryFolder;
@@ -189,7 +210,7 @@
 	// When, if ever, does a builder need to copy resources files (not .java or .class) into the output folder?
 	// If we wipe the output folder at the beginning of the build then all 'extra' resources must be copied to the output folder.
 
-	notifier.subTask(Messages.build_copyingResources); 
+	notifier.subTask(Util.bind("build.copyingResources")); //$NON-NLS-1$
 	final int segmentCount = sourceLocation.sourceFolder.getFullPath().segmentCount();
 	final char[][] exclusionPatterns = sourceLocation.exclusionPatterns;
 	final char[][] inclusionPatterns = sourceLocation.inclusionPatterns;
@@ -219,7 +240,7 @@
 								createProblemFor(
 									resource,
 									null,
-									Messages.bind(Messages.build_duplicateResource, (new String[] {id})), 
+									Util.bind("build.duplicateResource", id), //$NON-NLS-1$
 									javaBuilder.javaProject.getOption(JavaCore.CORE_JAVA_BUILD_DUPLICATE_RESOURCE, true));
 								return false;
 							}
diff --git a/model/org/eclipse/jdt/internal/core/builder/IncrementalImageBuilder.java b/model/org/eclipse/jdt/internal/core/builder/IncrementalImageBuilder.java
index 653bb23..60e0538 100644
--- a/model/org/eclipse/jdt/internal/core/builder/IncrementalImageBuilder.java
+++ b/model/org/eclipse/jdt/internal/core/builder/IncrementalImageBuilder.java
@@ -20,7 +20,6 @@
 import org.eclipse.jdt.internal.compiler.problem.*;
 import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
 import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
-import org.eclipse.jdt.internal.core.util.Messages;
 import org.eclipse.jdt.internal.core.util.Util;
 
 import java.io.*;
@@ -71,7 +70,7 @@
 	try {
 		resetCollections();
 
-		notifier.subTask(Messages.build_analyzingDeltas); 
+		notifier.subTask(Util.bind("build.analyzingDeltas")); //$NON-NLS-1$
 		IResourceDelta sourceDelta = (IResourceDelta) deltas.get(javaBuilder.currentProject);
 		if (sourceDelta != null)
 			if (!findSourceFiles(sourceDelta)) return false;
@@ -90,7 +89,7 @@
 		}
 		notifier.updateProgressDelta(0.10f);
 
-		notifier.subTask(Messages.build_analyzingSources); 
+		notifier.subTask(Util.bind("build.analyzingSources")); //$NON-NLS-1$
 		addAffectedSourceFiles();
 		notifier.updateProgressDelta(0.05f);
 
@@ -242,6 +241,51 @@
 	return true;
 }
 
+protected void handleFileDeletedByCompilationParticipant( IFile f )
+{
+	try
+	{
+	ClasspathMultiDirectory md = getSourceLocationForFile( f );
+	int segmentCount = md.sourceFolder.getFullPath().segmentCount();
+	IPath typePath = f.getFullPath().removeFirstSegments(segmentCount).removeFileExtension();
+	String typeLocator = f.getProjectRelativePath().toString();
+	char[][] definedTypeNames = newState.getDefinedTypeNamesFor(typeLocator);
+	if (definedTypeNames == null) { // defined a single type matching typePath
+		removeClassFile(typePath, md.binaryFolder);
+		/*
+		if ((sourceDelta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
+			// remove problems and tasks for a compilation unit that is being moved (to another package or renamed)
+			// if the target file is a compilation unit, the new cu will be recompiled
+			// if the target file is a non-java resource, then markers are removed
+			// see bug 2857
+			IResource movedFile = javaBuilder.workspaceRoot.getFile(sourceDelta.getMovedToPath());
+			JavaBuilder.removeProblemsAndTasksFor(movedFile); 
+		}
+		*/
+	} else {
+		if (JavaBuilder.DEBUG)
+			System.out.println("Found removed source file " + typePath.toString()); //$NON-NLS-1$
+		addDependentsOf(typePath, true); // add dependents of the source file since it may be involved in a name collision
+		if (definedTypeNames.length > 0) { // skip it if it failed to successfully define a type
+			IPath packagePath = typePath.removeLastSegments(1);
+			for (int i = 0, l = definedTypeNames.length; i < l; i++)
+				removeClassFile(packagePath.append(new String(definedTypeNames[i])), md.binaryFolder);
+		}
+	}
+	newState.removeLocator(typeLocator);
+	}
+	catch ( CoreException ce )
+	{
+		// TODO:  handle this exception
+		ce.printStackTrace();
+	}
+	catch( Exception e )
+	{
+		e.printStackTrace();
+	}
+}
+
+
 protected void findAffectedSourceFiles(IResourceDelta binaryDelta, int segmentCount, StringSet structurallyChangedTypes) {
 	// When a package becomes a type or vice versa, expect 2 deltas,
 	// one on the folder & one on the class file
diff --git a/search/org/eclipse/jdt/core/search/SearchPattern.java b/search/org/eclipse/jdt/core/search/SearchPattern.java
index 84f57f6..cd5666e 100644
--- a/search/org/eclipse/jdt/core/search/SearchPattern.java
+++ b/search/org/eclipse/jdt/core/search/SearchPattern.java
@@ -802,7 +802,9 @@
 	 * @return a search pattern on the given string pattern, or <code>null</code> if the string pattern is ill-formed
 	 */
 	public static SearchPattern createPattern(String stringPattern, int searchFor, int limitTo, int matchRule) {
-		if (stringPattern == null || stringPattern.length() == 0) return null;
+		// Null string not allowed, empty string only allowed for Package seach (default package)
+		if (stringPattern == null || stringPattern.length() == 0 && searchFor != IJavaSearchConstants.PACKAGE) 
+			return null;
 
 		// Ignore additional nature flags
 		limitTo &= ~(IJavaSearchConstants.IGNORE_DECLARING_TYPE+IJavaSearchConstants.IGNORE_RETURN_TYPE);
@@ -1087,10 +1089,8 @@
 				} catch (JavaModelException e) {
 					return null;
 				}
-				IType declaringClass = method.getDeclaringType();
-				if (ignoreDeclaringType) {
-					if (isConstructor) declaringSimpleName = declaringClass.getElementName().toCharArray();
-				} else {
+				if (!ignoreDeclaringType) {
+					IType declaringClass = method.getDeclaringType();
 					declaringSimpleName = declaringClass.getElementName().toCharArray();
 					declaringQualification = declaringClass.getPackageFragment().getElementName().toCharArray();
 					char[][] enclosingNames = enclosingTypeNames(declaringClass);