Attachment #103110 for bug #204234

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 204234
Collapse All | Expand All




			// ignore cases where field is used from within inside itself
			field.original().modifiers |= ExtraCompilerModifiers.AccLocallyUsed;
		}
	
		if ((field.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0) {
			AccessRestriction restriction =
				scope.environment().getAccessRestriction(field.declaringClass.erasure());
			if (restriction != null && (this.bits & ASTNode.InsideJavadoc)== 0) {
				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=204234
				// access restriction inside javadoc should have already been warned on Type
				// @see ASTNode#isTypeUseDeprecated(TypeBinding, Scope)
				scope.problemReporter().forbiddenReference(field, this,
						restriction.classpathEntryType, restriction.classpathEntryName, 
						restriction.getProblemId());
			}
		}
	
		if (!field.isViewedAsDeprecated()) return false;
	
		// inside same unit - no report
		if (scope.isDefinedInSameUnit(field.declaringClass)) return false;
	
		// if context is deprecated, may avoid reporting
		if (!scope.compilerOptions().reportDeprecationInsideDeprecatedCode && scope.isInsideDeprecatedCode()) return false;
		return true;

	}

	/* Answer true if the method use is considered deprecated.
	 * An access in the same compilation unit is allowed.
	 */
	public final boolean isMethodUseDeprecated(MethodBinding method, Scope scope,
			boolean isExplicitUse) {
		// ignore references insing Javadoc comments

			//       warnings, one on type, the other on constructor), because of the 'super()' case.
			AccessRestriction restriction =
				scope.environment().getAccessRestriction(method.declaringClass.erasure());
			if (restriction != null && (this.bits & ASTNode.InsideJavadoc)== 0) {
				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=204234
				// access restriction inside javadoc should have already been warned on Type
				// @see ASTNode#isTypeUseDeprecated(TypeBinding, Scope)
				scope.problemReporter().forbiddenReference(method, this,
						restriction.classpathEntryType, restriction.classpathEntryName,
						restriction.getProblemId());

	}

	/* Answer true if the type use is considered deprecated.
	 * An access in the same compilation unit is allowed.
	 */
	public final boolean isTypeUseDeprecated(TypeBinding type, Scope scope) {

		if (type.isArrayType()) {

		if (refType.hasRestrictedAccess()) {
			AccessRestriction restriction = scope.environment().getAccessRestriction(type.erasure());
			if (restriction != null) {
				if ((this.bits & ASTNode.InsideJavadoc)!= 0) {
					// https://bugs.eclipse.org/bugs/show_bug.cgi?id=204234
					// access restriction inside javadoc requires dedicated message
					scope.problemReporter().javadocForbiddenReference(this.sourceStart, this.sourceEnd, scope.getDeclarationModifiers());
				} else {
					scope.problemReporter().forbiddenReference(type, this, restriction.classpathEntryType,
							restriction.classpathEntryName, restriction.getProblemId());
				}
			}
		}


Lines 376-381 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (+1 lines)
376	460 = Empty block should be documented	376	460 = Empty block should be documented
377		377
378	### DOC	378	### DOC
		379	461 = Reference not visible due to access restriction
379	462 = Invalid URL reference. Double quote the reference or use the href syntax	380	462 = Invalid URL reference. Double quote the reference or use the href syntax
380	463 = Description expected after this reference	381	463 = Description expected after this reference
381	464 = Unexpected duplicated tag @{0}	382	464 = Unexpected duplicated tag @{0}

Lines 290-295 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (+8 lines)
290	case IProblem.JavadocHiddenReference:	290	case IProblem.JavadocHiddenReference:
291	case IProblem.JavadocMissingTagDescription:	291	case IProblem.JavadocMissingTagDescription:
292	case IProblem.JavadocInvalidSeeUrlReference:	292	case IProblem.JavadocInvalidSeeUrlReference:
		293	case IProblem.JavadocForbiddenReference:
293	return CompilerOptions.InvalidJavadoc;	294	return CompilerOptions.InvalidJavadoc;
294		295
295	case IProblem.JavadocMissingParamTag:	296	case IProblem.JavadocMissingParamTag:
Lines 1122-1127 Link Here
1122	case IProblem.JavadocNotVisibleMethod:	1123	case IProblem.JavadocNotVisibleMethod:
1123	case IProblem.JavadocNotVisibleType:	1124	case IProblem.JavadocNotVisibleType:
1124	case IProblem.JavadocHiddenReference:	1125	case IProblem.JavadocHiddenReference:
		1126	case IProblem.JavadocForbiddenReference:
1125	if (!(this.options.reportInvalidJavadocTags && this.options.reportInvalidJavadocTagsNotVisibleRef)) {	1127	if (!(this.options.reportInvalidJavadocTags && this.options.reportInvalidJavadocTagsNotVisibleRef)) {
1126	return ProblemSeverities.Ignore;	1128	return ProblemSeverities.Ignore;
1127	}	1129	}
Lines 3935-3940 Link Here
3935	messageSend.sourceEnd);	3937	messageSend.sourceEnd);
3936	}	3938	}
3937	}	3939	}
		3940	public void javadocForbiddenReference(int sourceStart, int sourceEnd, int modifiers){
		3941	if (!javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) return;
		3942	int severity = computeSeverity(IProblem.JavadocForbiddenReference);
		3943	if (severity == ProblemSeverities.Ignore) return;
		3944	this.handle(IProblem.JavadocForbiddenReference, NoArgument, NoArgument, sourceStart, sourceEnd);
		3945	}
