Attachment #124262 for bug #247206




		// javac options
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError /* javac test options */);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
public void test020() {
	Map customOptions = new HashMap();
	customOptions.put(CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportDeprecationWhenOverridingDeprecatedMethod, CompilerOptions.IGNORE);
	
	this.runConformTest(
			new String[] {
					"test1/E.java",
					"package test1;\n" + 
					"\n" + 
					"public class E implements I {\n" + 
					"	public I2 foo() {\n" + 
					"		return null;\n" + 
					"	}\n" + 
					"}\n" + 
					"interface I {\n" + 
					"	/** @deprecated */\n" + 
					"	public I2 foo();\n" + 
					"}\n" + 
					"/** @deprecated */\n" + 
					"interface I2 {}",
			},
			"", // expected output
			null,
			true, // flush previous output dir content
			null, // special vm args
			customOptions,  // custom options
			null); // custom requestor
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
public void test021() {
	Map customOptions = new HashMap();
	customOptions.put(CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportDeprecationWhenOverridingDeprecatedMethod, CompilerOptions.IGNORE);
	
	this.runConformTest(
			new String[] {
				"test1/E.java",
				"package test1;\n" + 
				"\n" + 
				"public class E implements I {\n" + 
				"	public I2 foo() {\n" + 
				"		return null;\n" + 
				"	}\n" + 
				"}\n" + 
				"interface I {\n" + 
				"	/** @deprecated */\n" + 
				"	public I2 foo();\n" + 
				"}\n",
				"test1/I2.java",
				"package test1;\n" + 
				"/** @deprecated */\n" + 
				"interface I2 {}",
			},
			"", // expected output
			null,
			true, // flush previous output dir content
			null, // special vm args
			customOptions,  // custom options
			null); // custom requestor
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206, additional tests that verify that
// deprecation messages originate from type parameters, bounds, arguments, return types,
// local variables, exception specifications etc. Valid only for 1.5 and above
public void test022() {
    if (this.complianceLevel <= ClassFileConstants.JDK1_4)
        return;
    Map customOptions = new HashMap();
    customOptions.put(CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.ERROR);
    customOptions.put(CompilerOptions.OPTION_ReportDeprecationInDeprecatedCode, CompilerOptions.ENABLED);
    customOptions.put(CompilerOptions.OPTION_ReportDeprecationWhenOverridingDeprecatedMethod, CompilerOptions.IGNORE);
    
    this.runNegativeTest(
            // test directory preparation
            true /* flush output directory */,
            new String[] {
                "test1/E.java",
                "package test1;\n" + 
                "\n" + 
                "public class E implements I {\n" + 
                "   public <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" + 
                "       I2 p = null; \n" +
                "       return p;\n" + 
                "   }\n" + 
                "}\n" + 
                "interface I {\n" + 
                "   /** @deprecated */\n" + 
                "   public <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" + 
                "}\n",
                "test1/I2.java",
                "package test1;\n" + 
                "/** @deprecated */\n" + 
                "interface I2 { /** @deprecated */ interface I3 {} }\n" +
                "/** @deprecated */\n" + 
                "class Xception extends Throwable {\n" +
                "   private static final long serialVersionUID = 1L;\n}\n",
            },
            // compiler options
            null /* no class libraries */,
            customOptions /* custom options */,
            "----------\n" +  // expected output
            "1. ERROR in test1\\E.java (at line 4)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" + 
            "\t                  ^^\n" + 
            "The type I2 is deprecated\n" + 
            "----------\n" + 
            "2. ERROR in test1\\E.java (at line 4)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" + 
            "\t                       ^^^^^\n" + 
            "The type I2 is deprecated\n" + 
            "----------\n" + 
            "3. ERROR in test1\\E.java (at line 4)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" + 
            "\t                       ^^^^^\n" + 
            "The type I2.I3 is deprecated\n" + 
            "----------\n" + 
            "4. ERROR in test1\\E.java (at line 4)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" + 
            "\t                              ^^\n" + 
            "The type I2 is deprecated\n" + 
            "----------\n" + 
            "5. ERROR in test1\\E.java (at line 4)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" + 
            "\t                                     ^^\n" + 
            "The type I2 is deprecated\n" + 
            "----------\n" + 
            "6. ERROR in test1\\E.java (at line 4)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" + 
            "\t                                                   ^^^^^^^^\n" + 
            "The type Xception is deprecated\n" + 
            "----------\n" + 
            "7. ERROR in test1\\E.java (at line 5)\n" + 
            "\tI2 p = null; \n" + 
            "\t^^\n" + 
            "The type I2 is deprecated\n" + 
            "----------\n" + 
            "8. ERROR in test1\\E.java (at line 11)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" + 
            "\t                  ^^\n" + 
            "The type I2 is deprecated\n" + 
            "----------\n" + 
            "9. ERROR in test1\\E.java (at line 11)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" + 
            "\t                       ^^^^^\n" + 
            "The type I2 is deprecated\n" + 
            "----------\n" + 
            "10. ERROR in test1\\E.java (at line 11)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" + 
            "\t                       ^^^^^\n" + 
            "The type I2.I3 is deprecated\n" + 
            "----------\n" + 
            "11. ERROR in test1\\E.java (at line 11)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" + 
            "\t                              ^^\n" + 
            "The type I2 is deprecated\n" + 
            "----------\n" + 
            "12. ERROR in test1\\E.java (at line 11)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" + 
            "\t                                     ^^\n" + 
            "The type I2 is deprecated\n" + 
            "----------\n" + 
            "13. ERROR in test1\\E.java (at line 11)\n" + 
            "\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" + 
            "\t                                                   ^^^^^^^^\n" + 
            "The type Xception is deprecated\n" + 
            "----------\n",
            // javac options
            JavacTestOptions.Excuse.EclipseWarningConfiguredAsError /* javac test options */
            );    
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206, verify that none of the 13 errros produced
// by test022 show up when deprecation reporting in an already deprecated context is disabled.
public void test023() {
    if (this.complianceLevel <= ClassFileConstants.JDK1_4)
        return;
    Map customOptions = new HashMap();
    customOptions.put(CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.ERROR);
    customOptions.put(CompilerOptions.OPTION_ReportDeprecationInDeprecatedCode, CompilerOptions.DISABLED);
    customOptions.put(CompilerOptions.OPTION_ReportDeprecationWhenOverridingDeprecatedMethod, CompilerOptions.IGNORE);
    
    this.runConformTest(
            new String[] {
                "test1/E.java",
                "package test1;\n" + 
                "\n" + 
                "public class E implements I {\n" + 
                "   public <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" + 
                "       I2 p = null; \n" +
                "       return p;\n" + 
                "   }\n" + 
                "}\n" + 
                "interface I {\n" + 
                "   /** @deprecated */\n" + 
                "   public <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" + 
                "}\n",
                "test1/I2.java",
                "package test1;\n" + 
                "/** @deprecated */\n" + 
                "interface I2 { /** @deprecated */ interface I3 {} }\n" +
                "/** @deprecated */\n" + 
                "class Xception extends Throwable {\n" +
                "   private static final long serialVersionUID = 1L;\n}\n",
                },
            "", // expected output
            null,
            true, // flush previous output dir content
            null, // special vm args
            customOptions,  // custom options
            null); // custom requestor
}


public static Class testClass() {
	return DeprecatedTest.class;
}




			if (unit.scope != null) {
				// fault in fields & methods
				unit.scope.faultInTypes();
				if (verifyMethods) {
					// http://dev.eclipse.org/bugs/show_bug.cgi?id=23117
 					// verify inherited methods
					unit.scope.verifyMethods(this.lookupEnvironment.methodVerifier());
					if (!unit.scope.compilerOptions().reportDeprecationInsideDeprecatedCode) {
						// If we short circuited some error reporting earlier due to being unable to say precisely
						// if we are in a deprecated method, report those errors/warnings (if any) now.
						// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
						unit.scope.reportDeprecatedTypesInSignatures();
					}
				}
				// type checking
				unit.resolve();




			if(inheritedMethod.isSynchronized() && !currentMethod.isSynchronized()) {
				problemReporter(currentMethod).missingSynchronizedOnInheritedMethod(currentMethod, inheritedMethod);
			}
			if (inheritedMethod.isViewedAsDeprecated()) {
				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
				boolean currentMethodIsViewedDeprecated = currentMethod.isViewedAsDeprecated();
				if (currentMethod.isImplementing() && !currentMethodIsViewedDeprecated)
					currentMethod.modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
				if (options.reportDeprecationWhenOverridingDeprecatedMethod) {
					if (!currentMethodIsViewedDeprecated || options.reportDeprecationInsideDeprecatedCode) {
						// check against the other inherited methods to see if they hide this inheritedMethod
						ReferenceBinding declaringClass = inheritedMethod.declaringClass;
						if (declaringClass.isInterface())
							for (int j = length; --j >= 0;)
								if (i != j && methods[j].declaringClass.implementsInterface(declaringClass, false))
									continue nextMethod;

						problemReporter(currentMethod).overridesDeprecatedMethod(currentMethod, inheritedMethod);
					}
				}
			}
		}

Lines 813-816 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java (+5 lines)
813	for (int i = 0, length = this.topLevelTypes.length; i < length; i++)	813	for (int i = 0, length = this.topLevelTypes.length; i < length; i++)
814	this.topLevelTypes[i].verifyMethods(verifier);	814	this.topLevelTypes[i].verifyMethods(verifier);
815	}	815	}
		816
		817	public void reportDeprecatedTypesInSignatures() {
		818	for (int i = 0, length = this.topLevelTypes.length; i < length; i++)
		819	this.topLevelTypes[i].reportDeprecatedTypesInSignatures();
		820	}
816	}	821	}




	}
	return null; // should never reach this point
}
private void reportDeprecatedUsagesFor(MethodBinding method) {
	// Deferred deprecation reporting. Now that the method verification is over, we are able to discover if
	// ``method'' overrides an abstract method. If it does and that method is deprecated, then ``method'' itself
	// should be considered to be implicitly deprecated. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
	if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) != 0)
		return;

	AbstractMethodDeclaration methodDecl = method.sourceMethod();
	if (methodDecl == null)
		return; // method could not be resolved in previous iteration

	// Report deprecation on type parameters as needed.
	TypeParameter[] typeParameters = methodDecl.typeParameters();
	if (typeParameters != null) {
		for (int i = 0; i < typeParameters.length; i++) {
			TypeParameter typeParameter = typeParameters[i];
			TypeReference typeRef = typeParameter.type;
			if (typeRef == null || typeRef.resolvedType == null || !typeRef.resolvedType.isValidBinding())
				continue;
			if (typeRef.isTypeUseDeprecated(typeRef.resolvedType, methodDecl.scope)) {
				methodDecl.scope.problemReporter().deprecatedType(typeRef.resolvedType, typeRef);
			}
			TypeReference[] boundRefs = typeParameter.bounds;
			if (boundRefs != null) {
				for (int j = 0; j < boundRefs.length; j++) {
					TypeReference boundRef = boundRefs[j];
					if (boundRef == null || boundRef.resolvedType == null || !boundRef.resolvedType.isValidBinding())
						continue;
					if (boundRef.isTypeUseDeprecated(boundRef.resolvedType, methodDecl.scope)) {
						methodDecl.scope.problemReporter().deprecatedType(boundRef.resolvedType, boundRef);
					}
				}				
			}
		}
	}
	// Report deprecation on exception specification as needed.
	TypeReference[] exceptionTypes = methodDecl.thrownExceptions;
	if (exceptionTypes != null) {
		int size = exceptionTypes.length;
		for (int i = 0; i < size; i++) {
			TypeReference anException = exceptionTypes[i];
			if (anException != null && anException.resolvedType != null) {
				if(!anException.resolvedType.isValidBinding())
					continue;
				if (anException.isTypeUseDeprecated(anException.resolvedType, methodDecl.scope)) {
					methodDecl.scope.problemReporter().deprecatedType(anException.resolvedType, anException);
				}
			}
		}
	}
	// Report deprecation on argument types as needed.
	Argument[] arguments = methodDecl.arguments;
	if (arguments != null) {
		int size = arguments.length;

		for (int i = 0; i < size; i++) {
			Argument anArgument = arguments[i];
			if (anArgument != null && anArgument.type != null && anArgument.type.resolvedType != null) {
				if (!anArgument.type.resolvedType.isValidBinding())
					continue;
				if (anArgument.isTypeUseDeprecated(anArgument.type.resolvedType, methodDecl.scope)) {
					methodDecl.scope.problemReporter().deprecatedType(anArgument.type.resolvedType, anArgument.type);
				}
			}
		}
	}
	// Report deprecation on return type as needed.
	if (!method.isConstructor() && methodDecl instanceof MethodDeclaration) {
		TypeReference returnType = ((MethodDeclaration) methodDecl).returnType;
		if (returnType != null && returnType.resolvedType != null && returnType.resolvedType.isValidBinding()) {
			if (returnType.isTypeUseDeprecated(returnType.resolvedType, methodDecl.scope)) {
				methodDecl.scope.problemReporter().deprecatedType(returnType.resolvedType, returnType);
			}
		}
	}
}
public MethodBinding resolveTypesFor(MethodBinding method) {
	if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
		return method;

	for (int i = this.memberTypes.length; --i >= 0;)
		 ((SourceTypeBinding) this.memberTypes[i]).verifyMethods(verifier);
}
void reportDeprecatedTypesInSignatures() {

	for (int i = 0, length = this.methods.length; i < length; i++)
		this.reportDeprecatedUsagesFor(this.methods[i]);

	for (int i = this.memberTypes.length; --i >= 0;)
		((SourceTypeBinding) this.memberTypes[i]).reportDeprecatedTypesInSignatures();

}
}

