diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java
index 3c90929..8159393 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java
@@ -22,6 +22,8 @@
  *							bug 403147 - [compiler][null] FUP of bug 400761: consolidate interaction between unboxing, NPE, and deferred checking
  *     Jesper S Moller <jesper@selskabet.org> - Contributions for
  *							bug 378674 - "The method can be declared as static" is wrong
+ *     Till Brychcy - Contributions for
+ *     						bug 413460 - NonNullByDefault is not inherited to Constructors when accessed via Class File
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.ast;
 
@@ -30,6 +32,7 @@
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
 import org.eclipse.jdt.internal.compiler.codegen.*;
 import org.eclipse.jdt.internal.compiler.flow.*;
+import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
 import org.eclipse.jdt.internal.compiler.impl.Constant;
 import org.eclipse.jdt.internal.compiler.lookup.*;
 import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
@@ -535,6 +538,16 @@
 	if (!isDiamond && this.resolvedType.isParameterizedTypeWithActualArguments()) {
  		checkTypeArgumentRedundancy((ParameterizedTypeBinding) this.resolvedType, null, argumentTypes, scope);
  	}
+	final CompilerOptions compilerOptions = scope.compilerOptions();
+	if (compilerOptions.isAnnotationBasedNullAnalysisEnabled && (this.binding.tagBits & TagBits.IsNullnessKnown) == 0) {
+//{ObjectTeams: added 2nd arg:
+/* orig:
+		new ImplicitNullAnnotationVerifier(compilerOptions.inheritNullAnnotations)
+  :giro */
+		new ImplicitNullAnnotationVerifier(compilerOptions.inheritNullAnnotations, scope.environment())
+// SH}
+				.checkImplicitNullAnnotations(this.binding, null/*srcMethod*/, false, scope);
+	}
 //{ObjectTeams: may need to wrap the resolved type
     this.resolvedType = allocationType =
     	(ReferenceBinding)RoleTypeCreator.maybeWrapUnqualifiedRoleType(allocationType, scope, this);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java
index e999aa0..caf490e 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java
@@ -21,6 +21,8 @@
  *								bug 403147 - [compiler][null] FUP of bug 400761: consolidate interaction between unboxing, NPE, and deferred checking
  *     Jesper S Moller <jesper@selskabet.org> - Contributions for
  *								bug 378674 - "The method can be declared as static" is wrong
+ *     Till Brychcy - Contributions for
+ *     							bug 413460 - NonNullByDefault is not inherited to Constructors when accessed via Class File
  ******************************************************************************/
 package org.eclipse.jdt.internal.compiler.ast;
 
@@ -30,10 +32,12 @@
 import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
 import org.eclipse.jdt.internal.compiler.flow.FlowContext;
 import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
+import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
 import org.eclipse.jdt.internal.compiler.impl.Constant;
 import org.eclipse.jdt.internal.compiler.lookup.Binding;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
+import org.eclipse.jdt.internal.compiler.lookup.ImplicitNullAnnotationVerifier;
 import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
 import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
@@ -337,7 +341,23 @@
 		if (this.anonymousType == null && this.enclosingInstance == null) {
 			return super.resolveType(scope);
 		}