3938	public void javadocHiddenReference(int sourceStart, int sourceEnd, Scope scope, int modifiers) {	3946	public void javadocHiddenReference(int sourceStart, int sourceEnd, Scope scope, int modifiers) {
3939	Scope currentScope = scope;	3947	Scope currentScope = scope;
3940	while (currentScope.parent.kind != Scope.COMPILATION_UNIT_SCOPE ) {	3948	while (currentScope.parent.kind != Scope.COMPILATION_UNIT_SCOPE ) {

Lines 822-827 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (+5 lines)
822	* Javadoc comments	822	* Javadoc comments
823	*/	823	*/
824	/**	824	/**
		825	* Problem warned on a restricted access reference.
		826	* @since 3.5
		827	*/
		828	int JavadocForbiddenReference = Javadoc + Internal + 461;
		829	/**
825	* Problem signaled on an invalid URL reference.	830	* Problem signaled on an invalid URL reference.
826	* Valid syntax example: @see "http://www.eclipse.org/"	831	* Valid syntax example: @see "http://www.eclipse.org/"
827	* @since 3.4	832	* @since 3.4




import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;

import junit.framework.Test;


import org.eclipse.jdt.internal.compiler.batch.ClasspathLocation;
import org.eclipse.jdt.internal.compiler.batch.Main;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

public class BatchCompilerTest extends AbstractRegressionTest {
	public static final String OUTPUT_DIR_PLACEHOLDER = "---OUTPUT_DIR_PLACEHOLDER---";

	}
}

/*
 * Return the custom compiler options handled by ExtraCompilerArguments
 * or null when dealing with simple command line arguments (@see ExtraCompilerArguments class).
 */
private Map getCompilerOptions(Object extraArguments) {
	if (extraArguments instanceof ExtraCompilerArguments) {
		return ((ExtraCompilerArguments) extraArguments).customCompilerOptions; 
	}
	// we may want to return null when no extra compiler options were specified
	return null;
}

/*
 * Return the command line arguments handled by ExtraCompilerArguments
 * or the extraArguments as a String (@see ExtraCompilerArguments class).
 */
private String getExtraArguments(Object extraArguments) {
	if (extraArguments instanceof ExtraCompilerArguments) {
		return ((ExtraCompilerArguments) extraArguments).extraArguments; 
	}
	return (String) extraArguments;
}

private String getLibraryClassesAsQuotedString() {
	String[] paths = Util.getJavaClassLibs();
	StringBuffer buffer = new StringBuffer();

			// (need appropriate exception)
			assertEquals(
					"Unexpected standard output for invocation with arguments ["
						+ getExtraArguments(extraArguments) + "]",
					expectedOutOutputString,
					outOutputString);
		}
		if (!errCompareOK) {
			assertEquals(
					"Unexpected error output for invocation with arguments ["
						+ getExtraArguments(extraArguments) + "]",
					expectedErrOutputString,
					errOutputString);
		}

// in this case, extraArguments is expected to hold a command line (as a String)
protected boolean invokeCompiler(PrintWriter out, PrintWriter err, Object extraArguments, TestCompilationProgress compilationProgress) {
	try {
		final String[] tokenizedCommandLine = Main.tokenize(getExtraArguments(extraArguments));
		return new Main(out, err, false, getCompilerOptions(extraArguments) /* customDefaultOptions */, compilationProgress /* compilationProgress*/).compile(tokenizedCommandLine);
	} catch (RuntimeException e) {
		System.out.println(getClass().getName() + '#' + getName());
		e.printStackTrace();

static final Matcher ONE_FILE_GENERATED_MATCHER = new SubstringMatcher("[1 .class file generated]");
static final Matcher TWO_FILES_GENERATED_MATCHER = new SubstringMatcher("[2 .class files generated]");
	/**
	 * Place holder for extra compiler arguments.
	 * These can be command line arguments combined with custom options 
	 */
	static class ExtraCompilerArguments {
		protected String extraArguments;
		protected Map customCompilerOptions;
		/**
		 * Getter for the custom compiler options.
		 * When none were set, will retrieve the default compiler options {@link CompilerOptions#getMap()}
		 * @return Map the map of custom compiler options.
		 */
		public Map getCustomOptions() {
			return this.customCompilerOptions == null ? this.customCompilerOptions = new CompilerOptions().getMap() : this.customCompilerOptions;
		}
	}	

	/**
	 * Abstract normalizer for output comparison. This class merely embodies a
	 * chain of responsibility, plus the signature of the method of interest
	 * here, that is {@link #normalized(String) normalized}.

        "incorrect classpath: p/Y.class\n",
        false/*shouldFlushOutput*/);
}
/**
 * @bug 204234: [javadoc] AccessRestriction compiler error in JavaDoc
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=204234"
 * An array of 5 tests that uses a combination of command line arguments
 * and compiler options (javadoc report invalid reference visibility)
 * Disable doc comment support in the last test (no warning expected)
 */
public void test285_accessRestrictedReference_in_javadoc() {
	String[] units = new String[] {
			"pkg1/X.java",
			"package pkg1;\n" + 
			"\n" + 
			"public class X {\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" + 
			"	 */\n" + 
			"	private String foo;\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" +  
			"	 */\n" + 
			"	public String bar;\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" + 
			"	 */\n" + 
			"	String fooBar;\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	private void foo() {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	protected void bar() {\n" + 
			"	\n" + 	
			"	}\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	public void fooBar() {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" +  
			"	 */\n" + 
			"	private class foo {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" + 
			"	 */\n" + 
			"	class bar {\n" + 
			"	\n" + 	
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" + 
			"	 */\n" + 
			"	public class fooBar {\n" + 
			"	}\n" + 
			"}",
			"pkg2/Y.java",
			"package pkg2;\n" +
			"\n" +
			"public class Y {" +
			"	public String E;" +
			"	public void foo() {}" +
			"}\n"
	};
	
	String expectedWarnings = 
		"----------\n" + 
		"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 9)\n" + 
		"	* test field declaration visibility {@link pkg2.Y#E}\n" + 
		"	                                           ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 28)\n" + 
		"	* test method declaration visibility {@link pkg2.Y#foo()}\n" + 
		"	                                            ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"3. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 44)\n" + 
		"	* test type declaration visibility {@link pkg2.Y}\n" + 
		"	                                          ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"3 problems (3 warnings)";
	
	String commandLineArgs =  "\"" + OUTPUT_DIR +  File.separator + "pkg1" +  File.separator + "X.java\""
    + " -g -preserveAllLocals -warn:-unusedLocal,-unusedPrivate"
    + " -proc:none -cp \"" + OUTPUT_DIR + "[-pkg2/Y]"
    + "\"" + File.pathSeparator
    + " -proceedOnError -d \"" + OUTPUT_DIR + "\"";
	
	ExtraCompilerArguments arguments = new ExtraCompilerArguments();
	// set command line options
	arguments.extraArguments = commandLineArgs;
	// set custom options
	Map customOptions = arguments.getCustomOptions();
	// javadoc
	customOptions.put(CompilerOptions.OPTION_DocCommentSupport, CompilerOptions.ENABLED);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadoc, CompilerOptions.WARNING);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTags, CompilerOptions.ENABLED);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTagsNotVisibleRef, CompilerOptions.ENABLED);
	// report invalid reference visibility: PUBLIC
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTagsVisibility, CompilerOptions.PUBLIC);
	// compiler
	customOptions.put(CompilerOptions.OPTION_ReportForbiddenReference, CompilerOptions.ERROR);
	
	// run test
	runTest(true, units, arguments, "", expectedWarnings, true, null);
}
public void test286_accessRestrictedReference_in_javadoc() {
	String[] units = new String[] {
			"pkg1/X.java",
			"package pkg1;\n" + 
			"\n" + 
			"public class X {\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" + 
			"	 */\n" + 
			"	private String foo;\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" +  
			"	 */\n" + 
			"	public String bar;\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" + 
			"	 */\n" + 
			"	String fooBar;\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	private void foo() {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	protected void bar() {\n" + 
			"	\n" + 	
			"	}\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	public void fooBar() {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" +  
			"	 */\n" + 
			"	private class foo {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" + 
			"	 */\n" + 
			"	class bar {\n" + 
			"	\n" + 	
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" + 
			"	 */\n" + 
			"	public class fooBar {\n" + 
			"	}\n" + 
			"}",
			"pkg2/Y.java",
			"package pkg2;\n" +
			"\n" +
			"public class Y {" +
			"	public String E;" +
			"	public void foo() {}" +
			"}\n"
	};
	
	String expectedWarnings = 
		"----------\n" + 
		"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 5)\n" + 
		"	* test field declaration visibility {@link pkg2.Y#E}\n" + 
		"	                                           ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 9)\n" + 
		"	* test field declaration visibility {@link pkg2.Y#E}\n" + 
		"	                                           ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"3. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 13)\n" + 
		"	* test field declaration visibility {@link pkg2.Y#E}\n" + 
		"	                                           ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"4. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 17)\n" + 
		"	* test method declaration visibility {@link pkg2.Y#foo()}\n" + 
		"	                                            ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"5. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 22)\n" + 
		"	* test method declaration visibility {@link pkg2.Y#foo()}\n" + 
		"	                                            ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"6. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 28)\n" + 
		"	* test method declaration visibility {@link pkg2.Y#foo()}\n" + 
		"	                                            ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"7. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 33)\n" + 
		"	* test type declaration visibility {@link pkg2.Y}\n" + 
		"	                                          ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"8. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 38)\n" + 
		"	* test type declaration visibility {@link pkg2.Y}\n" + 
		"	                                          ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"9. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 44)\n" + 
		"	* test type declaration visibility {@link pkg2.Y}\n" + 
		"	                                          ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"9 problems (9 warnings)";
	
	String commandLineArgs =  "\"" + OUTPUT_DIR +  File.separator + "pkg1" +  File.separator + "X.java\""
    + " -g -preserveAllLocals -warn:-unusedLocal,-unusedPrivate"
    + " -proc:none -cp \"" + OUTPUT_DIR + "[-pkg2/Y]"
    + "\"" + File.pathSeparator
    + " -proceedOnError -d \"" + OUTPUT_DIR + "\"";
	
	ExtraCompilerArguments arguments = new ExtraCompilerArguments();
	// set command line options
	arguments.extraArguments = commandLineArgs;
	// set custom options
	Map customOptions = arguments.getCustomOptions();
	// javadoc
	customOptions.put(CompilerOptions.OPTION_DocCommentSupport, CompilerOptions.ENABLED);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadoc, CompilerOptions.WARNING);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTags, CompilerOptions.ENABLED);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTagsNotVisibleRef, CompilerOptions.ENABLED);
	// report invalid reference visibility: PRIVATE
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTagsVisibility, CompilerOptions.PRIVATE);
	// compiler
	customOptions.put(CompilerOptions.OPTION_ReportForbiddenReference, CompilerOptions.ERROR);
	
	// run test
	runTest(true, units, arguments, "", expectedWarnings, true, null);
}
public void test287_accessRestrictedReference_in_javadoc() {
	String[] units = new String[] {
			"pkg1/X.java",
			"package pkg1;\n" + 
			"\n" + 
			"public class X {\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" + 
			"	 */\n" + 
			"	private String foo;\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" +  
			"	 */\n" + 
			"	public String bar;\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" + 
			"	 */\n" + 
			"	String fooBar;\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	private void foo() {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	protected void bar() {\n" + 
			"	\n" + 	
			"	}\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	public void fooBar() {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" +  
			"	 */\n" + 
			"	private class foo {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" + 
			"	 */\n" + 
			"	class bar {\n" + 
			"	\n" + 	
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" + 
			"	 */\n" + 
			"	public class fooBar {\n" + 
			"	}\n" + 
			"}",
			"pkg2/Y.java",
			"package pkg2;\n" +
			"\n" +
			"public class Y {" +
			"	public String E;" +
			"	public void foo() {}" +
			"}\n"
	};
	
	String expectedWarnings = 
		"----------\n" + 
		"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 9)\n" + 
		"	* test field declaration visibility {@link pkg2.Y#E}\n" + 
		"	                                           ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 22)\n" + 
		"	* test method declaration visibility {@link pkg2.Y#foo()}\n" + 
		"	                                            ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"3. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 28)\n" + 
		"	* test method declaration visibility {@link pkg2.Y#foo()}\n" + 
		"	                                            ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"4. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 44)\n" + 
		"	* test type declaration visibility {@link pkg2.Y}\n" + 
		"	                                          ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"4 problems (4 warnings)";
	
	String commandLineArgs =  "\"" + OUTPUT_DIR +  File.separator + "pkg1" +  File.separator + "X.java\""
    + " -g -preserveAllLocals -warn:-unusedLocal,-unusedPrivate"
    + " -proc:none -cp \"" + OUTPUT_DIR + "[-pkg2/Y]"
    + "\"" + File.pathSeparator
    + " -proceedOnError -d \"" + OUTPUT_DIR + "\"";
	
	ExtraCompilerArguments arguments = new ExtraCompilerArguments();
	// set command line options
	arguments.extraArguments = commandLineArgs;
	// set custom options
	Map customOptions = arguments.getCustomOptions();
	// javadoc
	customOptions.put(CompilerOptions.OPTION_DocCommentSupport, CompilerOptions.ENABLED);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadoc, CompilerOptions.WARNING);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTags, CompilerOptions.ENABLED);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTagsNotVisibleRef, CompilerOptions.ENABLED);
	// report invalid reference visibility: PROTECTED
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTagsVisibility, CompilerOptions.PROTECTED);
	// compiler
	customOptions.put(CompilerOptions.OPTION_ReportForbiddenReference, CompilerOptions.ERROR);
	
	// run test
	runTest(true, units, arguments, "", expectedWarnings, true, null);
}
public void test288_accessRestrictedReference_in_javadoc() {
	String[] units = new String[] {
			"pkg1/X.java",
			"package pkg1;\n" + 
			"\n" + 
			"public class X {\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" + 
			"	 */\n" + 
			"	private String foo;\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" +  
			"	 */\n" + 
			"	public String bar;\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" + 
			"	 */\n" + 
			"	String fooBar;\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	private void foo() {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	protected void bar() {\n" + 
			"	\n" + 	
			"	}\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	public void fooBar() {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" +  
			"	 */\n" + 
			"	private class foo {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" + 
			"	 */\n" + 
			"	class bar {\n" + 
			"	\n" + 	
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" + 
			"	 */\n" + 
			"	public class fooBar {\n" + 
			"	}\n" + 
			"}",
			"pkg2/Y.java",
			"package pkg2;\n" +
			"\n" +
			"public class Y {" +
			"	public String E;" +
			"	public void foo() {}" +
			"}\n"
	};
	
	String expectedWarnings = 
		"----------\n" + 
		"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 9)\n" + 
		"	* test field declaration visibility {@link pkg2.Y#E}\n" + 
		"	                                           ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 13)\n" + 
		"	* test field declaration visibility {@link pkg2.Y#E}\n" + 
		"	                                           ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"3. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 22)\n" + 
		"	* test method declaration visibility {@link pkg2.Y#foo()}\n" + 
		"	                                            ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"4. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 28)\n" + 
		"	* test method declaration visibility {@link pkg2.Y#foo()}\n" + 
		"	                                            ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"5. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 38)\n" + 
		"	* test type declaration visibility {@link pkg2.Y}\n" + 
		"	                                          ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"6. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/pkg1/X.java (at line 44)\n" + 
		"	* test type declaration visibility {@link pkg2.Y}\n" + 
		"	                                          ^^^^^^\n" + 
		"Javadoc: Reference not visible due to access restriction\n" + 
		"----------\n" + 
		"6 problems (6 warnings)";
	
	String commandLineArgs =  "\"" + OUTPUT_DIR +  File.separator + "pkg1" +  File.separator + "X.java\""
    + " -g -preserveAllLocals -warn:-unusedLocal,-unusedPrivate"
    + " -proc:none -cp \"" + OUTPUT_DIR + "[-pkg2/Y]"
    + "\"" + File.pathSeparator
    + " -proceedOnError -d \"" + OUTPUT_DIR + "\"";
	
	ExtraCompilerArguments arguments = new ExtraCompilerArguments();
	// set command line options
	arguments.extraArguments = commandLineArgs;
	// set custom options
	Map customOptions = arguments.getCustomOptions();
	// javadoc
	customOptions.put(CompilerOptions.OPTION_DocCommentSupport, CompilerOptions.ENABLED);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadoc, CompilerOptions.WARNING);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTags, CompilerOptions.ENABLED);
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTagsNotVisibleRef, CompilerOptions.ENABLED);
	// report invalid reference visibility: DEFAULT
	customOptions.put(CompilerOptions.OPTION_ReportInvalidJavadocTagsVisibility, CompilerOptions.DEFAULT);
	// compiler
	customOptions.put(CompilerOptions.OPTION_ReportForbiddenReference, CompilerOptions.ERROR);
	
	// run test
	runTest(true, units, arguments, "", expectedWarnings, true, null);
}
public void test289_accessRestrictedReference_in_javadoc() {
	// no warning expected as we do not validate javadoc content
	String[] units = new String[] {
			"pkg1/X.java",
			"package pkg1;\n" + 
			"\n" + 
			"public class X {\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" + 
			"	 */\n" + 
			"	private String foo;\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" +  
			"	 */\n" + 
			"	public String bar;\n" + 
			"	/**\n" + 
			"	 * test field declaration visibility {@link pkg2.Y#E}\n" + 
			"	 */\n" + 
			"	String fooBar;\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	private void foo() {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	protected void bar() {\n" + 
			"	\n" + 	
			"	}\n" + 
			"	/**\n" + 
			"	 * test method declaration visibility {@link pkg2.Y#foo()}\n" + 
			"	 */\n" + 
			"	public void fooBar() {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" +  
			"	 */\n" + 
			"	private class foo {\n" + 
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" + 
			"	 */\n" + 
			"	class bar {\n" + 
			"	\n" + 	
			"	}\n" + 
			"	/**\n" + 
			"	 * test type declaration visibility {@link pkg2.Y}\n" + 
			"	 */\n" + 
			"	public class fooBar {\n" + 
			"	}\n" + 
			"}",
			"pkg2/Y.java",
			"package pkg2;\n" +
			"\n" +
			"public class Y {" +
			"	public String E;" +
			"	public void foo() {}" +
			"}\n"
	};
	String commandLineArgs =  "\"" + OUTPUT_DIR +  File.separator + "pkg1" +  File.separator + "X.java\""
    + " -g -preserveAllLocals -warn:-unusedLocal,-unusedPrivate"
    + " -proc:none -cp \"" + OUTPUT_DIR + "[-pkg2/Y]"
    + "\"" + File.pathSeparator
    + " -proceedOnError -d \"" + OUTPUT_DIR + "\"";
	
	ExtraCompilerArguments arguments = new ExtraCompilerArguments();
	// set command line options
	arguments.extraArguments = commandLineArgs;
		
	// run test
	runTest(true, units, arguments, "", "", true, null);
}
}