Lines 726-738 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/Compiler.java (-8 / +17 lines)
726	long resolveStart = System.currentTimeMillis();	726	long resolveStart = System.currentTimeMillis();
727	this.stats.parseTime += resolveStart - parseStart;	727	this.stats.parseTime += resolveStart - parseStart;
728		728
729	// fault in fields & methods	729	if (unit.scope != null) {
730	if (unit.scope != null)	730	unit.scope.faultInTypes(); // fault in fields & methods
731	unit.scope.faultInTypes();	731	unit.scope.verifyMethods(this.lookupEnvironment.methodVerifier()); // verify inherited methods
732		732	if (!unit.scope.compilerOptions().reportDeprecationInsideDeprecatedCode) {
733	// verify inherited methods	733	// If we short circuited some error reporting earlier due to being unable to say precisely
734	if (unit.scope != null)	734	// if we are in a deprecated method, report those errors if any now.
735	unit.scope.verifyMethods(this.lookupEnvironment.methodVerifier());	735	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
		736	unit.scope.reportDeprecatedTypesInSignatures();
		737	}
		738	}
736		739
737	// type checking	740	// type checking
738	unit.resolve();	741	unit.resolve();
Lines 845-854 Link Here
845	if (unit.scope != null) {	848	if (unit.scope != null) {
846	// fault in fields & methods	849	// fault in fields & methods
847	unit.scope.faultInTypes();	850	unit.scope.faultInTypes();
848	if (unit.scope != null && verifyMethods) {	851	if (verifyMethods) {
849	// http://dev.eclipse.org/bugs/show_bug.cgi?id=23117	852	// http://dev.eclipse.org/bugs/show_bug.cgi?id=23117
850	// verify inherited methods	853	// verify inherited methods
851	unit.scope.verifyMethods(this.lookupEnvironment.methodVerifier());	854	unit.scope.verifyMethods(this.lookupEnvironment.methodVerifier());
		855	if (!unit.scope.compilerOptions().reportDeprecationInsideDeprecatedCode) {
		856	// If we short circuited some error reporting earlier due to being unable to say precisely
		857	// if we are in a deprecated method, report those errors/warnings (if any) now.
		858	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
		859	unit.scope.reportDeprecatedTypesInSignatures();
		860	}
852	}	861	}
853	// type checking	862	// type checking
854	unit.resolve();	863	unit.resolve();




		if (scope.isDefinedInSameUnit(refType)) return false;

		// if context is deprecated, may avoid reporting
		if (!scope.compilerOptions().reportDeprecationInsideDeprecatedCode) {
			if (scope.isInsideDeprecatedCode())
				return false;
			if (scope instanceof MethodScope) {
				MethodScope mScope = (MethodScope) scope;
				if (!mScope.isInsideInitializer()) {
					MethodBinding method = ((AbstractMethodDeclaration) mScope.referenceContext).binding;
					// If method is still unresolved, answer false as we cannot conclusively say (yet)
					// whether the method is really an implementation of a deprecated interface.
					if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) != 0)
						return false;
				}
			}
		}
		
		return true;
	}


