diff --git a/buildnotes_jdt-core.html b/buildnotes_jdt-core.html
index 14b7e4e..9458788 100644
--- a/buildnotes_jdt-core.html
+++ b/buildnotes_jdt-core.html
@@ -97,7 +97,11 @@
 </ul>
 
 <h3>Problem Reports Fixed</h3>
-<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=76880">76880</a>
+<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=74851">74851</a>
+[1.5] enum errors in 3.1M1
+<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=75134">75134</a>
+[1.5] Type mismatch error generated
+<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=76880">76880</a>
 Unable to resolve enum type
 <br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=76766">76766</a>
 [1.5] Option to format empty enum declaration or empty enum constant body has no effect
diff --git a/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java b/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
index 2076364..bca8299 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
@@ -199,8 +199,8 @@
 		}
 		if (unsafeWildcardInvocation) {
 		    scope.problemReporter().wildcardInvocation((ASTNode)invocationSite, receiverType, method, argumentTypes);
-		} else if (receiverType.isRawType() && method.hasSubstitutedParameters()) {
-		    scope.problemReporter().unsafeRawInvocation((ASTNode)invocationSite, receiverType, method);
+		} else if (!receiverType.isUnboundWildcard() && method.declaringClass.isRawType() && method.hasSubstitutedParameters()) {
+		    scope.problemReporter().unsafeRawInvocation((ASTNode)invocationSite, method);
 		}
 	}
 	public ASTNode concreteStatement() {
diff --git a/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java b/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java
index 367bcc4..745d613 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java
@@ -139,6 +139,12 @@
 				return null;
 			}
 			ReferenceBinding currentType = (ReferenceBinding) this.resolvedType;
+			if (qualifiedType == null) {
+				qualifiedType = currentType.enclosingType(); // if member type
+				if (qualifiedType != null && currentType.isStatic() && qualifiedType.isGenericType()) {
+					qualifiedType = scope.environment().createRawType(qualifiedType, qualifiedType.enclosingType());
+				}
+			}				
 			if (typeIsConsistent && currentType.isStatic() && qualifiedType != null && (qualifiedType.isParameterizedType() || qualifiedType.isGenericType())) {
 				scope.problemReporter().staticMemberOfParameterizedType(this, scope.createParameterizedType(currentType, null, qualifiedType));
 				typeIsConsistent = false;
diff --git a/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java b/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java
index 3a44879..2fdfc2e 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java
@@ -102,6 +102,13 @@
 				reportInvalidType(scope);
 				return null;
 			}