Return to bug 204234

Lines 348-369 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java (-12 / +24 lines)
348	// ignore cases where field is used from within inside itself	348	// ignore cases where field is used from within inside itself
349	field.original().modifiers \|= ExtraCompilerModifiers.AccLocallyUsed;	349	field.original().modifiers \|= ExtraCompilerModifiers.AccLocallyUsed;
350	}	350	}
351		351
352	if ((field.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0) {	352	if ((field.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0) {
353	AccessRestriction restriction =	353	AccessRestriction restriction =
354	scope.environment().getAccessRestriction(field.declaringClass.erasure());	354	scope.environment().getAccessRestriction(field.declaringClass.erasure());
355	if (restriction != null) {	355	if (restriction != null && (this.bits & ASTNode.InsideJavadoc)== 0) {
		356	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=204234
		357	// access restriction inside javadoc should have already been warned on Type
		358	// @see ASTNode#isTypeUseDeprecated(TypeBinding, Scope)
356	scope.problemReporter().forbiddenReference(field, this,	359	scope.problemReporter().forbiddenReference(field, this,
357	restriction.classpathEntryType, restriction.classpathEntryName,	360	restriction.classpathEntryType, restriction.classpathEntryName,
358	restriction.getProblemId());	361	restriction.getProblemId());
359	}	362	}
360	}	363	}
361		364
362	if (!field.isViewedAsDeprecated()) return false;	365	if (!field.isViewedAsDeprecated()) return false;
363		366
364	// inside same unit - no report	367	// inside same unit - no report
365	if (scope.isDefinedInSameUnit(field.declaringClass)) return false;	368	if (scope.isDefinedInSameUnit(field.declaringClass)) return false;
366		369
367	// if context is deprecated, may avoid reporting	370	// if context is deprecated, may avoid reporting
368	if (!scope.compilerOptions().reportDeprecationInsideDeprecatedCode && scope.isInsideDeprecatedCode()) return false;	371	if (!scope.compilerOptions().reportDeprecationInsideDeprecatedCode && scope.isInsideDeprecatedCode()) return false;
369	return true;	372	return true;
Lines 375-382 Link Here
375	}	378	}
376		379
377	/* Answer true if the method use is considered deprecated.	380	/* Answer true if the method use is considered deprecated.
378	* An access in the same compilation unit is allowed.	381	* An access in the same compilation unit is allowed.
379	*/	382	*/
380	public final boolean isMethodUseDeprecated(MethodBinding method, Scope scope,	383	public final boolean isMethodUseDeprecated(MethodBinding method, Scope scope,
381	boolean isExplicitUse) {	384	boolean isExplicitUse) {
382	// ignore references insing Javadoc comments	385	// ignore references insing Javadoc comments
Lines 393-399 Link Here
393	// warnings, one on type, the other on constructor), because of the 'super()' case.	396	// warnings, one on type, the other on constructor), because of the 'super()' case.
394	AccessRestriction restriction =	397	AccessRestriction restriction =
395	scope.environment().getAccessRestriction(method.declaringClass.erasure());	398	scope.environment().getAccessRestriction(method.declaringClass.erasure());
396	if (restriction != null) {	399	if (restriction != null && (this.bits & ASTNode.InsideJavadoc)== 0) {
		400	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=204234
		401	// access restriction inside javadoc should have already been warned on Type
		402	// @see ASTNode#isTypeUseDeprecated(TypeBinding, Scope)
397	scope.problemReporter().forbiddenReference(method, this,	403	scope.problemReporter().forbiddenReference(method, this,
398	restriction.classpathEntryType, restriction.classpathEntryName,	404	restriction.classpathEntryType, restriction.classpathEntryName,
399	restriction.getProblemId());	405	restriction.getProblemId());
Lines 427-434 Link Here
427	}	433	}
428		434
429	/* Answer true if the type use is considered deprecated.	435	/* Answer true if the type use is considered deprecated.
430	* An access in the same compilation unit is allowed.	436	* An access in the same compilation unit is allowed.
431	*/	437	*/
432	public final boolean isTypeUseDeprecated(TypeBinding type, Scope scope) {	438	public final boolean isTypeUseDeprecated(TypeBinding type, Scope scope) {
433		439
434	if (type.isArrayType()) {	440	if (type.isArrayType()) {
Lines 448-455 Link Here
448	if (refType.hasRestrictedAccess()) {	454	if (refType.hasRestrictedAccess()) {
449	AccessRestriction restriction = scope.environment().getAccessRestriction(type.erasure());	455	AccessRestriction restriction = scope.environment().getAccessRestriction(type.erasure());
450	if (restriction != null) {	456	if (restriction != null) {
451	scope.problemReporter().forbiddenReference(type, this, restriction.classpathEntryType,	457	if ((this.bits & ASTNode.InsideJavadoc)!= 0) {
452	restriction.classpathEntryName, restriction.getProblemId());	458	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=204234
		459	// access restriction inside javadoc requires dedicated message
		460	scope.problemReporter().javadocForbiddenReference(this.sourceStart, this.sourceEnd, scope.getDeclarationModifiers());
		461	} else {
		462	scope.problemReporter().forbiddenReference(type, this, restriction.classpathEntryType,
		463	restriction.classpathEntryName, restriction.getProblemId());
		464	}
453	}	465	}
454	}	466	}
455		467

Lines 702-707 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java (+2 lines)
702	expectedProblemAttributes.put("JavadocInvalidValueReference", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));	702	expectedProblemAttributes.put("JavadocInvalidValueReference", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
703	expectedProblemAttributes.put("JavadocUnexpectedText", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));	703	expectedProblemAttributes.put("JavadocUnexpectedText", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
704	expectedProblemAttributes.put("JavadocInvalidParamTagName", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));	704	expectedProblemAttributes.put("JavadocInvalidParamTagName", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		705	expectedProblemAttributes.put("JavadocForbiddenReference", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
705	expectedProblemAttributes.put("DuplicateTypeVariable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	706	expectedProblemAttributes.put("DuplicateTypeVariable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
706	expectedProblemAttributes.put("IllegalTypeVariableSuperReference", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	707	expectedProblemAttributes.put("IllegalTypeVariableSuperReference", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
707	expectedProblemAttributes.put("NonStaticTypeFromStaticInvocation", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	708	expectedProblemAttributes.put("NonStaticTypeFromStaticInvocation", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
Lines 1311-1316 Link Here
1311	expectedProblemAttributes.put("JavadocInvalidValueReference", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));	1312	expectedProblemAttributes.put("JavadocInvalidValueReference", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
1312	expectedProblemAttributes.put("JavadocUnexpectedText", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));	1313	expectedProblemAttributes.put("JavadocUnexpectedText", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
1313	expectedProblemAttributes.put("JavadocInvalidParamTagName", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));	1314	expectedProblemAttributes.put("JavadocInvalidParamTagName", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		1315	expectedProblemAttributes.put("JavadocForbiddenReference", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
1314	expectedProblemAttributes.put("DuplicateTypeVariable", SKIP);	1316	expectedProblemAttributes.put("DuplicateTypeVariable", SKIP);
1315	expectedProblemAttributes.put("IllegalTypeVariableSuperReference", SKIP);	1317	expectedProblemAttributes.put("IllegalTypeVariableSuperReference", SKIP);
1316	expectedProblemAttributes.put("NonStaticTypeFromStaticInvocation", SKIP);	1318	expectedProblemAttributes.put("NonStaticTypeFromStaticInvocation", SKIP);