Return to bug 247206

Lines 168-183 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java (-9 / +15 lines)
168	if(inheritedMethod.isSynchronized() && !currentMethod.isSynchronized()) {	168	if(inheritedMethod.isSynchronized() && !currentMethod.isSynchronized()) {
169	problemReporter(currentMethod).missingSynchronizedOnInheritedMethod(currentMethod, inheritedMethod);	169	problemReporter(currentMethod).missingSynchronizedOnInheritedMethod(currentMethod, inheritedMethod);
170	}	170	}
171	if (options.reportDeprecationWhenOverridingDeprecatedMethod && inheritedMethod.isViewedAsDeprecated()) {	171	if (inheritedMethod.isViewedAsDeprecated()) {
172	if (!currentMethod.isViewedAsDeprecated() \|\| options.reportDeprecationInsideDeprecatedCode) {	172	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
173	// check against the other inherited methods to see if they hide this inheritedMethod	173	boolean currentMethodIsViewedDeprecated = currentMethod.isViewedAsDeprecated();
174	ReferenceBinding declaringClass = inheritedMethod.declaringClass;	174	if (currentMethod.isImplementing() && !currentMethodIsViewedDeprecated)
175	if (declaringClass.isInterface())	175	currentMethod.modifiers \|= ExtraCompilerModifiers.AccDeprecatedImplicitly;
176	for (int j = length; --j >= 0;)	176	if (options.reportDeprecationWhenOverridingDeprecatedMethod) {
177	if (i != j && methods[j].declaringClass.implementsInterface(declaringClass, false))	177	if (!currentMethodIsViewedDeprecated \|\| options.reportDeprecationInsideDeprecatedCode) {
178	continue nextMethod;	178	// check against the other inherited methods to see if they hide this inheritedMethod
		179	ReferenceBinding declaringClass = inheritedMethod.declaringClass;
		180	if (declaringClass.isInterface())
		181	for (int j = length; --j >= 0;)
		182	if (i != j && methods[j].declaringClass.implementsInterface(declaringClass, false))
		183	continue nextMethod;
179		184
180	problemReporter(currentMethod).overridesDeprecatedMethod(currentMethod, inheritedMethod);	185	problemReporter(currentMethod).overridesDeprecatedMethod(currentMethod, inheritedMethod);
		186	}
181	}	187	}
182	}	188	}
183	}	189	}