+			enclosingType = this.resolvedType.enclosingType(); // if member type
+			if (enclosingType != null) {
+				ReferenceBinding currentType = (ReferenceBinding) this.resolvedType;
+				if (currentType.isStatic() && enclosingType.isGenericType()) {
+					enclosingType = scope.environment().createRawType(enclosingType, enclosingType.enclosingType());
+				}
+			}
 		} else { // resolving member type (relatively to enclosingType)
 			this.resolvedType = scope.getMemberType(token, (ReferenceBinding)enclosingType.erasure());		    
 			if (!this.resolvedType.isValidBinding()) {
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java
index 0b637c2..bb2d2ba 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java
@@ -365,6 +365,8 @@
 				modifiers |= AccDeprecatedImplicitly;
 			if ((enclosingType.modifiers & AccInterface) != 0)
 				modifiers |= AccPublic;
+			if (sourceType.isEnum())
+				modifiers |= AccStatic;
 		} else if (sourceType.isLocalType()) {
 			if (sourceType.isAnonymousType()) {
 			    modifiers |= AccFinal;
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java
index 398829b..5cba9cc 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java
@@ -31,11 +31,8 @@
 	private ReferenceBinding enclosingType;
 	
 	public ParameterizedTypeBinding(ReferenceBinding type, TypeBinding[] arguments,  ReferenceBinding enclosingType, LookupEnvironment environment){
+
 		this.environment = environment;
-		if (type.isParameterizedType() && type.isMemberType()) { // fixup instance of parameterized member type, e.g. Map<K,V>.Entry + <A,B>
-			enclosingType = type.enclosingType(); // use enclosing from previously parameterized
-			type = (ReferenceBinding)type.erasure(); // connect to erasure of member type
-		}
 		initialize(type, arguments);
 		this.enclosingType = enclosingType; // never unresolved, never lazy per construction
 
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java
index 0243900..fbbc9eb 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java
@@ -314,19 +314,12 @@
 		depth++;
 	return depth;
 }
-/* Answer the receiver's enclosing type... null if the receiver is a top level type.
-*/
-
-public ReferenceBinding enclosingType() {
-	return null;
-}
 public final ReferenceBinding enclosingTypeAt(int relativeDepth) {
 	ReferenceBinding current = this;
 	while (relativeDepth-- > 0 && current != null)
 		current = current.enclosingType();
 	return current;
 }
-
 public int fieldCount() {
 	return fields().length;
 }
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java
index fefb9e2..0e32594 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java
@@ -62,6 +62,12 @@
 public int dimensions(){
 	return 0;
 }
+/* Answer the receiver's enclosing type... null if the receiver is a top level type.
+*/
+
+public ReferenceBinding enclosingType() {
+	return null;
+}
 public TypeBinding erasure() {
     return this;
 }
@@ -209,7 +215,12 @@
 public boolean isBoundParameterizedType() {
 	return (this.tagBits & TagBits.IsBoundParameterizedType) != 0;
 }
-
+/**
+ * Returns true if wildcard type of the form '?' (no bound)
+ */
+public boolean isUnboundWildcard() {
+	return false;
+}
 /**
  * Returns true if the type is a wildcard
  */
diff --git a/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java b/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java
index f0bbd1e..6f345df 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java
@@ -182,6 +182,13 @@
     /**
 	 * Returns true if the type is a wildcard
 	 */
+	public boolean isUnboundWildcard() {
+	    return this.kind == Wildcard.UNBOUND;
+	}
+	
+    /**
+	 * Returns true if the type is a wildcard
+	 */
 	public boolean isWildcard() {
 	    return true;
 	}
@@ -272,15 +279,15 @@
      */
     public ReferenceBinding[] superInterfaces() {
         if (this.superInterfaces == null) {
-			TypeBinding superType = null;
 			if (this.kind == Wildcard.EXTENDS) {
-				superType = this.bound;
+				if (this.bound.isInterface()) {
+					return new ReferenceBinding[]{ (ReferenceBinding)this.bound };
+				} else {
+					return NoSuperInterfaces;
+				}
 			} else if (this.typeVariable() != null) {
-				superType = this.typeVariable.firstBound; // TODO (philippe) shouldn't it retrieve variable superinterfaces ?
+				return this.typeVariable.superInterfaces();
 			}
-			this.superInterfaces = superType != null && superType.isInterface()
-				? new ReferenceBinding[] { (ReferenceBinding) superType }
-				: NoSuperInterfaces;
         }
         return this.superInterfaces;
     }
diff --git a/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java b/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
index ec0e593..62c0c45 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
+++ b/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
@@ -4499,19 +4499,19 @@
 		location.sourceStart,
 		location.sourceEnd);    
 }
-public void unsafeRawInvocation(ASTNode location, TypeBinding receiverType, MethodBinding method) {
-    if (method.isConstructor()) {
+public void unsafeRawInvocation(ASTNode location, MethodBinding rawMethod) {
+    if (rawMethod.isConstructor()) {
 		this.handle(
 			IProblem.UnsafeRawConstructorInvocation,
 			new String[] {
-				new String(receiverType.readableName()),
-				typesAsString(method.original().isVarargs(), method.original().parameters, false),
-				new String(receiverType.erasure().readableName()),
+				new String(rawMethod.declaringClass.readableName()),
+				typesAsString(rawMethod.original().isVarargs(), rawMethod.parameters, false),
+				new String(rawMethod.declaringClass.erasure().readableName()),
 			 }, 
 			new String[] {
-				new String(receiverType.shortReadableName()),
-				typesAsString(method.original().isVarargs(), method.original().parameters, true),
-				new String(receiverType.erasure().shortReadableName()),
+				new String(rawMethod.declaringClass.shortReadableName()),
+				typesAsString(rawMethod.original().isVarargs(), rawMethod.parameters, true),
+				new String(rawMethod.declaringClass.erasure().shortReadableName()),
 			 }, 
 			location.sourceStart,
 			location.sourceEnd);    
@@ -4519,16 +4519,16 @@
 		this.handle(
 			IProblem.UnsafeRawMethodInvocation,
 			new String[] {
-				new String(method.selector),
-				typesAsString(method.original().isVarargs(), method.original().parameters, false),
-				new String(receiverType.readableName()),
-				new String(receiverType.erasure().readableName()),
+				new String(rawMethod.selector),
+				typesAsString(rawMethod.original().isVarargs(), rawMethod.parameters, false),
+				new String(rawMethod.declaringClass.readableName()),
+				new String(rawMethod.declaringClass.erasure().readableName()),
 			 }, 
 			new String[] {
-				new String(method.selector),
-				typesAsString(method.original().isVarargs(), method.original().parameters, true),
-				new String(receiverType.shortReadableName()),
-				new String(receiverType.erasure().shortReadableName()),
+				new String(rawMethod.selector),
+				typesAsString(rawMethod.original().isVarargs(), rawMethod.parameters, true),
+				new String(rawMethod.declaringClass.shortReadableName()),
+				new String(rawMethod.declaringClass.erasure().shortReadableName()),
 			 }, 
 			location.sourceStart,
 			location.sourceEnd);    
diff --git a/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties b/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties
index 79c10e4..a93529f 100644
--- a/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties
+++ b/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties
@@ -145,8 +145,8 @@
 178 = The assignment to variable {0} has no effect
 179 = Possible accidental assignment in place of a comparison. A condition expression should not be reduced to an assignment
 180 = Unnecessary semicolon
-181 = Unnecessary cast to type {1} for expression of type {0}
-182 = Unnecessary cast to type {1} for expression of type {0}. It is already compatible with the argument type {2}
+181 = Unnecessary cast from {0} to {1}
+182 = Unnecessary cast from {0} to {1}. It is already compatible with the argument type {2}
 183 = The expression of type {0} is already an instance of type {1}
 184 = finally block does not complete normally
 185 = The declared exception {3} is not actually thrown by the method {1}({2}) from type {0}
@@ -167,7 +167,7 @@
 200 = Cannot use {0} in a static context 
 201 = Cannot make a static reference to the non-static method {1}({2}) from the type {0}
 202 = Cannot specify an array dimension after an empty dimension
-203 = Invalid cast type expression
+203 = Invalid cast expression
 204 = Syntax error on token "{0}", {1} expected
 205 = Syntax error on token "{0}", no accurate correction available
 206 = Invalid argument to operation ++/--
@@ -411,22 +411,22 @@
 527 = Method {0}({2}) has the same erasure {0}({3}) as another method in type {1}
 528 = Illegal forward reference to type parameter {0}
 529 = The type {0} is not an interface; it cannot be specified as a bounded parameter
-530 = Unsafe type operation: Should not invoke the constructor {0}({1}) of raw type {0}. References to generic type {2} should be parameterized
-531 = Unsafe type operation: Should not invoke the method {0}({1}) of raw type {2}. References to generic type {3} should be parameterized
-532 = Unsafe type operation: Should not convert expression of raw type {0} to type {1}. References to generic type {2} should be parameterized
+530 = Type safety: The constructor {0}({1}) belongs to the raw type {0}. References to generic type {2} should be parameterized
+531 = Type safety: The method {0}({1}) belongs to the raw type {2}. References to generic type {3} should be parameterized
+532 = Type safety: The expression of raw type {0} is converted to {1}. References to generic type {2} should be parameterized
 533 = Cannot use the type parameter {0} in a catch block
 534 = Cannot use the parameterized type {0} either in catch block or throws clause
 535 = Cannot create a generic array of {0}
-536 = Unsafe type operation: Should not assign expression of type {0} to the field {1} of raw type {2}. References to generic type {3} should be parameterized
+536 = Type safety: The field {1} from the raw type {2} is assigned a value of type {0}. References to generic type {3} should be parameterized
 537 = The type parameter {0} should not be bounded by the final type {1}. Final types cannot be further extended
 538 = Inconsistent classfile encountered: The undefined type parameter {0} is referenced from within {1}
-539 = The interface {2} cannot be implemented simultaneously with different arguments: {0} and {1}
+539 = The interface {2} cannot be implemented more than once with different arguments: {0} and {1}
 540 = Bound mismatch: The constructor {0}({1}) of type {2} is not applicable for the arguments ({3}). The wildcard parameter {5} has no lower bound, and may actually be more restrictive than argument {4}
 541 = Bound mismatch: The method {0}({1}) of type {2} is not applicable for the arguments ({3}). The wildcard parameter {5} has no lower bound, and may actually be more restrictive than argument {4}
 542 = Bound mismatch: Cannot assign expression of type {0} to wildcard type {1}. The wildcard type has no lower bound, and may actually be more restrictive than expression type
 543 = Bound mismatch: The generic method {0}({1}) of type {2} is not applicable for the arguments ({3}) since the type {4} is not a valid substitute for the bounded parameter <{5} extends {6}>
 544 = Bound mismatch: The generic constructor {0}({1}) of type {2} is not applicable for the arguments ({3}) since the type {4} is not a valid substitute for the bounded parameter <{5} extends {6}>
-545 = Unsafe type operation: The cast from {0} to parameterized type {1} will not check conformance of type arguments at runtime
+545 = Type safety: The cast from {0} to {1} will not check conformance of type arguments at runtime
 546 = Cannot perform instanceof check against parameterized type {0}. Use instead its raw form {1} since generic type information will be erased at runtime
 547 = Cannot perform instanceof check against type parameter {0}. Use instead its erasure {1} since generic type information will be erased at runtime
 548 = The method {0}({1}) of type {2} is not generic; it cannot be parameterized with arguments <{3}>
@@ -440,7 +440,7 @@
 556 = The type {1} cannot extend or implement {0}. A supertype may not specify any wildcard
 557 = The generic class {0} may not subclass java.lang.Throwable
 558 = Illegal class literal for the type parameter {0}
-559 = Unsafe type operation: The return type {0} of the method {1}({2}) of type {3} needs unchecked conversion to conform to the return type {4} of inherited method
+559 = Type safety: The return type {0} of the method {1}({2}) of type {3} needs unchecked conversion to conform to the return type {4} of inherited method
 560 = Name clash : The method {0}({1}) of type {2} has the same erasure as {0}({3}) of type {4} but does not override it
 561 = The member type {0}<{1}> must be qualified with a parameterized type, since it is not static
 562 = The member type {0} must be parameterized, since it is qualified with a parameterized type
diff --git a/eval/org/eclipse/jdt/internal/eval/CodeSnippetAllocationExpression.java b/eval/org/eclipse/jdt/internal/eval/CodeSnippetAllocationExpression.java
index 009fd91..18b8a14 100644
--- a/eval/org/eclipse/jdt/internal/eval/CodeSnippetAllocationExpression.java
+++ b/eval/org/eclipse/jdt/internal/eval/CodeSnippetAllocationExpression.java
@@ -207,7 +207,7 @@
 		}
 	}
 	if (allocatedType.isRawType() && this.binding.hasSubstitutedParameters()) {
-	    scope.problemReporter().unsafeRawInvocation(this, allocatedType, this.binding);
+	    scope.problemReporter().unsafeRawInvocation(this, this.binding);
 	}
 	return allocatedType;
 }