-
+		TypeBinding result=resolveTypeForQualifiedAllocationExpression(scope);
+		if(result != null) {
+			final CompilerOptions compilerOptions = scope.compilerOptions();
+			if (compilerOptions.isAnnotationBasedNullAnalysisEnabled && (this.binding.tagBits & TagBits.IsNullnessKnown) == 0) {
+//{ObjectTeams: added 2nd arg:
+/* orig:
+				new ImplicitNullAnnotationVerifier(compilerOptions.inheritNullAnnotations)
+  :giro */
+				new ImplicitNullAnnotationVerifier(compilerOptions.inheritNullAnnotations, scope.environment())
+// SH}
+						.checkImplicitNullAnnotations(this.binding, null/*srcMethod*/, false, scope);
+			}
+		}
+		return result;
+	}
+	
+	private TypeBinding resolveTypeForQualifiedAllocationExpression(BlockScope scope) {
 		// Propagate the type checking to the arguments, and checks if the constructor is defined.
 		// ClassInstanceCreationExpression ::= Primary '.' 'new' SimpleName '(' ArgumentListopt ')' ClassBodyopt
 		// ClassInstanceCreationExpression ::= Name '.' 'new' SimpleName '(' ArgumentListopt ')' ClassBodyopt
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/LoopingFlowContext.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/LoopingFlowContext.java
index 2befb45..22cf760 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/LoopingFlowContext.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/LoopingFlowContext.java
@@ -18,6 +18,7 @@
  *								bug 376263 - Bogus "Potential null pointer access" warning
  *								bug 403147 - [compiler][null] FUP of bug 400761: consolidate interaction between unboxing, NPE, and deferred checking
  *								bug 406384 - Internal error with I20130413
+ *								Bug 415413 - [compiler][null] NullpointerException in Null Analysis caused by interaction of LoopingFlowContext and FinallyFlowContext
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.flow;
 
@@ -262,7 +263,7 @@
 					if (nullStatus != FlowInfo.NON_NULL) {
 						this.parent.recordNullityMismatch(scope, (Expression)location, this.providedExpectedTypes[i][0], this.providedExpectedTypes[i][1], nullStatus);
 					}
-					break;
+					continue; // no more delegation to parent
 				case EXIT_RESOURCE:
 						FakedTrackingVariable trackingVar = local.closeTracker;
 						if (trackingVar != null) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java
index 3e5ddfd..4e70de2 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java
@@ -17,6 +17,7 @@
  *								bug 395002 - Self bound generic class doesn't resolve bounds properly for wildcards for certain parametrisation.
  *								bug 395681 - [compiler] Improve simulation of javac6 behavior from bug 317719 after fixing bug 388795
  *								bug 409473 - [compiler] JDT cannot compile against JRE 1.8
+ *								Bug 410325 - [1.7][compiler] Generified method override different between javac and eclipse compiler
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.lookup;
 
@@ -302,6 +303,23 @@
 		boolean isAbstract = methods[i].isAbstract() || methods[i].declaringClass.isInterface();
 		if (!isAbstract) {
 			if (concreteMethod != null) {
+				// https://bugs.eclipse.org/195802 with https://bugs.eclipse.org/410325
+				// If a replace method (from findReplacedMethod()) is the rawified version of another
+				// don't count this as duplicates:
+				//   (Not asking ParameterizedGenericMethodBinding.isRawMethod(),
+				//    because that is true only for methods of a RawTypeBinding,
+				//    but here we look for rawness regarding the method's type variables).
+				if (concreteMethod.declaringClass == methods[i].declaringClass 
+						&& concreteMethod.typeVariables.length != methods[i].typeVariables.length) 
+				{
+					if (concreteMethod.typeVariables == Binding.NO_TYPE_VARIABLES
+							&& concreteMethod.original() == methods[i])
+						continue;
+					if (methods[i].typeVariables == Binding.NO_TYPE_VARIABLES
+							&& methods[i].original() == concreteMethod)
+						continue;
+				}
+
 				problemReporter().duplicateInheritedMethods(this.type, concreteMethod, methods[i]);
 				continueInvestigation = false;
 			}
@@ -639,6 +657,8 @@
  * mark as isOverridden
  * - any skippable method as defined above iff it is actually overridden by the specific method (disregarding visibility etc.)
  * Note, that 'idx' corresponds to the position of 'general' in the arrays 'skip' and 'isOverridden'
+ * TODO(stephan) currently (as of Bug 410325), the boarder between skip and isOverridden is blurred,
+ *                should reassess after more experience with this patch.
  */
 boolean isSkippableOrOverridden(MethodBinding specific, MethodBinding general, boolean[] skip, boolean[] isOverridden, int idx) {
 	boolean specificIsInterface = specific.declaringClass.isInterface();
@@ -649,10 +669,10 @@
 			isOverridden[idx] = true;
 			return true;
 		}
-	} else if (specificIsInterface == generalIsInterface) { 
-		if (isParameterSubsignature(specific, general)) {
+	} else if (specificIsInterface == generalIsInterface) {
+		if (specific.declaringClass.isCompatibleWith(general.declaringClass) && isMethodSubsignature(specific, general)) {
 			skip[idx] = true;
-			isOverridden[idx] = specific.declaringClass.isCompatibleWith(general.declaringClass);
+			isOverridden[idx] = true;
 			return true;
 		}
 	}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
index ad49a2d..16f1292 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
@@ -23,6 +23,8 @@
  *								bug 388281 - [compiler][null] inheritance of null annotations as an option
  *								bug 331649 - [compiler][null] consider null annotations for fields
  *								bug 380896 - [compiler][null] Enum constants not recognised as being NonNull.
+ *     Till Brychcy - Contributions for
+ *     							bug 415269 - NonNullByDefault is not always inherited to nested classes
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.lookup;
 
@@ -1663,7 +1665,7 @@
 	this.scope.buildMethods();
 }
 
-private void initializeNullDefault() {
+private int getNullDefault() {
 	// ensure nullness defaults are initialized at all enclosing levels:
 	switch (this.nullnessDefaultInitialized) {
 	case 0:
@@ -1673,6 +1675,7 @@
 		getPackage().isViewedAsDeprecated(); // initialize annotations
 		this.nullnessDefaultInitialized = 2;
 	}
+	return this.defaultNullness;
 }
 
 /**
@@ -2034,7 +2037,6 @@
 					// enum constants neither have a type declaration nor can they be null
 					field.tagBits |= TagBits.AnnotationNonNull;
 				} else {
-					initializeNullDefault();
 					if (hasNonNullDefault()) {
 						field.fillInDefaultNonNullness(fieldDecl, initializationScope);
 					}
@@ -2393,7 +2395,7 @@
 	return method;
 }
 private void createArgumentBindings(MethodBinding method, CompilerOptions compilerOptions) {
-	initializeNullDefault();
+	getNullDefault(); // ensure initialized
 	AbstractMethodDeclaration methodDecl = method.sourceMethod();
 	if (methodDecl != null) {
 		// while creating argument bindings we also collect explicit null annotations:
@@ -2465,7 +2467,7 @@
 
 // return: should caller continue searching?
 protected boolean checkRedundantNullnessDefaultOne(ASTNode location, Annotation[] annotations, long annotationTagBits) {
-	int thisDefault = this.defaultNullness;
+	int thisDefault = getNullDefault();
 	if (thisDefault == NONNULL_BY_DEFAULT) {
 		if ((annotationTagBits & TagBits.AnnotationNonNullByDefault) != 0) {
 			this.scope.problemReporter().nullDefaultAnnotationIsRedundant(location, annotations, this);
@@ -2495,7 +2497,7 @@
 			case Scope.CLASS_SCOPE:
 				currentType = ((ClassScope)currentScope).referenceContext.binding;
 				if (currentType != null) {
-					int foundDefaultNullness = currentType.defaultNullness;
+					int foundDefaultNullness = currentType.getNullDefault();
 					if (foundDefaultNullness != NO_NULL_DEFAULT) {
 						return foundDefaultNullness == NONNULL_BY_DEFAULT;
 					}
diff --git a/org.eclipse.jdt.core/forceQualifierUpdate.txt b/org.eclipse.jdt.core/forceQualifierUpdate.txt
index 13bf69d..6c3cdbf 100644
--- a/org.eclipse.jdt.core/forceQualifierUpdate.txt
+++ b/org.eclipse.jdt.core/forceQualifierUpdate.txt
@@ -3,3 +3,4 @@
 Bug 407853 - ECJ download misses legal file (about.html)
 Bug 407852 - ECJ source download is not correct
 Bug 408447 - compiler (log message) needs updating for copyright and bundle_qualifier
+Several bundles changed and need to be touched
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
index 8ded8c2..5c794ea 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
@@ -940,9 +940,10 @@
 	 */
 	public static final String COMPILER_PB_RAW_TYPE_REFERENCE = PLUGIN_ID + ".compiler.problem.rawTypeReference"; //$NON-NLS-1$
 	/**
-	 * Compiler option ID: Reporting of Unavoidable Generic Type Problems.
-	 * <p> When enabled, the compiler will issue an error or warning even when it detects a generic type problem
-	 *     that could not have been avoided by the programmer. As an example, a type may be forced to use raw types
+	 * Compiler option ID: Reporting of Unavoidable Generic Type Problems due to raw APIs.
+	 * <p> When enabled, the compiler will issue an error or warning even when it detects a generics-related type problem
+	 *     that could not have been avoided by the programmer, because a referenced API already contains raw types.
+	 *     As an example, a type may be forced to use raw types
 	 *     in its method signatures and return types because the methods it overrides from a super type are declared to
 	 *     use raw types in the first place.</p>
 	 * <dl>
diff --git a/org.eclipse.jdt.core/pom.xml b/org.eclipse.jdt.core/pom.xml
index 4e908bf..1cd2b9c 100644
--- a/org.eclipse.jdt.core/pom.xml
+++ b/org.eclipse.jdt.core/pom.xml
@@ -21,6 +21,10 @@
   <version>3.10.0-SNAPSHOT</version>
   <packaging>eclipse-plugin</packaging>
 
+  <properties>
+    <defaultSigning-excludeInnerJars>true</defaultSigning-excludeInnerJars>
+  </properties>
+
   <build>
     <plugins>
     <plugin>