Lines 1295-1300 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java (+85 lines)
1295	}	1295	}
1296	return null; // should never reach this point	1296	return null; // should never reach this point
1297	}	1297	}
		1298	private void reportDeprecatedUsagesFor(MethodBinding method) {
		1299	// Deferred deprecation reporting. Now that the method verification is over, we are able to discover if
		1300	// ``method'' overrides an abstract method. If it does and that method is deprecated, then ``method'' itself
		1301	// should be considered to be implicitly deprecated. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
		1302	if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) != 0)
		1303	return;
		1304
		1305	AbstractMethodDeclaration methodDecl = method.sourceMethod();
		1306	if (methodDecl == null)
		1307	return; // method could not be resolved in previous iteration
		1308
		1309	// Report deprecation on type parameters as needed.
		1310	TypeParameter[] typeParameters = methodDecl.typeParameters();
		1311	if (typeParameters != null) {
		1312	for (int i = 0; i < typeParameters.length; i++) {
		1313	TypeParameter typeParameter = typeParameters[i];
		1314	TypeReference typeRef = typeParameter.type;
		1315	if (typeRef == null \|\| typeRef.resolvedType == null \|\| !typeRef.resolvedType.isValidBinding())
		1316	continue;
		1317	if (typeRef.isTypeUseDeprecated(typeRef.resolvedType, methodDecl.scope)) {
		1318	methodDecl.scope.problemReporter().deprecatedType(typeRef.resolvedType, typeRef);
		1319	}
		1320	TypeReference[] boundRefs = typeParameter.bounds;
		1321	if (boundRefs != null) {
		1322	for (int j = 0; j < boundRefs.length; j++) {
		1323	TypeReference boundRef = boundRefs[j];
		1324	if (boundRef == null \|\| boundRef.resolvedType == null \|\| !boundRef.resolvedType.isValidBinding())
		1325	continue;
		1326	if (boundRef.isTypeUseDeprecated(boundRef.resolvedType, methodDecl.scope)) {
		1327	methodDecl.scope.problemReporter().deprecatedType(boundRef.resolvedType, boundRef);
		1328	}
		1329	}
		1330	}
		1331	}
		1332	}
		1333	// Report deprecation on exception specification as needed.
		1334	TypeReference[] exceptionTypes = methodDecl.thrownExceptions;
		1335	if (exceptionTypes != null) {
		1336	int size = exceptionTypes.length;
		1337	for (int i = 0; i < size; i++) {
		1338	TypeReference anException = exceptionTypes[i];
		1339	if (anException != null && anException.resolvedType != null) {
		1340	if(!anException.resolvedType.isValidBinding())
		1341	continue;
		1342	if (anException.isTypeUseDeprecated(anException.resolvedType, methodDecl.scope)) {
		1343	methodDecl.scope.problemReporter().deprecatedType(anException.resolvedType, anException);
		1344	}
		1345	}
		1346	}
		1347	}
		1348	// Report deprecation on argument types as needed.
		1349	Argument[] arguments = methodDecl.arguments;
		1350	if (arguments != null) {
		1351	int size = arguments.length;
		1352
		1353	for (int i = 0; i < size; i++) {
		1354	Argument anArgument = arguments[i];
		1355	if (anArgument != null && anArgument.type != null && anArgument.type.resolvedType != null) {
		1356	if (!anArgument.type.resolvedType.isValidBinding())
		1357	continue;
		1358	if (anArgument.isTypeUseDeprecated(anArgument.type.resolvedType, methodDecl.scope)) {
		1359	methodDecl.scope.problemReporter().deprecatedType(anArgument.type.resolvedType, anArgument.type);
		1360	}
		1361	}
1362	}
1363	}
1364	// Report deprecation on return type as needed.
1365	if (!method.isConstructor() && methodDecl instanceof MethodDeclaration) {
1366	TypeReference returnType = ((MethodDeclaration) methodDecl).returnType;
1367	if (returnType != null && returnType.resolvedType != null && returnType.resolvedType.isValidBinding()) {
1368	if (returnType.isTypeUseDeprecated(returnType.resolvedType, methodDecl.scope)) {
1369	methodDecl.scope.problemReporter().deprecatedType(returnType.resolvedType, returnType);
1370	}
1371	}
1372	}
1373	}
1298	public MethodBinding resolveTypesFor(MethodBinding method) {	1374	public MethodBinding resolveTypesFor(MethodBinding method) {
1299	if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)	1375	if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
1300	return method;	1376	return method;
Lines 1617-1620 Link Here
1617	for (int i = this.memberTypes.length; --i >= 0;)	1693	for (int i = this.memberTypes.length; --i >= 0;)
1618	((SourceTypeBinding) this.memberTypes[i]).verifyMethods(verifier);	1694	((SourceTypeBinding) this.memberTypes[i]).verifyMethods(verifier);
1619	}	1695	}
		1696	void reportDeprecatedTypesInSignatures() {
		1697
		1698	for (int i = 0, length = this.methods.length; i < length; i++)
		1699	this.reportDeprecatedUsagesFor(this.methods[i]);
		1700
		1701	for (int i = this.memberTypes.length; --i >= 0;)
		1702	((SourceTypeBinding) this.memberTypes[i]).reportDeprecatedTypesInSignatures();
		1703
		1704	}
1620	}	1705	}

Lines 472-478 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java (-1 / +15 lines)
472	if (scope.isDefinedInSameUnit(refType)) return false;	472	if (scope.isDefinedInSameUnit(refType)) return false;
473		473
474	// if context is deprecated, may avoid reporting	474	// if context is deprecated, may avoid reporting
475	if (!scope.compilerOptions().reportDeprecationInsideDeprecatedCode && scope.isInsideDeprecatedCode()) return false;	475	if (!scope.compilerOptions().reportDeprecationInsideDeprecatedCode) {
		476	if (scope.isInsideDeprecatedCode())
		477	return false;
		478	if (scope instanceof MethodScope) {
		479	MethodScope mScope = (MethodScope) scope;
		480	if (!mScope.isInsideInitializer()) {
		481	MethodBinding method = ((AbstractMethodDeclaration) mScope.referenceContext).binding;
		482	// If method is still unresolved, answer false as we cannot conclusively say (yet)
		483	// whether the method is really an implementation of a deprecated interface.
		484	if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) != 0)
		485	return false;
		486	}
		487	}
		488	}
		489
476	return true;	490	return true;
477	}	491	}
478		492

Lines 796-801 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/DeprecatedTest.java (+214 lines)
796	// javac options	796	// javac options
797	JavacTestOptions.Excuse.EclipseWarningConfiguredAsError /* javac test options */);	797	JavacTestOptions.Excuse.EclipseWarningConfiguredAsError /* javac test options */);
798	}	798	}
		799	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
		800	public void test020() {
		801	Map customOptions = new HashMap();
		802	customOptions.put(CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.ERROR);
		803	customOptions.put(CompilerOptions.OPTION_ReportDeprecationWhenOverridingDeprecatedMethod, CompilerOptions.IGNORE);
		804
		805	this.runConformTest(
		806	new String[] {
		807	"test1/E.java",
		808	"package test1;\n" +
		809	"\n" +
		810	"public class E implements I {\n" +
		811	" public I2 foo() {\n" +
		812	" return null;\n" +
		813	" }\n" +
		814	"}\n" +
		815	"interface I {\n" +
		816	" /** @deprecated */\n" +
		817	" public I2 foo();\n" +
		818	"}\n" +
		819	"/** @deprecated */\n" +
		820	"interface I2 {}",
		821	},
		822	"", // expected output
		823	null,
		824	true, // flush previous output dir content
		825	null, // special vm args
		826	customOptions, // custom options
		827	null); // custom requestor
		828	}
		829	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
		830	public void test021() {
		831	Map customOptions = new HashMap();
		832	customOptions.put(CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.ERROR);
		833	customOptions.put(CompilerOptions.OPTION_ReportDeprecationWhenOverridingDeprecatedMethod, CompilerOptions.IGNORE);
		834
		835	this.runConformTest(
		836	new String[] {
		837	"test1/E.java",
		838	"package test1;\n" +
		839	"\n" +
		840	"public class E implements I {\n" +
		841	" public I2 foo() {\n" +
		842	" return null;\n" +
		843	" }\n" +
		844	"}\n" +
		845	"interface I {\n" +
		846	" /** @deprecated */\n" +
		847	" public I2 foo();\n" +
		848	"}\n",
		849	"test1/I2.java",
		850	"package test1;\n" +
		851	"/** @deprecated */\n" +
		852	"interface I2 {}",
		853	},
		854	"", // expected output
		855	null,
		856	true, // flush previous output dir content
		857	null, // special vm args
		858	customOptions, // custom options
		859	null); // custom requestor
		860	}
		861
		862	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206, additional tests that verify that
863	// deprecation messages originate from type parameters, bounds, arguments, return types,
864	// local variables, exception specifications etc. Valid only for 1.5 and above
865	public void test022() {
866	if (this.complianceLevel <= ClassFileConstants.JDK1_4)
867	return;
868	Map customOptions = new HashMap();
869	customOptions.put(CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.ERROR);
870	customOptions.put(CompilerOptions.OPTION_ReportDeprecationInDeprecatedCode, CompilerOptions.ENABLED);
871	customOptions.put(CompilerOptions.OPTION_ReportDeprecationWhenOverridingDeprecatedMethod, CompilerOptions.IGNORE);
872
873	this.runNegativeTest(
874	// test directory preparation
875	true /* flush output directory */,
876	new String[] {
877	"test1/E.java",
878	"package test1;\n" +
879	"\n" +
880	"public class E implements I {\n" +
881	" public <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" +
882	" I2 p = null; \n" +
883	" return p;\n" +
884	" }\n" +
885	"}\n" +
886	"interface I {\n" +
887	" /** @deprecated */\n" +
888	" public <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" +
889	"}\n",
890	"test1/I2.java",
891	"package test1;\n" +
892	"/** @deprecated */\n" +
893	"interface I2 { /** @deprecated */ interface I3 {} }\n" +
894	"/** @deprecated */\n" +
895	"class Xception extends Throwable {\n" +
896	" private static final long serialVersionUID = 1L;\n}\n",
897	},
898	// compiler options
899	null /* no class libraries */,
900	customOptions /* custom options */,
901	"----------\n" + // expected output
902	"1. ERROR in test1\\E.java (at line 4)\n" +
903	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" +
904	"\t ^^\n" +
905	"The type I2 is deprecated\n" +
906	"----------\n" +
907	"2. ERROR in test1\\E.java (at line 4)\n" +
908	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" +
909	"\t ^^^^^\n" +
910	"The type I2 is deprecated\n" +
911	"----------\n" +
912	"3. ERROR in test1\\E.java (at line 4)\n" +
913	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" +
914	"\t ^^^^^\n" +
915	"The type I2.I3 is deprecated\n" +
916	"----------\n" +
917	"4. ERROR in test1\\E.java (at line 4)\n" +
918	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" +
919	"\t ^^\n" +
920	"The type I2 is deprecated\n" +
921	"----------\n" +
922	"5. ERROR in test1\\E.java (at line 4)\n" +
923	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" +
924	"\t ^^\n" +
925	"The type I2 is deprecated\n" +
926	"----------\n" +
927	"6. ERROR in test1\\E.java (at line 4)\n" +
928	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" +
929	"\t ^^^^^^^^\n" +
930	"The type Xception is deprecated\n" +
931	"----------\n" +
932	"7. ERROR in test1\\E.java (at line 5)\n" +
933	"\tI2 p = null; \n" +
934	"\t^^\n" +
935	"The type I2 is deprecated\n" +
936	"----------\n" +
937	"8. ERROR in test1\\E.java (at line 11)\n" +
938	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" +
939	"\t ^^\n" +
940	"The type I2 is deprecated\n" +
941	"----------\n" +
942	"9. ERROR in test1\\E.java (at line 11)\n" +
943	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" +
944	"\t ^^^^^\n" +
945	"The type I2 is deprecated\n" +
946	"----------\n" +
947	"10. ERROR in test1\\E.java (at line 11)\n" +
948	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" +
949	"\t ^^^^^\n" +
950	"The type I2.I3 is deprecated\n" +
951	"----------\n" +
952	"11. ERROR in test1\\E.java (at line 11)\n" +
953	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" +
954	"\t ^^\n" +
955	"The type I2 is deprecated\n" +
956	"----------\n" +
957	"12. ERROR in test1\\E.java (at line 11)\n" +
958	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" +
959	"\t ^^\n" +
960	"The type I2 is deprecated\n" +
961	"----------\n" +
962	"13. ERROR in test1\\E.java (at line 11)\n" +
963	"\tpublic <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" +
964	"\t ^^^^^^^^\n" +
965	"The type Xception is deprecated\n" +
966	"----------\n",
967	// javac options
968	JavacTestOptions.Excuse.EclipseWarningConfiguredAsError /* javac test options */
969	);
970	}
971	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206, verify that none of the 13 errros produced
972	// by test022 show up when deprecation reporting in an already deprecated context is disabled.
973	public void test023() {
974	if (this.complianceLevel <= ClassFileConstants.JDK1_4)
975	return;
976	Map customOptions = new HashMap();
977	customOptions.put(CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.ERROR);
978	customOptions.put(CompilerOptions.OPTION_ReportDeprecationInDeprecatedCode, CompilerOptions.DISABLED);
979	customOptions.put(CompilerOptions.OPTION_ReportDeprecationWhenOverridingDeprecatedMethod, CompilerOptions.IGNORE);
980
981	this.runConformTest(
982	new String[] {
983	"test1/E.java",
984	"package test1;\n" +
985	"\n" +
986	"public class E implements I {\n" +
987	" public <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception {\n" +
988	" I2 p = null; \n" +
989	" return p;\n" +
990	" }\n" +
991	"}\n" +
992	"interface I {\n" +
993	" /** @deprecated */\n" +
994	" public <T extends I2 & I2.I3> I2 foo(I2 i2) throws Xception;\n" +
995	"}\n",
996	"test1/I2.java",
997	"package test1;\n" +
998	"/** @deprecated */\n" +
999	"interface I2 { /** @deprecated */ interface I3 {} }\n" +
1000	"/** @deprecated */\n" +
1001	"class Xception extends Throwable {\n" +
1002	" private static final long serialVersionUID = 1L;\n}\n",
1003	},
1004	"", // expected output
1005	null,
1006	true, // flush previous output dir content
1007	null, // special vm args
1008	customOptions, // custom options
1009	null); // custom requestor
1010	}
1011
1012
799	public static Class testClass() {	1013	public static Class testClass() {
800	return DeprecatedTest.class;	1014	return DeprecatedTest.class;
801	}	1015	}

Lines 856-865 Link Here

(-)dom/org/eclipse/jdt/core/dom/CompilationUnitResolver.java (-1 / +7 lines)
856	if (unit.scope != null) {	856	if (unit.scope != null) {
857	// fault in fields & methods	857	// fault in fields & methods
858	unit.scope.faultInTypes();	858	unit.scope.faultInTypes();
859	if (unit.scope != null && verifyMethods) {	859	if (verifyMethods) {
860	// http://dev.eclipse.org/bugs/show_bug.cgi?id=23117	860	// http://dev.eclipse.org/bugs/show_bug.cgi?id=23117
861	// verify inherited methods	861	// verify inherited methods
862	unit.scope.verifyMethods(this.lookupEnvironment.methodVerifier());	862	unit.scope.verifyMethods(this.lookupEnvironment.methodVerifier());
		863	if (!unit.scope.compilerOptions().reportDeprecationInsideDeprecatedCode) {
		864	// If we short circuited some error reporting earlier due to being unable to say precisely
		865	// if we are in a deprecated method, report those errors/warnings (if any) now.
		866	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=247206
		867	unit.scope.reportDeprecatedTypesInSignatures();
		868	}
863	}	869	}
864	// type checking	870	// type checking
865	unit.resolve();	871	unit.resolve();