JDK_1_5-Merge with HEAD: v_411a
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest2.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest2.java
index e316b20..0ebe2a9 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest2.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest2.java
@@ -7713,4 +7713,73 @@
expectedReplacedSource,
"diet ast");
}
+/*
+ * https://bugs.eclipse.org/bugs/show_bug.cgi?id=53624
+ */
+public void test0137(){
+ String str =
+ "public class X {\n" +
+ " void foo(){\n" +
+ " new Object(){\n" +
+ " void bar(){\n" +
+ " super.zzz();\n" +
+ " }\n" +
+ " };\n" +
+ " }\n" +
+ "}\n";
+
+
+ String completeBehind = "zzz(";
+ int cursorLocation = str.indexOf("zzz(") + completeBehind.length() - 1;
+ String expectedCompletionNodeToString = "<NONE>";
+ String expectedParentNodeToString = "<NONE>";
+ String completionIdentifier = "<NONE>";
+ String expectedReplacedSource = "<NONE>";
+ String expectedUnitDisplayString =
+ "public class X {\n" +
+ " public X() {\n" +
+ " }\n" +
+ " void foo() {\n" +
+ " }\n" +
+ "}\n";
+
+ checkDietParse(
+ str.toCharArray(),
+ cursorLocation,
+ expectedCompletionNodeToString,
+ expectedParentNodeToString,
+ expectedUnitDisplayString,
+ completionIdentifier,
+ expectedReplacedSource,
+ "diet ast");
+
+ expectedCompletionNodeToString = "<CompleteOnMessageSend:super.zzz()>";
+ expectedParentNodeToString = "<NONE>";
+ completionIdentifier = "";
+ expectedReplacedSource = "zzz(";
+ expectedUnitDisplayString =
+ "public class X {\n" +
+ " public X() {\n" +
+ " }\n" +
+ " void foo() {\n" +
+ " new Object() {\n" +
+ " () {\n" +
+ " }\n" +
+ " void bar() {\n" +
+ " <CompleteOnMessageSend:super.zzz()>;\n" +
+ " }\n" +
+ " };\n" +
+ " }\n" +
+ "}\n";
+
+ checkMethodParse(
+ str.toCharArray(),
+ cursorLocation,
+ expectedCompletionNodeToString,
+ expectedParentNodeToString,
+ expectedUnitDisplayString,
+ completionIdentifier,
+ expectedReplacedSource,
+ "full ast");
+}
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTest.java
index 0688e77..23b656c 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTest.java
@@ -10,250 +10,405 @@
*******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Map;
+import java.util.StringTokenizer;
import junit.framework.Test;
import junit.framework.TestSuite;
+import org.eclipse.jdt.core.tests.util.AbstractCompilerTest;
+import org.eclipse.jdt.core.tests.util.CompilerTestSetup;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
public abstract class JavadocTest extends AbstractRegressionTest {
+
+ boolean useLibrary = false;
+ static String zipFile = "/TestJavadocVisibility.zip";
+ static final String LINE_SEPARATOR = System.getProperty("line.separator");
+ public static ArrayList allTestClasses = null;
+ static final String DOC_COMMENT_SUPPORT = System.getProperty("doc.support");
+// String docCommentSupport;
+ boolean supportJavadoc;
+ static boolean debug = true;
+ static String[] testNames = null;
+ static int[] testNumbers = null;
+ static int[] testRange = null;
+
+ static {
+ allTestClasses = new ArrayList(6);
+ allTestClasses.add(JavadocTestForClass.class);
+ allTestClasses.add(JavadocTestForConstructor.class);
+ allTestClasses.add(JavadocTestForField.class);
+ allTestClasses.add(JavadocTestForInterface.class);
+ allTestClasses.add(JavadocTestForMethod.class);
+ allTestClasses.add(JavadocTestMixed.class);
+ allTestClasses.add(JavadocTestOptions.class);
+ }
-boolean useLibrary = false;
-static String zipFile = "/TestJavadocVisibility.zip";
-static final String LINE_SEPARATOR = System.getProperty("line.separator");
-public static ArrayList allTestClasses = null;
-
-static {
- allTestClasses = new ArrayList(6);
- allTestClasses.add(JavadocTestForClass.class);
- allTestClasses.add(JavadocTestForConstructor.class);
- allTestClasses.add(JavadocTestForField.class);
- allTestClasses.add(JavadocTestForInterface.class);
- allTestClasses.add(JavadocTestForMethod.class);
- allTestClasses.add(JavadocTestMixed.class);
- allTestClasses.add(JavadocTestOptions.class);
-}
-
-
-public static void addTest(TestSuite suite, Class testClass) {
- TestSuite innerSuite = new TestSuite(testClass);
- suite.addTest(innerSuite);
-}
-public static Test suite() {
- TestSuite suite = new TestSuite(JavadocTest.class.getName());
- for (int i=0; i<allTestClasses.size(); i++) {
- addTest(suite, (Class) allTestClasses.get(i));
+
+ public static void addTest(TestSuite suite, Class testClass) {
+ TestSuite innerSuite = new TestSuite(testClass);
+ suite.addTest(innerSuite);
}
- return new RegressionTestSetup(suite, COMPLIANCE_1_4);
-}
-public JavadocTest(String name) {
- super(name);
-}
-
-public static boolean equals(String c, String s) {
- if (c == null) {
- if (s == null)
- return true;
- else
- return false;
+ public static Test buildSuite(Class testClass) {
+ TestSuite suite = new TestSuite(testClass.getName());
+ int complianceLevels = AbstractCompilerTest.getPossibleComplianceLevels();
+ if ((complianceLevels & AbstractCompilerTest.F_1_3) != 0) {
+ suite.addTest(suiteForComplianceLevel(COMPLIANCE_1_3, testClass));
+ }
+ if ((complianceLevels & AbstractCompilerTest.F_1_4) != 0) {
+ suite.addTest(suiteForComplianceLevel(COMPLIANCE_1_4, testClass));
+ }
+ if ((complianceLevels & AbstractCompilerTest.F_1_5) != 0) {
+ suite.addTest(suiteForComplianceLevel(COMPLIANCE_1_5, testClass));
+ }
+ return suite;
}
- return c.equals(s);
-}
+
+ public static Test suiteForComplianceLevel(String level, Class testClass) {
+ TestSuite suite = new TestSuite(level);
+ try {
+// Class[] paramTypes = new Class[] { String.class, String.class };
+ Class[] paramTypes = new Class[] { String.class };
+ Constructor constructor = testClass.getConstructor(paramTypes);
+ // Javadoc ENABLED
+ String support = CompilerOptions.DISABLED;
+ if (DOC_COMMENT_SUPPORT == null) {
+ suite.addTest(suiteForJavadocSupport(level, testClass, constructor, CompilerOptions.ENABLED));
+// suiteForJavadocSupport(suite, testClass, constructor, CompilerOptions.ENABLED);
+ } else {
+ support = DOC_COMMENT_SUPPORT;
+ }
-protected Map getCompilerOptions() {
- Map options = super.getCompilerOptions();
- options.put(CompilerOptions.OPTION_ReportFieldHiding, CompilerOptions.IGNORE);
- options.put(CompilerOptions.OPTION_ReportSyntheticAccessEmulation, CompilerOptions.IGNORE);
- return options;
-}
-
-protected String[] getDefaultClassPaths() {
- if (useLibrary) {
- String[] classLibs = super.getDefaultClassPaths();
- final int length = classLibs.length;
- String[] newClassPaths = new String[length + 1];
- System.arraycopy(classLibs, 0, newClassPaths, 0, length);
- newClassPaths[length] = getClass().getResource(zipFile).getPath();
- return newClassPaths;
- } else {
- return super.getDefaultClassPaths();
+ // Javadoc DISABLED
+ suite.addTest(suiteForJavadocSupport(level, testClass, constructor, support));
+// suiteForJavadocSupport(suite, testClass, constructor, support);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+// return new RegressionTestSetup(suite, level);
+ return suite;
}
-}
-static String[] referencedClasses = null;
-static {
- referencedClasses =
- new String[] {
- "test/AbstractVisibility.java",
- "package test;\n"
- + "public abstract class AbstractVisibility {\n"
- + " private class AvcPrivate {\n"
- + " private int avf_private = 10;\n"
- + " public int avf_public = avf_private;\n"
- + " private int avm_private() {\n"
- + " avf_private = (new AvcPrivate()).avf_private;\n"
- + " return avf_private;\n"
- + " }\n"
- + " public int avm_public() {\n"
- + " return avm_private();\n"
- + " }\n"
- + " }\n"
- + " public class AvcPublic {\n"
- + " private int avf_private = 10;\n"
- + " public int avf_public = avf_private;\n"
- + " private int avm_private() {\n"
- + " avf_private = (new AvcPrivate()).avf_private;\n"
- + " return avf_private;\n"
- + " }\n"
- + " public int avm_public() {\n"
- + " return avm_private();\n"
- + " }\n"
- + " }\n"
- + " private int avf_private = 100;\n"
- + " public int avf_public = avf_private;\n"
- + " \n"
- + " private int avm_private() {\n"
- + " avf_private = (new AvcPrivate()).avf_private;\n"
- + " return avf_private;\n"
- + " }\n"
- + " public int avm_public() {\n"
- + " return avm_private();\n"
- + " }\n"
- + "}\n",
- "test/Visibility.java",
- "package test;\n"
- + "public class Visibility extends AbstractVisibility {\n"
- + " private class VcPrivate {\n"
- + " private int vf_private = 10;\n"
- + " public int vf_public = vf_private;\n"
- + " private int vm_private() {\n"
- + " vf_private = (new VcPrivate()).vf_private;\n"
- + " avf_private = vf_private;\n"
- + " return vf_private+avf_private;\n"
- + " }\n"
- + " public int vm_public() {\n"
- + " return vm_private();\n"
- + " }\n"
- + " };\n"
- + " public class VcPublic {\n"
- + " private int vf_private = 10;\n"
- + " public int vf_public = vf_private;\n"
- + " private int vm_private() {\n"
- + " vf_private = (new VcPrivate()).vf_private;\n"
- + " avf_private = vf_private;\n"
- + " return vf_private+avf_private;\n"
- + " }\n"
- + " public int vm_public() {\n"
- + " return vm_private();\n"
- + " }\n"
- + " };\n"
- + " private int vf_private = 100;\n"
- + " private int avf_private = 100;\n"
- + " public int vf_public = vf_private;\n"
- + " public int avf_public = vf_private;\n"
- + " \n"
- + " private int vm_private() {\n"
- + " vf_private = (new VcPrivate()).vf_private;\n"
- + " avf_private = vf_private;\n"
- + " return vf_private+avf_private;\n"
- + " }\n"
- + " public int vm_public() {\n"
- + " return vm_private();\n"
- + " }\n"
- + "}\n",
- "test/copy/VisibilityPackage.java",
- "package test.copy;\n"
- + "class VisibilityPackage {\n"
- + " private class VpPrivate {\n"
- + " private int vf_private = 10;\n"
- + " public int vf_public = vf_private;\n"
- + " private int vm_private() {\n"
- + " vf_private = (new VpPrivate()).vf_private;\n"
- + " return vf_private;\n"
- + " }\n"
- + " public int vm_public() {\n"
- + " return vm_private();\n"
- + " }\n"
- + " }\n"
- + " public class VpPublic {\n"
- + " private int vf_private = 10;\n"
- + " public int vf_public = vf_private;\n"
- + " private int vm_private() {\n"
- + " vf_private = (new VpPrivate()).vf_private;\n"
- + " return vf_private;\n"
- + " }\n"
- + " public int vm_public() {\n"
- + " return vm_private();\n"
- + " }\n"
- + " }\n"
- + " private int vf_private = 100;\n"
- + " public int vf_public = vf_private;\n"
- + " \n"
- + " private int vm_private() {\n"
- + " vf_private = (new VpPrivate()).vf_private;\n"
- + " return vf_private;\n"
- + " }\n"
- + " public int vm_public() {\n"
- + " return vm_private();\n"
- + " }\n"
- + "}\n",
- "test/copy/VisibilityPublic.java",
- "package test.copy;\n"
- + "public class VisibilityPublic {\n"
- + " private class VpPrivate {\n"
- + " private int vf_private = 10;\n"
- + " public int vf_public = vf_private;\n"
- + " private int vm_private() {\n"
- + " vf_private = (new VpPrivate()).vf_private;\n"
- + " return vf_private;\n"
- + " }\n"
- + " public int vm_public() {\n"
- + " return vm_private();\n"
- + " }\n"
- + " }\n"
- + " public class VpPublic {\n"
- + " private int vf_private = 10;\n"
- + " public int vf_public = vf_private;\n"
- + " private int vm_private() {\n"
- + " vf_private = (new VpPrivate()).vf_private;\n"
- + " return vf_private;\n"
- + " }\n"
- + " public int vm_public() {\n"
- + " return vm_private();\n"
- + " }\n"
- + " }\n"
- + " private int vf_private = 100;\n"
- + " public int vf_public = vf_private;\n"
- + " \n"
- + " private int vm_private() {\n"
- + " vf_private = (new VpPrivate()).vf_private;\n"
- + " return vf_private;\n"
- + " }\n"
- + " public int vm_public() {\n"
- + " return vm_private();\n"
- + " }\n"
- + "}\n" };
-}
+ public static Test suiteForJavadocSupport(/*TestSuite suite,*/ String level, Class testClass, Constructor constructor, String support) throws InvocationTargetException, IllegalAccessException, InstantiationException {
+ TestSuite suite = new TestSuite("Doc "+support);
+ if (testNames != null) {
+ for (int i = 0; i < testNames.length; i++) {
+ String meth = "test" + testNames[i];
+// Object[] params = {meth, support};
+ Object[] params = {meth};
+ suite.addTest((Test)constructor.newInstance(params));
+ }
+ }
+ else if (testNumbers != null) {
+ for (int i = 0; i < testNumbers.length; i++) {
+ String meth = "test";
+ int num = testNumbers[i];
+ if (num < 10) meth += "0";
+ if (num < 100) meth += "0";
+ meth += num;
+// Object[] params = {meth, support};
+ Object[] params = {meth};
+ suite.addTest((Test)constructor.newInstance(params));
+ }
+ }
+ else if (testRange != null && testRange.length == 2 && testRange[0]>=0 && testRange[0]<=testRange[1]) {
+ for (int i=testRange[0]; i<=testRange[1]; i++) {
+ String meth = "test";
+ if (i<10) meth += "0";
+ if (i<100) meth += "0";
+ meth += i;
+// Object[] params = {meth, support};
+ Object[] params = {meth};
+ suite.addTest((Test)constructor.newInstance(params));
+ }
+ } else {
+ // Run all tests
+ Method[] methods = testClass.getMethods();
+ for (int i = 0, max = methods.length; i < max; i++) {
+ if (methods[i].getModifiers() == 1 && methods[i].getName().startsWith("test")) { //$NON-NLS-1$
+// Object[] params = {methods[i].getName(), support};
+ Object[] params = {methods[i].getName()};
+ suite.addTest((Test)constructor.newInstance(params));
+ }
+ }
+ }
+// return suite;
+ return new RegressionTestSetup(suite, level, support);
+ }
-protected void runConformReferenceTest(String[] testFiles) {
- String[] completedFiles = testFiles;
- if (!useLibrary) {
- completedFiles = new String[testFiles.length + referencedClasses.length];
- System.arraycopy(referencedClasses, 0, completedFiles, 0, referencedClasses.length);
- System.arraycopy(testFiles, 0, completedFiles, referencedClasses.length, testFiles.length);
+
+ public static Test suite() {
+ TestSuite suite = new TestSuite(JavadocTest.class.getName());
+ for (int i=0; i<allTestClasses.size(); i++) {
+ suite.addTest(buildSuite((Class) allTestClasses.get(i)));
+ }
+ return suite;
}
- runConformTest(completedFiles);
-}
-protected void runNegativeReferenceTest(String[] testFiles, String expected) {
- String[] completedFiles = testFiles;
- if (!useLibrary) {
- completedFiles = new String[testFiles.length + referencedClasses.length];
- System.arraycopy(referencedClasses, 0, completedFiles, 0, referencedClasses.length);
- System.arraycopy(testFiles, 0, completedFiles, referencedClasses.length, testFiles.length);
+
+ public JavadocTest(String name) {
+ this(name, CompilerOptions.ENABLED);
}
- runNegativeTest(completedFiles, expected);
-}
+ public JavadocTest(String name, String support) {
+ super(name);
+ }
+ /**
+ * @return Returns the docCommentSupport.
+ */
+ public String getNamePrefix() {
+ return "Doc "+(this.supportJavadoc?"on":"off")+" - ";
+ }
+ /* (non-Javadoc)
+ * @see junit.framework.TestCase#getName()
+ */
+ public String getName() {
+ if (this.docCommentSupport == null) {
+ return super.getName();
+ } else {
+ return getNamePrefix()+super.getName();
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.core.tests.util.AbstractCompilerTest#initialize(org.eclipse.jdt.core.tests.util.CompilerTestSetup)
+ */
+ public void initialize(CompilerTestSetup setUp) {
+ super.initialize(setUp);
+ this.supportJavadoc = !CompilerOptions.DISABLED.equals(this.docCommentSupport);
+ }
+ protected Map getCompilerOptions() {
+ Map options = super.getCompilerOptions();
+ options.put(CompilerOptions.OPTION_ReportFieldHiding, CompilerOptions.IGNORE);
+ options.put(CompilerOptions.OPTION_ReportSyntheticAccessEmulation, CompilerOptions.IGNORE);
+ options.put(CompilerOptions.OPTION_DocCommentSupport, this.docCommentSupport);
+ return options;
+ }
+
+ protected String[] getDefaultClassPaths() {
+ if (useLibrary) {
+ String[] classLibs = super.getDefaultClassPaths();
+ final int length = classLibs.length;
+ String[] newClassPaths = new String[length + 1];
+ System.arraycopy(classLibs, 0, newClassPaths, 0, length);
+ newClassPaths[length] = getClass().getResource(zipFile).getPath();
+ return newClassPaths;
+ } else {
+ return super.getDefaultClassPaths();
+ }
+ }
+
+ static String[] referencedClasses = null;
+ static {
+ referencedClasses =
+ new String[] {
+ "test/AbstractVisibility.java",
+ "package test;\n"
+ + "public abstract class AbstractVisibility {\n"
+ + " private class AvcPrivate {\n"
+ + " private int avf_private = 10;\n"
+ + " public int avf_public = avf_private;\n"
+ + " private int avm_private() {\n"
+ + " avf_private = (new AvcPrivate()).avf_private;\n"
+ + " return avf_private;\n"
+ + " }\n"
+ + " public int avm_public() {\n"
+ + " return avm_private();\n"
+ + " }\n"
+ + " }\n"
+ + " public class AvcPublic {\n"
+ + " private int avf_private = 10;\n"
+ + " public int avf_public = avf_private;\n"
+ + " private int avm_private() {\n"
+ + " avf_private = (new AvcPrivate()).avf_private;\n"
+ + " return avf_private;\n"
+ + " }\n"
+ + " public int avm_public() {\n"
+ + " return avm_private();\n"
+ + " }\n"
+ + " }\n"
+ + " private int avf_private = 100;\n"
+ + " public int avf_public = avf_private;\n"
+ + " \n"
+ + " private int avm_private() {\n"
+ + " avf_private = (new AvcPrivate()).avf_private;\n"
+ + " return avf_private;\n"
+ + " }\n"
+ + " public int avm_public() {\n"
+ + " return avm_private();\n"
+ + " }\n"
+ + "}\n",
+ "test/Visibility.java",
+ "package test;\n"
+ + "public class Visibility extends AbstractVisibility {\n"
+ + " private class VcPrivate {\n"
+ + " private int vf_private = 10;\n"
+ + " public int vf_public = vf_private;\n"
+ + " private int vm_private() {\n"
+ + " vf_private = (new VcPrivate()).vf_private;\n"
+ + " avf_private = vf_private;\n"
+ + " return vf_private+avf_private;\n"
+ + " }\n"
+ + " public int vm_public() {\n"
+ + " return vm_private();\n"
+ + " }\n"
+ + " };\n"
+ + " public class VcPublic {\n"
+ + " private int vf_private = 10;\n"
+ + " public int vf_public = vf_private;\n"
+ + " private int vm_private() {\n"
+ + " vf_private = (new VcPrivate()).vf_private;\n"
+ + " avf_private = vf_private;\n"
+ + " return vf_private+avf_private;\n"
+ + " }\n"
+ + " public int vm_public() {\n"
+ + " return vm_private();\n"
+ + " }\n"
+ + " };\n"
+ + " private int vf_private = 100;\n"
+ + " private int avf_private = 100;\n"
+ + " public int vf_public = vf_private;\n"
+ + " public int avf_public = vf_private;\n"
+ + " \n"
+ + " private int vm_private() {\n"
+ + " vf_private = (new VcPrivate()).vf_private;\n"
+ + " avf_private = vf_private;\n"
+ + " return vf_private+avf_private;\n"
+ + " }\n"
+ + " public int vm_public() {\n"
+ + " return vm_private();\n"
+ + " }\n"
+ + "}\n",
+ "test/copy/VisibilityPackage.java",
+ "package test.copy;\n"
+ + "class VisibilityPackage {\n"
+ + " private class VpPrivate {\n"
+ + " private int vf_private = 10;\n"
+ + " public int vf_public = vf_private;\n"
+ + " private int vm_private() {\n"
+ + " vf_private = (new VpPrivate()).vf_private;\n"
+ + " return vf_private;\n"
+ + " }\n"
+ + " public int vm_public() {\n"
+ + " return vm_private();\n"
+ + " }\n"
+ + " }\n"
+ + " public class VpPublic {\n"
+ + " private int vf_private = 10;\n"
+ + " public int vf_public = vf_private;\n"
+ + " private int vm_private() {\n"
+ + " vf_private = (new VpPrivate()).vf_private;\n"
+ + " return vf_private;\n"
+ + " }\n"
+ + " public int vm_public() {\n"
+ + " return vm_private();\n"
+ + " }\n"
+ + " }\n"
+ + " private int vf_private = 100;\n"
+ + " public int vf_public = vf_private;\n"
+ + " \n"
+ + " private int vm_private() {\n"
+ + " vf_private = (new VpPrivate()).vf_private;\n"
+ + " return vf_private;\n"
+ + " }\n"
+ + " public int vm_public() {\n"
+ + " return vm_private();\n"
+ + " }\n"
+ + "}\n",
+ "test/copy/VisibilityPublic.java",
+ "package test.copy;\n"
+ + "public class VisibilityPublic {\n"
+ + " private class VpPrivate {\n"
+ + " private int vf_private = 10;\n"
+ + " public int vf_public = vf_private;\n"
+ + " private int vm_private() {\n"
+ + " vf_private = (new VpPrivate()).vf_private;\n"
+ + " return vf_private;\n"
+ + " }\n"
+ + " public int vm_public() {\n"
+ + " return vm_private();\n"
+ + " }\n"
+ + " }\n"
+ + " public class VpPublic {\n"
+ + " private int vf_private = 10;\n"
+ + " public int vf_public = vf_private;\n"
+ + " private int vm_private() {\n"
+ + " vf_private = (new VpPrivate()).vf_private;\n"
+ + " return vf_private;\n"
+ + " }\n"
+ + " public int vm_public() {\n"
+ + " return vm_private();\n"
+ + " }\n"
+ + " }\n"
+ + " private int vf_private = 100;\n"
+ + " public int vf_public = vf_private;\n"
+ + " \n"
+ + " private int vm_private() {\n"
+ + " vf_private = (new VpPrivate()).vf_private;\n"
+ + " return vf_private;\n"
+ + " }\n"
+ + " public int vm_public() {\n"
+ + " return vm_private();\n"
+ + " }\n"
+ + "}\n" };
+ }
+
+ protected void runConformReferenceTest(String[] testFiles) {
+ String[] completedFiles = testFiles;
+ if (!useLibrary) {
+ completedFiles = new String[testFiles.length + referencedClasses.length];
+ System.arraycopy(referencedClasses, 0, completedFiles, 0, referencedClasses.length);
+ System.arraycopy(testFiles, 0, completedFiles, referencedClasses.length, testFiles.length);
+ }
+ runConformTest(completedFiles);
+ }
+ protected void runNegativeReferenceTest(String[] testFiles, String expected) {
+ String[] completedFiles = testFiles;
+ if (!useLibrary) {
+ completedFiles = new String[testFiles.length + referencedClasses.length];
+ System.arraycopy(referencedClasses, 0, completedFiles, 0, referencedClasses.length);
+ System.arraycopy(testFiles, 0, completedFiles, referencedClasses.length, testFiles.length);
+ }
+ runNegativeTest(completedFiles, expected);
+ }
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.core.tests.compiler.regression.AbstractRegressionTest#runNegativeTest(java.lang.String[], java.lang.String)
+ */
+ protected void runNegativeTest(String[] testFiles, String expectedProblemLog) {
+ if (this.supportJavadoc) {
+ super.runNegativeTest(testFiles, expectedProblemLog);
+ } else {
+ StringTokenizer tokenizer = new StringTokenizer(expectedProblemLog);
+ int errors=0, javadocs=0;
+ while (tokenizer.hasMoreTokens()) {
+ String token = tokenizer.nextToken();
+ if ("ERROR".equals(token) || "WARNING".equals(token)) {
+ errors++;
+ } else if ("Javadoc:".equals(token)) {
+ javadocs++;
+ }
+ }
+ if (errors == javadocs) {
+ super.runConformTest(testFiles);
+ } else if (javadocs == 0) {
+ super.runNegativeTest(testFiles, expectedProblemLog);
+ } else {
+ if (debug) System.out.println("Test "+getName()+" skipped due to non-javadoc compiler errors...");
+ }
+ }
+ }
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.core.tests.compiler.regression.AbstractRegressionTest#runConformTest(java.lang.String[])
+ */
+ protected void runConformTest(String[] testFiles) {
+ if (this.supportJavadoc) {
+ super.runConformTest(testFiles);
+ } else {
+ if (debug) System.out.println("Test "+getName()+" skipped as identical when Javadoc is enabled...");
+ }
+ }
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForClass.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForClass.java
index 372e695..98e18da 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForClass.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForClass.java
@@ -13,54 +13,21 @@
import java.util.Map;
import junit.framework.Test;
-import junit.framework.TestSuite;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
public class JavadocTestForClass extends JavadocTest {
+
public static Test suite() {
- if (false) {
- TestSuite ts;
- int[] numbers = { 10, 12 };
- //some of the tests depend on the order of this suite.
- ts = new TestSuite();
- for (int i = 0; i < numbers.length; i++) {
- String meth = "test";
- int num = numbers[i];
- if (num < 10) {
- meth += "0";
- }
- if (num < 100) {
- meth += "0";
- }
- meth += num;
- ts.addTest(new JavadocTestForClass(meth));
- }
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- if (false) {
- TestSuite ts;
- //some of the tests depend on the order of this suite.
- ts = new TestSuite();
- for (int i=30; i<=30; i++) {
- String meth = "test";
- if (i<10) {
- meth += "0";
- }
- if (i<100) {
- meth += "0";
- }
- meth += i;
- ts.addTest(new JavadocTestForClass(meth));
- }
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- return setupSuite(testClass());
+ return buildSuite(javadocTestClass());
}
public JavadocTestForClass(String name) {
super(name);
}
- public static Class testClass() {
+ public JavadocTestForClass(String name, String support) {
+ super(name, support);
+ }
+ public static Class javadocTestClass() {
return JavadocTestForClass.class;
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForConstructor.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForConstructor.java
index b5077b0..e9c7450 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForConstructor.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForConstructor.java
@@ -18,52 +18,22 @@
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
public class JavadocTestForConstructor extends JavadocTest {
- public static Test suite() {
- if (false) {
- TestSuite ts;
- int[] numbers = { 3 };
- //some of the tests depend on the order of this suite.
- ts = new TestSuite();
- for (int i = 0; i < numbers.length; i++) {
- String meth = "test";
- int num = numbers[i];
- if (num < 10) {
- meth += "0";
- }
- if (num < 100) {
- meth += "0";
- }
- meth += num;
- ts.addTest(new JavadocTestForConstructor(meth));
- }
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- if (false) {
- TestSuite ts;
- //some of the tests depend on the order of this suite.
- ts = new TestSuite();
- for (int i=1; i<=8; i++) {
- String meth = "test";
- if (i<10) {
- meth += "0";
- }
- if (i<100) {
- meth += "0";
- }
- meth += i;
- ts.addTest(new JavadocTestForConstructor(meth));
- }
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- return setupSuite(testClass());
- }
public JavadocTestForConstructor(String name) {
super(name);
}
- public static Class testClass() {
+ public JavadocTestForConstructor(String name, String support) {
+ super(name, support);
+ }
+ public static Class javadocTestClass() {
return JavadocTestForConstructor.class;
}
+ public static Test suite() {
+ return buildSuite(javadocTestClass());
+ }
+ static { // Use this static to initialize testNames (String[]) , testRange (int[2]), testNumbers (int[])
+ }
+
protected Map getCompilerOptions() {
Map options = super.getCompilerOptions();
options.put(CompilerOptions.OPTION_ReportInvalidJavadoc, CompilerOptions.ERROR);
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForField.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForField.java
index 58aeea3..66e001b 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForField.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForField.java
@@ -18,32 +18,20 @@
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
public class JavadocTestForField extends JavadocTest {
- public static Test suite() {
- if (false) {
- TestSuite ts;
- //some of the tests depend on the order of this suite.
- ts = new TestSuite();
- for (int i=50; i<=80; i++) {
- String meth = "test";
- if (i<10) {
- meth += "0";
- }
- if (i<100) {
- meth += "0";
- }
- meth += i;
- ts.addTest(new JavadocTestForField(meth));
- }
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- return setupSuite(testClass());
- }
public JavadocTestForField(String name) {
super(name);
}
- public static Class testClass() {
+ public JavadocTestForField(String name, String support) {
+ super(name, support);
+ }
+ public static Class javadocTestClass() {
return JavadocTestForField.class;
}
+ public static Test suite() {
+ return buildSuite(javadocTestClass());
+ }
+ static { // Use this static to initialize testNames (String[]) , testRange (int[2]), testNumbers (int[])
+ }
protected Map getCompilerOptions() {
Map options = super.getCompilerOptions();
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForInterface.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForInterface.java
index e744bcd..760a096 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForInterface.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForInterface.java
@@ -18,33 +18,22 @@
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
public class JavadocTestForInterface extends JavadocTest {
- public static Test suite() {
- if (false) {
- TestSuite ts;
- //some of the tests depend on the order of this suite.
- ts = new TestSuite();
- for (int i = 61; i <= 61; i++) {
- String meth = "test";
- if (i < 10) {
- meth += "0";
- }
- if (i < 100) {
- meth += "0";
- }
- meth += i;
- ts.addTest(new JavadocTestForInterface(meth));
- }
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- return setupSuite(testClass());
- }
public JavadocTestForInterface(String name) {
super(name);
}
- public static Class testClass() {
+ public JavadocTestForInterface(String name, String support) {
+ super(name, support);
+ }
+ public static Class javadocTestClass() {
return JavadocTestForInterface.class;
}
+ public static Test suite() {
+ return buildSuite(javadocTestClass());
+ }
+ static { // Use this static to initialize testNames (String[]) , testRange (int[2]), testNumbers (int[])
+ }
+
protected Map getCompilerOptions() {
Map options = super.getCompilerOptions();
options.put(CompilerOptions.OPTION_ReportInvalidJavadoc, CompilerOptions.ERROR);
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForMethod.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForMethod.java
index ba0a5c1..96038a7 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForMethod.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForMethod.java
@@ -18,51 +18,20 @@
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
public class JavadocTestForMethod extends JavadocTest {
- public static Test suite() {
- if (false) {
- TestSuite ts;
- int[] numbers = { 80, 81, 85 };
- //some of the tests depend on the order of this suite.
- ts = new TestSuite();
- for (int i = 0; i < numbers.length; i++) {
- String meth = "test";
- int num = numbers[i];
- if (num < 10) {
- meth += "0";
- }
- if (num < 100) {
- meth += "0";
- }
- meth += num;
- ts.addTest(new JavadocTestForMethod(meth));
- }
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- if (false) {
- TestSuite ts;
- //some of the tests depend on the order of this suite.
- ts = new TestSuite();
- for (int i=130; i<=138; i++) {
- String meth = "test";
- if (i<10) {
- meth += "0";
- }
- if (i<100) {
- meth += "0";
- }
- meth += i;
- ts.addTest(new JavadocTestForMethod(meth));
- }
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- return setupSuite(testClass());
- }
public JavadocTestForMethod(String name) {
super(name);
}
- public static Class testClass() {
+ public JavadocTestForMethod(String name, String support) {
+ super(name, support);
+ }
+ public static Class javadocTestClass() {
return JavadocTestForMethod.class;
}
+ public static Test suite() {
+ return buildSuite(javadocTestClass());
+ }
+ static { // Use this static to initialize testNames (String[]) , testRange (int[2]), testNumbers (int[])
+ }
protected Map getCompilerOptions() {
Map options = super.getCompilerOptions();
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestMixed.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestMixed.java
index 040e394..8bb5948 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestMixed.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestMixed.java
@@ -13,55 +13,36 @@
import java.util.Map;
import junit.framework.Test;
-import junit.framework.TestSuite;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
public class JavadocTestMixed extends JavadocTest {
+ String localDocCommentSupport = CompilerOptions.ENABLED;
String reportInvalidJavadoc = CompilerOptions.ERROR;
String reportMissingJavadocComments = null;
public JavadocTestMixed(String name) {
super(name);
}
+ public JavadocTestMixed(String name, String support) {
+ super(name, support);
+ }
- public static Class testClass() {
+ public static Class javadocTestClass() {
return JavadocTestMixed.class;
}
public static Test suite() {
- if (false) {
- TestSuite ts;
- int[] numbers = { 41 };
- //some of the tests depend on the order of this suite.
- ts = new TestSuite();
- for (int i = 0; i < numbers.length; i++) {
- String meth = "test";
- int num = numbers[i];
- if (num < 10) {
- meth += "0";
- }
- if (num < 100) {
- meth += "0";
- }
- meth += num;
- ts.addTest(new JavadocTestMixed(meth));
- }
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- if (false) {
- TestSuite ts = new TestSuite();
- ts.addTest(new JavadocTestMixed("testBug52216"));
- ts.addTest(new JavadocTestMixed("testBug52216a"));
- ts.addTest(new JavadocTestMixed("testBug52216b"));
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- return setupSuite(testClass());
+ return buildSuite(javadocTestClass());
+ }
+ static {
+// testNames = new String[] { "Bug51529a", "Bug51529b" };
}
protected Map getCompilerOptions() {
Map options = super.getCompilerOptions();
+ options.put(CompilerOptions.OPTION_DocCommentSupport, this.localDocCommentSupport);
options.put(CompilerOptions.OPTION_ReportInvalidJavadoc, reportInvalidJavadoc);
if (reportMissingJavadocComments != null)
options.put(CompilerOptions.OPTION_ReportMissingJavadocComments, reportMissingJavadocComments);
@@ -71,6 +52,7 @@
options.put(CompilerOptions.OPTION_ReportFieldHiding, CompilerOptions.IGNORE);
options.put(CompilerOptions.OPTION_ReportSyntheticAccessEmulation, CompilerOptions.IGNORE);
options.put(CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.ERROR);
+ options.put(CompilerOptions.OPTION_ReportUnusedImport, CompilerOptions.ERROR);
return options;
}
/* (non-Javadoc)
@@ -78,6 +60,7 @@
*/
protected void setUp() throws Exception {
super.setUp();
+ this.localDocCommentSupport = this.docCommentSupport;
reportInvalidJavadoc = CompilerOptions.ERROR;
reportMissingJavadocComments = null;
}
@@ -2149,4 +2132,60 @@
"----------\n"
);
}
+
+ /**
+ * Test fix for bug 51529.
+ * @see <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=51529">51529</a>
+ */
+ public void testBug51529() {
+ reportMissingJavadocComments = CompilerOptions.IGNORE;
+ runConformTest(
+ new String[] {
+ "X.java",
+ "import java.util.Vector;\n" +
+ "public class X {\n" +
+ " /**\n" +
+ " * @see Vector\n" +
+ " */\n" +
+ " void foo() {}\n" +
+ "}\n"
+ });
+ }
+ public void testBug51529a() {
+ reportInvalidJavadoc = CompilerOptions.IGNORE;
+ reportMissingJavadocComments = CompilerOptions.IGNORE;
+ runConformTest(
+ new String[] {
+ "X.java",
+ "import java.util.Vector;\n" +
+ "public class X {\n" +
+ " /**\n" +
+ " * @see Vector\n" +
+ " */\n" +
+ " void foo() {}\n" +
+ "}\n"
+ }
+ );
+ }
+ public void testBug51529b() {
+ this.localDocCommentSupport = CompilerOptions.DISABLED;
+ runNegativeTest(
+ new String[] {
+ "X.java",
+ "import java.util.Vector;\n" +
+ "public class X {\n" +
+ " /**\n" +
+ " * @see Vector\n" +
+ " */\n" +
+ " void foo() {}\n" +
+ "}\n"
+ },
+ "----------\n" +
+ "1. ERROR in X.java (at line 1)\n" +
+ " import java.util.Vector;\n" +
+ " ^^^^^^^^^^^^^^^^\n" +
+ "The import java.util.Vector is never used\n" +
+ "----------\n"
+ );
+ }
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestOptions.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestOptions.java
index e46f868..57d53b1 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestOptions.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestOptions.java
@@ -13,7 +13,6 @@
import java.util.Map;
import junit.framework.Test;
-import junit.framework.TestSuite;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
@@ -26,6 +25,7 @@
*/
public class JavadocTestOptions extends JavadocTest {
+ String localDocCommentSupport = null;
String reportInvalidJavadoc = null;
String reportInvalidJavadocTagsVisibility = null;
String reportInvalidJavadocTags = null;
@@ -1513,24 +1513,34 @@
public JavadocTestOptions(String name) {
super(name);
}
-
- public static Class testClass() {
+ public JavadocTestOptions(String name, String support) {
+ super(name, support);
+ }
+ public static Class javadocTestClass() {
return JavadocTestOptions.class;
}
-
public static Test suite() {
- if (false) {
- TestSuite ts = new TestSuite();
- ts.addTest(new JavadocTestOptions("testMissingTagsErrorPrivate"));
- ts.addTest(new JavadocTestOptions("testMissingCommentsErrorPrivate"));
- return new RegressionTestSetup(ts, COMPLIANCE_1_4);
- }
- return setupSuite(testClass());
+ return buildSuite(javadocTestClass());
}
+ static { // Use this static to initialize testNames (String[]) , testRange (int[2]), testNumbers (int[])
+ }
+ /**
+ * @return Returns the docCommentSupport.
+ *
+ public String getNamePrefix() {
+ if (this.localDocCommentSupport == null) {
+ return super.getNamePrefix();
+ } else {
+ return this.localDocCommentSupport;
+ }
+ }
+ */
protected Map getCompilerOptions() {
Map options = super.getCompilerOptions();
// Set javadoc options if non null
+ if (this.localDocCommentSupport != null)
+ options.put(CompilerOptions.OPTION_DocCommentSupport, this.localDocCommentSupport);
if (reportInvalidJavadoc != null)
options.put(CompilerOptions.OPTION_ReportInvalidJavadoc, reportInvalidJavadoc);
if (reportInvalidJavadocTagsVisibility != null)
@@ -1881,4 +1891,34 @@
reportInvalidJavadocTagsVisibility = CompilerOptions.PRIVATE;
runConformTest(MissingTags);
}
+
+ /**
+ * Test fix for bug 52264.
+ * @see <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=52264">52264</a>
+ */
+ // Test invalid javadoc "error" with javadoc comment support disabled
+ public void testInvalidTagsReferencesJavadocSupportDisabled() {
+ this.localDocCommentSupport = CompilerOptions.DISABLED;
+ reportInvalidJavadoc = CompilerOptions.ERROR;
+ reportInvalidJavadocTags = CompilerOptions.ERROR;
+ runConformTest(InvalidReferencesClassJavadocComments);
+ runConformTest(InvalidReferencesFieldJavadocComments);
+ runConformTest(InvalidReferencesMethodJavadocComments);
+ runConformTest(InvalidReferencesConstructorJavadocComments);
+ }
+
+ // Test missing javadoc comments "error" with javadoc comment support disabled
+ public void testMissingCommentsJavadocSupportDisabled() {
+ this.localDocCommentSupport = CompilerOptions.DISABLED;
+ reportMissingJavadocComments = CompilerOptions.ERROR;
+ runConformReferenceTest(MissingComments);
+ }
+
+ // Test missing javadoc tags "error" with javadoc comment support disabled
+ public void testMissingTagsJavadocSupportDisabled() {
+ this.localDocCommentSupport = CompilerOptions.DISABLED;
+ reportMissingJavadocTags = CompilerOptions.ERROR;
+ runConformReferenceTest(MissingTags);
+ }
+
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/RegressionTestSetup.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/RegressionTestSetup.java
index 015e0de..cefae5f 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/RegressionTestSetup.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/RegressionTestSetup.java
@@ -26,7 +26,10 @@
public RegressionTestSetup(Test test, String complianceLevel) {
super(test, complianceLevel);
}
-
+ public RegressionTestSetup(Test test, String complianceLevel, String support) {
+ super(test, complianceLevel, support);
+ }
+
protected void setUp() {
if (this.javaClassLib == null) {
// Create name environment
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/TestAll.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/TestAll.java
index b23e25d..e05f68a 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/TestAll.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/TestAll.java
@@ -28,7 +28,7 @@
}
public static Test suite() {
ArrayList standardTests = new ArrayList();
- standardTests.addAll(JavadocTest.allTestClasses);
+// standardTests.addAll(JavadocTest.allTestClasses);
standardTests.add(ArrayTest.class);
standardTests.add(AssignmentTest.class);
standardTests.add(BatchCompilerTest.class);
@@ -66,6 +66,8 @@
tests_1_5.add(GenericTypeTest.class);
all.addTest(AbstractCompilerTest.suiteForComplianceLevel(AbstractCompilerTest.COMPLIANCE_1_5, RegressionTestSetup.class, tests_1_5));
}
+ // Add Javadoc test suites
+ all.addTest(JavadocTest.suite());
return all;
}
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/AbstractCompilerTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/AbstractCompilerTest.java
index b7d3459..68f12ca 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/AbstractCompilerTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/AbstractCompilerTest.java
@@ -34,6 +34,7 @@
private static int possibleComplianceLevels = -1;
protected String complianceLevel;
+ protected String docCommentSupport;
/*
* Returns the possible compliance levels this VM instance can run.
@@ -156,5 +157,6 @@
public void initialize(CompilerTestSetup setUp) {
this.complianceLevel = setUp.complianceLevel;
+ this.docCommentSupport = setUp.docCommentSupport;
}
}
\ No newline at end of file
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/CompilerTestSetup.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/CompilerTestSetup.java
index 5efd8d2..6c9bc08 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/CompilerTestSetup.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/CompilerTestSetup.java
@@ -20,11 +20,17 @@
public class CompilerTestSetup extends TestDecorator {
String complianceLevel;
+ String docCommentSupport;
public CompilerTestSetup(Test test, String complianceLevel) {
super(test);
this.complianceLevel = complianceLevel;
}
+ public CompilerTestSetup(Test test, String complianceLevel, String support) {
+ super(test);
+ this.complianceLevel = complianceLevel;
+ this.docCommentSupport = support;
+ }
protected void initTest(Object test) {
if (test instanceof AbstractCompilerTest) {
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverterJavadocTest.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverterJavadocTest.java
index 1f27e7a..304c3ea 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverterJavadocTest.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverterJavadocTest.java
@@ -15,7 +15,6 @@
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
-import java.util.Map;
import junit.framework.Test;
import junit.framework.TestSuite;
@@ -25,21 +24,19 @@
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.compiler.IProblem;
+import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
-import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ArrayType;
-import org.eclipse.jdt.core.dom.BlockComment;
import org.eclipse.jdt.core.dom.Comment;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.IBinding;
import org.eclipse.jdt.core.dom.Javadoc;
-import org.eclipse.jdt.core.dom.LineComment;
import org.eclipse.jdt.core.dom.MemberRef;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodRef;
import org.eclipse.jdt.core.dom.MethodRefParameter;
import org.eclipse.jdt.core.dom.Name;
-import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SimpleType;
@@ -49,12 +46,18 @@
public class ASTConverterJavadocTest extends ConverterTestSetup {
+ // Test counters
protected static int[] testCounters = { 0, 0, 0, 0 };
+ // Unicode tests
+ protected static boolean unicode = false;
+ // Doc Comment support
+ static final String DOC_COMMENT_SUPPORT = System.getProperty("doc.support");
+ final String docCommentSupport;
// List of comments read from source of test
-// private final int LINE_COMMENT = 100;
-// private final int BLOCK_COMMENT =200;
-// private final int DOC_COMMENT = 300;
+ private final int LINE_COMMENT = 100;
+ private final int BLOCK_COMMENT =200;
+ private final int DOC_COMMENT = 300;
List comments = new ArrayList();
// List of tags contained in each comment read from test source.
List allTags = new ArrayList();
@@ -69,31 +72,59 @@
protected StringBuffer problems;
protected String compilerOption = JavaCore.IGNORE;
protected List failures;
+ protected IJavaProject currentProject;
-
+ /**
+ * @param name
+ * @param support
+ */
+ public ASTConverterJavadocTest(String name, String support) {
+ super(name);
+ this.docCommentSupport = support;
+ }
/**
* @param name
*/
public ASTConverterJavadocTest(String name) {
- super(name);
+ this(name, JavaCore.ENABLED);
}
public static Test suite() {
TestSuite suite = new Suite(ASTConverterJavadocTest.class.getName());
-
+// String param = System.getProperty("unicode");
+// if ("true".equals(param)) {
+// unicode = true;
+// }
if (true) {
- Class c = ASTConverterJavadocTest.class;
- Method[] methods = c.getMethods();
- for (int i = 0, max = methods.length; i < max; i++) {
- if (methods[i].getName().startsWith("test")) { //$NON-NLS-1$
- suite.addTest(new ASTConverterJavadocTest(methods[i].getName()));
- }
+ if (DOC_COMMENT_SUPPORT == null) {
+ buildSuite(suite, JavaCore.ENABLED);
+ buildSuite(suite, JavaCore.DISABLED);
+ } else {
+ String support = DOC_COMMENT_SUPPORT==null ? JavaCore.DISABLED : (DOC_COMMENT_SUPPORT.equals(JavaCore.DISABLED)?JavaCore.DISABLED:JavaCore.ENABLED);
+ buildSuite(suite, support);
}
return suite;
}
- suite.addTest(new ASTConverterJavadocTest("test014"));
+ suite.addTest(new ASTConverterJavadocTest("testBug52908unicode"));
return suite;
}
+
+ public static void buildSuite(TestSuite suite, String support) {
+ Class c = ASTConverterJavadocTest.class;
+ Method[] methods = c.getMethods();
+ for (int i = 0, max = methods.length; i < max; i++) {
+ if (methods[i].getName().startsWith("test")) { //$NON-NLS-1$
+ suite.addTest(new ASTConverterJavadocTest(methods[i].getName(), support));
+ }
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see junit.framework.TestCase#getName()
+ */
+ public String getName() {
+ return "Doc "+this.docCommentSupport+" - "+super.getName();
+ }
/* (non-Javadoc)
* @see junit.framework.TestCase#setUp()
*/
@@ -126,6 +157,8 @@
}
}
assertTrue(title, size==0 || problems.length() > 0);
+ // put default options on project
+ this.currentProject.setOptions(JavaCore.getOptions());
}
/* (non-Javadoc)
* @see junit.framework.TestCase#tearDown()
@@ -144,226 +177,236 @@
}
}
- class ASTConverterJavadocFlattener extends ASTVisitor {
-
- /**
- * The string buffer into which the serialized representation of the AST is
- * written.
- */
- private StringBuffer buffer;
-
- private String comment;
-
- /**
- * Creates a new AST printer.
- */
- ASTConverterJavadocFlattener(String comment) {
- this.buffer = new StringBuffer();
- this.comment = comment;
- }
-
- /**
- * Returns the string accumulated in the visit.
- *
- * @return the serialized
- */
- public String getResult() {
- return this.buffer.toString();
- }
-
- /**
- * Resets this printer so that it can be used again.
- */
- public void reset() {
- this.buffer.setLength(0);
- }
-
-
- /*
- * @see ASTVisitor#visit(ArrayType)
- */
- public boolean visit(ArrayType node) {
- node.getComponentType().accept(this);
- this.buffer.append("[]");//$NON-NLS-1$
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(BlockComment)
- * @since 3.0
- */
- public boolean visit(BlockComment node) {
- this.buffer.append(this.comment);
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(Javadoc)
- */
- public boolean visit(Javadoc node) {
- // ignore deprecated node.getComment()
- this.buffer.append("/**");//$NON-NLS-1$
- ASTNode e = null;
- int start = 3;
- for (Iterator it = node.tags().iterator(); it.hasNext(); ) {
- e = (ASTNode) it.next();
- try {
- this.buffer.append(this.comment.substring(start, e.getStartPosition()-node.getStartPosition()));
- start = e.getStartPosition()-node.getStartPosition();
- } catch (IndexOutOfBoundsException ex) {
- // do nothing
- }
- e.accept(this);
- start += e.getLength();
- }
- this.buffer.append(this.comment.substring(start, node.getLength()));
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(LineComment)
- * @since 3.0
- */
- public boolean visit(LineComment node) {
- this.buffer.append(this.comment);
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(MemberRef)
- * @since 3.0
- */
- public boolean visit(MemberRef node) {
- if (node.getQualifier() != null) {
- node.getQualifier().accept(this);
- }
- this.buffer.append("#");//$NON-NLS-1$
- node.getName().accept(this);
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(MethodRef)
- * @since 3.0
- */
- public boolean visit(MethodRef node) {
- if (node.getQualifier() != null) {
- node.getQualifier().accept(this);
- }
- this.buffer.append("#");//$NON-NLS-1$
- node.getName().accept(this);
- this.buffer.append("(");//$NON-NLS-1$
- for (Iterator it = node.parameters().iterator(); it.hasNext(); ) {
- MethodRefParameter e = (MethodRefParameter) it.next();
- e.accept(this);
- if (it.hasNext()) {
- this.buffer.append(",");//$NON-NLS-1$
- }
- }
- this.buffer.append(")");//$NON-NLS-1$
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(MethodRefParameter)
- * @since 3.0
- */
- public boolean visit(MethodRefParameter node) {
- node.getType().accept(this);
- if (node.getName() != null) {
- this.buffer.append(" ");//$NON-NLS-1$
- node.getName().accept(this);
- }
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(TagElement)
- * @since 3.0
- */
- public boolean visit(TagElement node) {
- Javadoc javadoc = null;
- int start = 0;
- if (node.isNested()) {
- // nested tags are always enclosed in braces
- this.buffer.append("{");//$NON-NLS-1$
- javadoc = (Javadoc) node.getParent().getParent();
- start++;
- } else {
- javadoc = (Javadoc) node.getParent();
- }
- start += node.getStartPosition()-javadoc.getStartPosition();
- if (node.getTagName() != null) {
- this.buffer.append(node.getTagName());
- start += node.getTagName().length();
- }
- for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
- ASTNode e = (ASTNode) it.next();
- try {
- this.buffer.append(this.comment.substring(start, e.getStartPosition()-javadoc.getStartPosition()));
- start = e.getStartPosition()-javadoc.getStartPosition();
- } catch (IndexOutOfBoundsException ex) {
- // do nothing
- }
- start += e.getLength();
- e.accept(this);
- }
- if (node.isNested()) {
- this.buffer.append("}");//$NON-NLS-1$
- }
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(TextElement)
- * @since 3.0
- */
- public boolean visit(TextElement node) {
- this.buffer.append(node.getText());
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(PrimitiveType)
- */
- public boolean visit(PrimitiveType node) {
- this.buffer.append(node.getPrimitiveTypeCode().toString());
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(QualifiedName)
- */
- public boolean visit(QualifiedName node) {
- node.getQualifier().accept(this);
- this.buffer.append(".");//$NON-NLS-1$
- node.getName().accept(this);
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(SimpleName)
- */
- public boolean visit(SimpleName node) {
- this.buffer.append(node.getIdentifier());
- return false;
- }
-
- /*
- * @see ASTVisitor#visit(SimpleName)
- */
- public boolean visit(SimpleType node) {
- node.getName().accept(this);
- return false;
- }
+ public ASTNode runConversion(char[] source, String unitName, IJavaProject project) {
+ ASTParser parser = ASTParser.newParser(AST.LEVEL_2_0);
+ parser.setSource(source);
+ parser.setUnitName(unitName);
+ parser.setProject(project);
+ parser.setResolveBindings(this.resolveBinding);
+ return parser.createAST(null);
}
+// NOT USED
+// class ASTConverterJavadocFlattener extends ASTVisitor {
+//
+// /**
+// * The string buffer into which the serialized representation of the AST is
+// * written.
+// */
+// private StringBuffer buffer;
+//
+// private String comment;
+//
+// /**
+// * Creates a new AST printer.
+// */
+// ASTConverterJavadocFlattener(String comment) {
+// this.buffer = new StringBuffer();
+// this.comment = comment;
+// }
+//
+// /**
+// * Returns the string accumulated in the visit.
+// *
+// * @return the serialized
+// */
+// public String getResult() {
+// return this.buffer.toString();
+// }
+//
+// /**
+// * Resets this printer so that it can be used again.
+// */
+// public void reset() {
+// this.buffer.setLength(0);
+// }
+//
+// /*
+// * @see ASTVisitor#visit(ArrayType)
+// */
+// public boolean visit(ArrayType node) {
+// node.getComponentType().accept(this);
+// this.buffer.append("[]");//$NON-NLS-1$
+// return false;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(BlockComment)
+// * @since 3.0
+// */
+// public boolean visit(BlockComment node) {
+// this.buffer.append(this.comment);
+// return false;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(Javadoc)
+// */
+// public boolean visit(Javadoc node) {
+//
+// // ignore deprecated node.getComment()
+// this.buffer.append("/**");//$NON-NLS-1$
+// ASTNode e = null;
+// int start = 3;
+// for (Iterator it = node.tags().iterator(); it.hasNext(); ) {
+// e = (ASTNode) it.next();
+// try {
+// this.buffer.append(this.comment.substring(start, e.getStartPosition()-node.getStartPosition()));
+// start = e.getStartPosition()-node.getStartPosition();
+// } catch (IndexOutOfBoundsException ex) {
+// // do nothing
+// }
+// e.accept(this);
+// start += e.getLength();
+// }
+// this.buffer.append(this.comment.substring(start, node.getLength()));
+// return false;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(LineComment)
+// * @since 3.0
+// */
+// public boolean visit(LineComment node) {
+// this.buffer.append(this.comment);
+// return false;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(MemberRef)
+// * @since 3.0
+// */
+// public boolean visit(MemberRef node) {
+// if (node.getQualifier() != null) {
+// node.getQualifier().accept(this);
+// }
+// this.buffer.append("#");//$NON-NLS-1$
+// node.getName().accept(this);
+// return true;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(MethodRef)
+// * @since 3.0
+// */
+// public boolean visit(MethodRef node) {
+// if (node.getQualifier() != null) {
+// node.getQualifier().accept(this);
+// }
+// this.buffer.append("#");//$NON-NLS-1$
+// node.getName().accept(this);
+// this.buffer.append("(");//$NON-NLS-1$
+// for (Iterator it = node.parameters().iterator(); it.hasNext(); ) {
+// MethodRefParameter e = (MethodRefParameter) it.next();
+// e.accept(this);
+// if (it.hasNext()) {
+// this.buffer.append(",");//$NON-NLS-1$
+// }
+// }
+// this.buffer.append(")");//$NON-NLS-1$
+// return true;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(MethodRefParameter)
+// * @since 3.0
+// */
+// public boolean visit(MethodRefParameter node) {
+// node.getType().accept(this);
+// if (node.getName() != null) {
+// this.buffer.append(" ");//$NON-NLS-1$
+// node.getName().accept(this);
+// }
+// return true;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(TagElement)
+// * @since 3.0
+// */
+// public boolean visit(TagElement node) {
+// Javadoc javadoc = null;
+// int start = 0;
+// if (node.isNested()) {
+// // nested tags are always enclosed in braces
+// this.buffer.append("{");//$NON-NLS-1$
+// javadoc = (Javadoc) node.getParent().getParent();
+// start++;
+// } else {
+// javadoc = (Javadoc) node.getParent();
+// }
+// start += node.getStartPosition()-javadoc.getStartPosition();
+// if (node.getTagName() != null) {
+// this.buffer.append(node.getTagName());
+// start += node.getTagName().length();
+// }
+// for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
+// ASTNode e = (ASTNode) it.next();
+// try {
+// this.buffer.append(this.comment.substring(start, e.getStartPosition()-javadoc.getStartPosition()));
+// start = e.getStartPosition()-javadoc.getStartPosition();
+// } catch (IndexOutOfBoundsException ex) {
+// // do nothing
+// }
+// start += e.getLength();
+// e.accept(this);
+// }
+// if (node.isNested()) {
+// this.buffer.append("}");//$NON-NLS-1$
+// }
+// return true;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(TextElement)
+// * @since 3.0
+// */
+// public boolean visit(TextElement node) {
+// this.buffer.append(node.getText());
+// return false;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(PrimitiveType)
+// */
+// public boolean visit(PrimitiveType node) {
+// this.buffer.append(node.getPrimitiveTypeCode().toString());
+// return false;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(QualifiedName)
+// */
+// public boolean visit(QualifiedName node) {
+// node.getQualifier().accept(this);
+// this.buffer.append(".");//$NON-NLS-1$
+// node.getName().accept(this);
+// return false;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(SimpleName)
+// */
+// public boolean visit(SimpleName node) {
+// this.buffer.append(node.getIdentifier());
+// return false;
+// }
+//
+// /*
+// * @see ASTVisitor#visit(SimpleName)
+// */
+// public boolean visit(SimpleType node) {
+// node.getName().accept(this);
+// return false;
+// }
+// }
+
/*
* Convert Javadoc source to match Javadoc.toString().
* Store converted comments and their corresponding tags respectively
* in this.comments and this.allTags fields
*/
- void setSourceComment(char[] source) {
+ protected void setSourceComment(char[] source) {
this.comments = new ArrayList();
this.allTags = new ArrayList();
StringBuffer buffer = null;
@@ -372,71 +415,205 @@
String tag = null;
List tags = new ArrayList();
int length = source.length;
+ char previousChar=0, currentChar=0;
for (int i=0; i<length; i++) {
- if (comment == 0) {
- switch (source[i]) {
- case '/':
- switch (source[++i]) {
- case '/':
- comment = 1; // line comment
- buffer = new StringBuffer("//");
- i++;
- break;
- case '*':
- if (source[++i] == '*') {
- if (source[++i] == '/') { // empty block comment
- this.comments.add("/**/");
- this.allTags.add(new ArrayList());
+ previousChar = currentChar;
+ // get next char
+ currentChar = source[i];
+ int charLength = 1;
+ if (currentChar == '\\' && source[i+1] == 'u') {
+ //-------------unicode traitement ------------
+ int c1, c2, c3, c4;
+ charLength++;
+ while (source[i+charLength] == 'u') charLength++;
+ if (((c1 = Character.getNumericValue(source[i+charLength++])) > 15
+ || c1 < 0)
+ || ((c2 = Character.getNumericValue(source[i+charLength++])) > 15 || c2 < 0)
+ || ((c3 = Character.getNumericValue(source[i+charLength++])) > 15 || c3 < 0)
+ || ((c4 = Character.getNumericValue(source[i+charLength])) > 15 || c4 < 0)) {
+ throw new RuntimeException("Invalid unicode in source at "+i);
+ }
+ currentChar = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
+ i+=charLength;
+ }
+
+ //
+ switch (comment) {
+ case 0:
+ switch (currentChar) {
+ case '/':
+ comment = 1; // first char for comments...
+ buffer = new StringBuffer();
+ if (charLength == 1) {
+ buffer.append(currentChar);
+ } else {
+ for (int k=i-charLength; k<=i; k++) buffer.append(source[k]);
+ }
+ break;
+ case '\'':
+ while (i<length) {
+ // get next char
+ currentChar = source[i];
+ if (currentChar == '\\' && source[i+1] == 'u') {
+ //-------------unicode traitement ------------
+ i++;
+ int c1, c2, c3, c4;
+ i++;
+ while (source[i] == 'u') i++;
+ if (((c1 = Character.getNumericValue(source[i++])) > 15
+ || c1 < 0)
+ || ((c2 = Character.getNumericValue(source[i++])) > 15 || c2 < 0)
+ || ((c3 = Character.getNumericValue(source[i++])) > 15 || c3 < 0)
+ || ((c4 = Character.getNumericValue(source[i++])) > 15 || c4 < 0)) {
+ throw new RuntimeException("Invalid unicode in source at "+i);
+ }
+ currentChar = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
+ }
+ if (currentChar == '\\') {
+ // get next char
+ currentChar = source[i];
+ if (currentChar == '\\' && source[i+1] == 'u') {
+ //-------------unicode traitement ------------
i++;
- } else {
- comment = 3; // javadoc
- buffer = new StringBuffer("/**");
+ int c1, c2, c3, c4;
+ i++;
+ while (source[i] == 'u') i++;
+ if (((c1 = Character.getNumericValue(source[i++])) > 15
+ || c1 < 0)
+ || ((c2 = Character.getNumericValue(source[i++])) > 15 || c2 < 0)
+ || ((c3 = Character.getNumericValue(source[i++])) > 15 || c3 < 0)
+ || ((c4 = Character.getNumericValue(source[i++])) > 15 || c4 < 0)) {
+ throw new RuntimeException("Invalid unicode in source at "+i);
+ }
+ currentChar = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
}
} else {
- comment = 2; // block comment
- buffer = new StringBuffer("/*");
- }
- break;
- }
- break;
- case '\'':
- while (i<length) {
- i++;
- if (i==length) break;
- if (source[i] == '\\') {
- i++;
- } else {
- if (source[i] == '\'') {
- break;
- }
- }
- }
- break;
- case '"':
- while (i<length) {
- i++;
- if (i==length) break;
- if (source[i] == '\\') {
- i++;
- } else {
- if (source[i] == '"') {
- if ((i+1)==length) break;
- if (source[i+1] == '"') {
- i++;
- } else {
+ if (currentChar == '\'') {
break;
}
}
}
- }
- break;
- }
- }
- switch (comment) {
- case 1: // line comment
- if (source[i] == '\r' || source[i] == '\n') {
+ break;
+ case '"':
+ while (i<length) {
+ // get next char
+ currentChar = source[i];
+ if (currentChar == '\\' && source[i+1] == 'u') {
+ //-------------unicode traitement ------------
+ i++;
+ int c1, c2, c3, c4;
+ i++;
+ while (source[i] == 'u') i++;
+ if (((c1 = Character.getNumericValue(source[i++])) > 15
+ || c1 < 0)
+ || ((c2 = Character.getNumericValue(source[i++])) > 15 || c2 < 0)
+ || ((c3 = Character.getNumericValue(source[i++])) > 15 || c3 < 0)
+ || ((c4 = Character.getNumericValue(source[i++])) > 15 || c4 < 0)) {
+ throw new RuntimeException("Invalid unicode in source at "+i);
+ }
+ currentChar = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
+ }
+ if (currentChar == '\\') {
+ // get next char
+ currentChar = source[i];
+ if (currentChar == '\\' && source[i+1] == 'u') {
+ //-------------unicode traitement ------------
+ i++;
+ int c1, c2, c3, c4;
+ i++;
+ while (source[i] == 'u') i++;
+ if (((c1 = Character.getNumericValue(source[i++])) > 15
+ || c1 < 0)
+ || ((c2 = Character.getNumericValue(source[i++])) > 15 || c2 < 0)
+ || ((c3 = Character.getNumericValue(source[i++])) > 15 || c3 < 0)
+ || ((c4 = Character.getNumericValue(source[i++])) > 15 || c4 < 0)) {
+ throw new RuntimeException("Invalid unicode in source at "+i);
+ }
+ currentChar = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
+ }
+ } else {
+ if (currentChar == '"') {
+ int currentPos=i;
+ // get next char
+ currentChar = source[i];
+ if (currentChar == '\\' && source[i+1] == 'u') {
+ //-------------unicode traitement ------------
+ i++;
+ int c1, c2, c3, c4;
+ i++;
+ while (source[i] == 'u') i++;
+ if (((c1 = Character.getNumericValue(source[i++])) > 15
+ || c1 < 0)
+ || ((c2 = Character.getNumericValue(source[i++])) > 15 || c2 < 0)
+ || ((c3 = Character.getNumericValue(source[i++])) > 15 || c3 < 0)
+ || ((c4 = Character.getNumericValue(source[i++])) > 15 || c4 < 0)) {
+ throw new RuntimeException("Invalid unicode in source at "+i);
+ }
+ currentChar = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
+ }
+ if (source[i+1] != '"') {
+ i=currentPos;
+ break;
+ }
+ }
+ }
+ }
+ break;
+ }
+ break;
+ case 1: // first '/' has been found...
+ switch (currentChar) {
+ case '/':
+ if (charLength == 1) {
+ buffer.append(currentChar);
+ } else {
+ for (int k=i-charLength; k<=i; k++) buffer.append(source[k]);
+ }
+ comment = LINE_COMMENT;
+ break;
+ case '*':
+ if (charLength == 1) {
+ buffer.append(currentChar);
+ } else {
+ for (int k=i-charLength; k<=i; k++) buffer.append(source[k]);
+ }
+ comment = 2; // next step
+ break;
+ default:
+ comment = 0;
+ break;
+ }
+ break;
+ case 2: // '/*' has been found...
+ if (currentChar == '*') {
+ comment = 3; // next step...
+ } else {
+ comment = BLOCK_COMMENT;
+ }
+ if (charLength == 1) {
+ buffer.append(currentChar);
+ } else {
+ for (int k=i-charLength; k<=i; k++) buffer.append(source[k]);
+ }
+ break;
+ case 3: // '/**' has bee found, verify that's not an empty block comment
+ if (charLength == 1) {
+ buffer.append(currentChar);
+ } else {
+ for (int k=i-charLength; k<=i; k++) buffer.append(source[k]);
+ }
+ if (currentChar == '/') { // empty block comment
+ this.comments.add(buffer.toString());
+ this.allTags.add(new ArrayList());
+ comment = 0;
+ } else {
+ comment = DOC_COMMENT;
+ }
+ break;
+ case LINE_COMMENT:
+ if (currentChar == '\r' || currentChar == '\n') {
/*
- if (source[i] == '\r' && source[i+1] == '\n') {
+ if (currentChar == '\r' && source[i+1] == '\n') {
buffer.append(source[++i]);
}
*/
@@ -444,21 +621,25 @@
this.comments.add(buffer.toString());
this.allTags.add(tags);
} else {
- buffer.append(source[i]);
+ if (charLength == 1) {
+ buffer.append(currentChar);
+ } else {
+ for (int k=i-charLength; k<=i; k++) buffer.append(source[k]);
+ }
}
break;
- case 3: // javadoc comment
+ case DOC_COMMENT:
if (tag != null) {
- if (source[i] >= 'a' && source[i] <= 'z') {
- tag += source[i];
+ if (currentChar >= 'a' && currentChar <= 'z') {
+ tag += currentChar;
} else {
tags.add(tag);
tag = null;
}
}
- switch (source[i]) {
+ switch (currentChar) {
case '@':
- if (!lineStarted || source[i-1] == '{') {
+ if (!lineStarted || previousChar == '{') {
tag = "";
lineStarted = true;
}
@@ -470,20 +651,24 @@
case '*':
break;
default:
- if (!Character.isWhitespace(source[i])) {
+ if (!Character.isWhitespace(currentChar)) {
lineStarted = true;
}
}
- case 2: // block comment
- buffer.append(source[i]);
- if (end && source[i] == '/') {
+ case BLOCK_COMMENT:
+ if (charLength == 1) {
+ buffer.append(currentChar);
+ } else {
+ for (int k=i-charLength; k<=i; k++) buffer.append(source[k]);
+ }
+ if (end && currentChar == '/') {
comment = 0;
lineStarted = false;
this.comments.add(buffer.toString());
this.allTags.add(tags);
tags = new ArrayList();
}
- end = source[i] == '*';
+ end = currentChar == '*';
break;
default:
// do nothing
@@ -491,6 +676,52 @@
}
}
}
+
+ /*
+ * Convert Javadoc source to match Javadoc.toString().
+ * Store converted comments and their corresponding tags respectively
+ * in this.comments and this.allTags fields
+ */
+ char[] getUnicodeSource(char[] source) {
+ int length = source.length;
+ int unicodeLength = length*6;
+ char[] unicodeSource = new char[unicodeLength];
+ int u=0;
+ for (int i=0; i<length; i++) {
+ // get next char
+ if (source[i] == '\\' && source[i+1] == 'u') {
+ //-------------unicode traitement ------------
+ int c1, c2, c3, c4;
+ unicodeSource[u++] = source[i];
+ unicodeSource[u++] = source[++i];
+ if (((c1 = Character.getNumericValue(source[i+1])) > 15
+ || c1 < 0)
+ || ((c2 = Character.getNumericValue(source[i+2])) > 15 || c2 < 0)
+ || ((c3 = Character.getNumericValue(source[i+3])) > 15 || c3 < 0)
+ || ((c4 = Character.getNumericValue(source[i+4])) > 15 || c4 < 0)) {
+ throw new RuntimeException("Invalid unicode in source at "+i);
+ }
+ for (int j=0; j<4; j++) unicodeSource[u++] = source[++i];
+ } else {
+ unicodeSource[u++] = '\\';
+ unicodeSource[u++] = 'u';
+ unicodeSource[u++] = '0';
+ unicodeSource[u++] = '0';
+ int val = source[i]/16;
+ unicodeSource[u++] = (char) (val<10 ? val+ 0x30 : val-10+0x61);
+ val = source[i]%16;
+ unicodeSource[u++] = (char) (val<10 ? val+ 0x30 : val-10+0x61);
+ }
+ }
+ // Return one well sized array
+ if (u != unicodeLength) {
+ char[] result = new char[u];
+ System.arraycopy(unicodeSource, 0, result, 0, u);
+ return result;
+ } else {
+ return unicodeSource;
+ }
+ }
/*
* Return all tags number for a given Javadoc
@@ -516,14 +747,11 @@
}
/*
- * Compare a string a subset of a char array.
+ * Add a failure to the list. Use only one method as it easier to put breakpoint to
+ * debug failure when it occurs...
*/
- protected boolean compare(String str, int start, int length, char[] source) {
- if (str.length() != length) return false;
- for (int i=0; i<length; i++) {
- if (str.charAt(i) != source[start+i]) return false;
- }
- return true;
+ private void addFailure(String msg) {
+ this.failures.add(msg);
}
/*
@@ -533,7 +761,7 @@
*/
protected void assumeTrue(String msg, boolean cond) {
if (!cond) {
- this.failures.add(msg);
+ addFailure(msg);
}
}
@@ -544,7 +772,7 @@
*/
protected void assumeNull(String msg, Object obj) {
if (obj != null) {
- this.failures.add(msg);
+ addFailure(msg);
}
}
@@ -555,7 +783,7 @@
*/
protected void assumeNotNull(String msg, Object obj) {
if (obj == null) {
- this.failures.add(msg);
+ addFailure(msg);
}
}
@@ -566,7 +794,7 @@
*/
protected void assumeEquals(String msg, int expected, int actual) {
if (expected != actual) {
- this.failures.add(msg+", expected="+expected+" actual="+actual);
+ addFailure(msg+", expected="+expected+" actual="+actual);
}
}
@@ -580,7 +808,7 @@
return;
if (expected != null && expected.equals(actual))
return;
- this.failures.add(msg+", expected:<"+expected+"> actual:<"+actual+'>');
+ addFailure(msg+", expected:<"+expected+"> actual:<"+actual+'>');
}
/*
@@ -926,15 +1154,41 @@
// Create DOM AST nodes hierarchy
String sourceStr = this.sourceUnit.getSource();
- IJavaProject project = this.sourceUnit.getJavaProject();
- Map originalOptions = project.getOptions(true);
+ this.currentProject = this.sourceUnit.getJavaProject();
+
+ // set up java project options
+ this.currentProject.setOption(JavaCore.COMPILER_PB_INVALID_JAVADOC, this.compilerOption);
+ this.currentProject.setOption(JavaCore.COMPILER_PB_MISSING_JAVADOC_TAGS, this.compilerOption);
+ this.currentProject.setOption(JavaCore.COMPILER_PB_MISSING_JAVADOC_COMMENTS, this.compilerOption);
+ this.currentProject.setOption(JavaCore.COMPILER_PB_METHOD_WITH_CONSTRUCTOR_NAME, JavaCore.IGNORE);
+ this.currentProject.setOption(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, this.docCommentSupport);
+
+ // Verify source regardings converted comments
+ char[] source = sourceStr.toCharArray();
+ String fileName = unit.getPath().toString();
+ verifyComments(fileName, source);
+ }
+
+ protected void verifyComments(String fileName, char[] source) {
+
+ // Get comments infos from test file
+ setSourceComment(source);
+
+ // Verify comments either in unicode or not
+ char[] testedSource = source;
+ if (unicode) {
+ testedSource = getUnicodeSource(source);
+ }
+// Map originalOptions = this.currentProject.getOptions(true);
List unitComments = null;
- try {
- project.setOption(JavaCore.COMPILER_PB_INVALID_JAVADOC, this.compilerOption);
- project.setOption(JavaCore.COMPILER_PB_MISSING_JAVADOC_TAGS, this.compilerOption);
- project.setOption(JavaCore.COMPILER_PB_MISSING_JAVADOC_COMMENTS, this.compilerOption);
- project.setOption(JavaCore.COMPILER_PB_METHOD_WITH_CONSTRUCTOR_NAME, JavaCore.IGNORE);
- CompilationUnit compilUnit = (CompilationUnit) runConversion(this.sourceUnit, this.resolveBinding); // resolve bindings
+// try {
+// this.currentProject.setOption(JavaCore.COMPILER_PB_INVALID_JAVADOC, this.compilerOption);
+// this.currentProject.setOption(JavaCore.COMPILER_PB_MISSING_JAVADOC_TAGS, this.compilerOption);
+// this.currentProject.setOption(JavaCore.COMPILER_PB_MISSING_JAVADOC_COMMENTS, this.compilerOption);
+// this.currentProject.setOption(JavaCore.COMPILER_PB_METHOD_WITH_CONSTRUCTOR_NAME, JavaCore.IGNORE);
+// this.currentProject.setOption(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, this.docCommentSupport);
+ CompilationUnit compilUnit = (CompilationUnit) runConversion(testedSource, fileName, this.currentProject);
+// CompilationUnit compilUnit = (CompilationUnit) runConversion(this.sourceUnit, this.resolveBinding); // resolve bindings
if (this.compilerOption.equals(JavaCore.ERROR)) {
assumeEquals(this.prefix+"Unexpected problems", 0, compilUnit.getProblems().length); //$NON-NLS-1$
} else if (this.compilerOption.equals(JavaCore.WARNING)) {
@@ -948,47 +1202,42 @@
}
}
unitComments = compilUnit.getCommentList();
- } finally {
- project.setOptions(originalOptions);
- }
+// } finally {
+// this.currentProject.setOptions(originalOptions);
+// }
assumeNotNull(this.prefix+"Unexpected problems", unitComments);
- // Verify source regardings converted comments
- char[] source = sourceStr.toCharArray();
- verifyComments(sourceStr, source, unitComments);
- }
-
- /* (non-Javadoc)
- * @see junit.framework.TestCase#setUp()
- */
- protected void verifyComments(String sourceStr, char[] source, List unitComments) {
- // Get comments infos from test file
- setSourceComment(source);
-
// Basic comments verification
int size = unitComments.size();
- assumeEquals(this.prefix+"Wrong number of comments in source:\n"+sourceStr+"\n", this.comments.size(), size);
+ assumeEquals(this.prefix+"Wrong number of comments!", this.comments.size(), size);
+
// Verify comments positions and bindings
- for (int i=0; i<size; i++) {
- Comment comment = (Comment) unitComments.get(i);
- List tags = (List) allTags.get(i);
- // Verify flattened content
- String stringComment = (String) this.comments.get(i);
- ASTConverterJavadocFlattener printer = new ASTConverterJavadocFlattener(stringComment);
- comment.accept(printer);
- String text = new String(source, comment.getStartPosition(), comment.getLength());
- assumeEquals(this.prefix+"Flattened comment does NOT match source!", stringComment, text);
- // Verify javdoc tags positions and bindings
- if (comment.isDocComment()) {
- Javadoc docComment = (Javadoc)comment;
- assumeEquals(this.prefix+"Invalid tags number in javadoc:\n"+docComment+"\n", tags.size(), allTags(docComment));
- verifyPositions(docComment, source);
- if (this.resolveBinding) {
- verifyBindings(docComment);
+// if (this.comments.size() == size) {
+ for (int i=0; i<size; i++) {
+ Comment comment = (Comment) unitComments.get(i);
+ List tags = (List) allTags.get(i);
+ // Verify flattened content
+ String stringComment = (String) this.comments.get(i);
+ // ASTConverterJavadocFlattener printer = new ASTConverterJavadocFlattener(stringComment);
+ // comment.accept(printer);
+ String text = new String(testedSource, comment.getStartPosition(), comment.getLength());
+ assumeEquals(this.prefix+"Flattened comment does NOT match source!", stringComment, text);
+ // Verify javdoc tags positions and bindings
+ if (comment.isDocComment()) {
+ Javadoc docComment = (Javadoc)comment;
+ if (this.docCommentSupport.equals(JavaCore.ENABLED)) {
+ assumeEquals(this.prefix+"Invalid tags number in javadoc:\n"+docComment+"\n", tags.size(), allTags(docComment));
+ verifyPositions(docComment, testedSource);
+ if (this.resolveBinding) {
+ verifyBindings(docComment);
+ }
+ } else {
+ assumeEquals("Javadoc should be flat!", 0, docComment.tags().size());
+ }
}
}
- }
+// }
/* Verify each javadoc: not implemented yet
Iterator types = compilUnit.types().listIterator();
@@ -1333,9 +1582,12 @@
public void testBug52908() throws JavaModelException {
verifyComments("testBug52908");
}
+ public void testBug52908unicode() throws JavaModelException {
+ verifyComments("testBug52908unicode");
+ }
/**
- * https://bugs.eclipse.org/bugs/show_bug.cgi?id=5xxxA
+ * https://bugs.eclipse.org/bugs/show_bug.cgi?id=53276
*/
public void testBug53276() throws JavaModelException {
verifyComments("testBug53276");
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverterTest2.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverterTest2.java
index d6246d4..284bacf 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverterTest2.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverterTest2.java
@@ -96,7 +96,7 @@
return new Suite(ASTConverterTest2.class);
}
TestSuite suite = new Suite(ASTConverterTest2.class.getName());
- suite.addTest(new ASTConverterTest2("test0538d"));
+ suite.addTest(new ASTConverterTest2("test0539"));
return suite;
}
/**
@@ -4287,4 +4287,31 @@
sourceUnit.discardWorkingCopy();
}
}
+ /**
+ * http://dev.eclipse.org/bugs/show_bug.cgi?id=53477
+ */
+ public void test0539() throws JavaModelException {
+ ICompilationUnit sourceUnit = getCompilationUnit("Converter", "src", "test0539", "A.java"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ char[] source = sourceUnit.getSource().toCharArray();
+ ASTNode result = runConversion(sourceUnit, false);
+ final CompilationUnit unit = (CompilationUnit) result;
+ assertEquals("Wrong number of problems", 0, unit.getProblems().length); //$NON-NLS-1$
+ ASTNode node = getASTNode(unit, 0, 1, 0);
+ assertNotNull("No node", node);
+ assertTrue("not an expression statement", node.getNodeType() == ASTNode.EXPRESSION_STATEMENT);
+ ExpressionStatement expressionStatement = (ExpressionStatement) node;
+ Expression expression = expressionStatement.getExpression();
+ assertTrue("not a class instance creation", expression.getNodeType() == ASTNode.CLASS_INSTANCE_CREATION);
+ ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) expression;
+ checkSourceRange(classInstanceCreation, "new A(){}.new Inner(){/*x*/}", source);
+ AnonymousClassDeclaration anonymousClassDeclaration = classInstanceCreation.getAnonymousClassDeclaration();
+ Expression expression2 = classInstanceCreation.getExpression();
+ assertTrue("not a class instance creation", expression2.getNodeType() == ASTNode.CLASS_INSTANCE_CREATION);
+ ClassInstanceCreation classInstanceCreation2 = (ClassInstanceCreation) expression2;
+ AnonymousClassDeclaration anonymousClassDeclaration2 = classInstanceCreation2.getAnonymousClassDeclaration();
+ assertNotNull("No anonymous class declaration", anonymousClassDeclaration2);
+ checkSourceRange(anonymousClassDeclaration2, "{}", source);
+ assertNotNull("No anonymous class declaration", anonymousClassDeclaration);
+ checkSourceRange(anonymousClassDeclaration, "{/*x*/}", source);
+ }
}
\ No newline at end of file
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchJavadocTests.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchJavadocTests.java
index 3ad2103..0986df9 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchJavadocTests.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchJavadocTests.java
@@ -11,6 +11,7 @@
package org.eclipse.jdt.core.tests.model;
import java.util.Map;
+import java.util.StringTokenizer;
import junit.framework.Test;
import junit.framework.TestSuite;
@@ -28,18 +29,42 @@
public class JavaSearchJavadocTests extends JavaSearchTests {
Map originalOptions;
+ final String docCommentSupport;
+ static final String DOC_COMMENT_SUPPORT = System.getProperty("doc.support");
/**
* @param name
*/
- public JavaSearchJavadocTests(String name) {
+ public JavaSearchJavadocTests(String name, String support) {
super(name);
+ this.docCommentSupport = support;
}
- private void resetProjectOptions() {
+ public JavaSearchJavadocTests(String name) {
+ this(name, JavaCore.ENABLED);
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.core.tests.model.SuiteOfTestCases#setUpSuite()
+ */
+ public void setUp() throws Exception {
+ super.setUp();
+ this.originalOptions = this.javaProject.getOptions(true);
+ this.javaProject.setOption(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, this.docCommentSupport);
+ }
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.core.tests.model.SuiteOfTestCases#tearDownSuite()
+ */
+ public void tearDown() throws Exception {
+ super.tearDown();
this.javaProject.setOptions(originalOptions);
}
+ /* (non-Javadoc)
+ * @see junit.framework.TestCase#getName()
+ */
+ public String getName() {
+ return "Doc "+this.docCommentSupport+" - "+super.getName();
+ }
private void setJavadocOptions() {
- this.originalOptions = this.javaProject.getOptions(true);
this.javaProject.setOption(JavaCore.COMPILER_PB_INVALID_JAVADOC, JavaCore.WARNING);
this.javaProject.setOption(JavaCore.COMPILER_PB_MISSING_JAVADOC_COMMENTS, JavaCore.ERROR);
}
@@ -47,69 +72,104 @@
// NOTE: cannot use 'new Suite(JavaSearchJavadocTests.class)' as this would include tests from super class
TestSuite suite = new Suite(JavaSearchJavadocTests.class.getName());
- // Tests on type declarations
- suite.addTest(new JavaSearchJavadocTests("testJavadocTypeDeclaration"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocTypeDeclarationWithJavadoc"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocTypeStringDeclaration"));
-
- // Tests on field declarations
- suite.addTest(new JavaSearchJavadocTests("testJavadocFieldDeclaration"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocFieldDeclarationWithJavadoc"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocFieldStringDeclaration"));
-
- // Tests on method declarations
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodDeclaration"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodArgDeclaration"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodDeclarationWithJavadoc"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodArgDeclarationWithJavadoc"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodStringDeclaration"));
-
- // Tests on type references
- suite.addTest(new JavaSearchJavadocTests("testJavadocTypeReference"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocTypeReferenceWithJavadoc"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocTypeStringReference"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocTypeStringReferenceWithJavadoc"));
-
- // Tests on field references
- suite.addTest(new JavaSearchJavadocTests("testJavadocFieldReference"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocFieldReferenceWithJavadoc"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocFieldStringReference"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocFieldStringReferenceWithJavadoc"));
-
- // Tests on method references
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodReference"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodArgReference"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodReferenceWithJavadoc"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodArgReferenceWithJavadoc"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodStringReference"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocMethodStringReferenceWithJavadoc"));
-
- // Tests on constructor references
- suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorReference"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorArgReference"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorReferenceWithJavadoc"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorArgReferenceWithJavadoc"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorStringReference"));
- suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorStringReferenceWithJavadoc"));
-
- // Tests on bugs
- suite.addTest(new JavaSearchJavadocTests("testBug47909"));
- suite.addTest(new JavaSearchJavadocTests("testBug47968type"));
- suite.addTest(new JavaSearchJavadocTests("testBug47968field"));
- suite.addTest(new JavaSearchJavadocTests("testBug47968method"));
- suite.addTest(new JavaSearchJavadocTests("testBug47968constructor"));
- suite.addTest(new JavaSearchJavadocTests("testBug47209type"));
- suite.addTest(new JavaSearchJavadocTests("testBug47209field"));
- suite.addTest(new JavaSearchJavadocTests("testBug47209method"));
- suite.addTest(new JavaSearchJavadocTests("testBug47209constructor"));
- suite.addTest(new JavaSearchJavadocTests("testBug49994"));
- suite.addTest(new JavaSearchJavadocTests("testBug49994field"));
- suite.addTest(new JavaSearchJavadocTests("testBug49994method"));
- suite.addTest(new JavaSearchJavadocTests("testBug49994constructor"));
+ if (DOC_COMMENT_SUPPORT == null) {
+ // Default is to test both Doc Comment Support ON and OFF
+ buildSuite(suite, JavaCore.ENABLED);
+ buildSuite(suite, JavaCore.DISABLED);
+ } else {
+ // Test specified with Doc Comment Support
+ String support = DOC_COMMENT_SUPPORT==null ? JavaCore.DISABLED : (DOC_COMMENT_SUPPORT.equals(JavaCore.DISABLED)?JavaCore.DISABLED:JavaCore.ENABLED);
+ buildSuite(suite, support);
+ }
return suite;
}
+ public static void buildSuite(TestSuite suite, String support) {
+// TestSuite suite = new Suite("Doc "+support);
+ // Tests on type declarations
+ suite.addTest(new JavaSearchJavadocTests("testJavadocTypeDeclaration", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocTypeDeclarationWithJavadoc", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocTypeStringDeclaration", support));
+
+ // Tests on field declarations
+ suite.addTest(new JavaSearchJavadocTests("testJavadocFieldDeclaration", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocFieldDeclarationWithJavadoc", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocFieldStringDeclaration", support));
+
+ // Tests on method declarations
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodDeclaration", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodArgDeclaration", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodDeclarationWithJavadoc", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodArgDeclarationWithJavadoc", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodStringDeclaration", support));
+
+ // Tests on type references
+ suite.addTest(new JavaSearchJavadocTests("testJavadocTypeReference", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocTypeReferenceWithJavadoc", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocTypeStringReference", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocTypeStringReferenceWithJavadoc", support));
+
+ // Tests on field references
+ suite.addTest(new JavaSearchJavadocTests("testJavadocFieldReference", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocFieldReferenceWithJavadoc", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocFieldStringReference", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocFieldStringReferenceWithJavadoc", support));
+
+ // Tests on method references
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodReference", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodArgReference", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodReferenceWithJavadoc", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodArgReferenceWithJavadoc", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodStringReference", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocMethodStringReferenceWithJavadoc", support));
+
+ // Tests on constructor references
+ suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorReference", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorArgReference", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorReferenceWithJavadoc", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorArgReferenceWithJavadoc", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorStringReference", support));
+ suite.addTest(new JavaSearchJavadocTests("testJavadocConstructorStringReferenceWithJavadoc", support));
+
+ // Tests on bugs
+ suite.addTest(new JavaSearchJavadocTests("testBug47909", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug47968type", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug47968field", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug47968method", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug47968constructor", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug47209type", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug47209field", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug47209method", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug47209constructor", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug49994", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug49994field", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug49994method", support));
+ suite.addTest(new JavaSearchJavadocTests("testBug49994constructor", support));
+
+// return suite;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.core.tests.model.AbstractJavaModelTests#assertSearchResults(java.lang.String, java.lang.Object)
+ */
+ protected void assertSearchResults(String message, String expected, Object collector) {
+ if (JavaCore.ENABLED.equals(this.docCommentSupport)) {
+ super.assertSearchResults(message, expected, collector);
+ } else {
+ StringTokenizer tokenizer = new StringTokenizer(expected, "\n");
+ StringBuffer buffer = new StringBuffer(expected.length());
+ while (tokenizer.hasMoreTokens()) {
+ String token = tokenizer.nextToken();
+ if (token.startsWith("src/j1/JavadocSearched.java") || token.startsWith("test47909.jar")) {
+ if (buffer.length() > 0) buffer.append('\n');
+ buffer.append(token);
+ }
+ }
+// System.out.println(getName()+" - Expected: "+buffer.toString());
+ super.assertSearchResults(message, buffer.toString(), collector);
+ }
+ }
/*
* Test search of type declaration in javadoc comments
* ===================================================
@@ -146,7 +206,7 @@
}
public void testJavadocTypeDeclarationWithJavadoc() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j1", "JavadocSearched.java").getType("JavadocSearched");
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -160,9 +220,9 @@
assertSearchResults(
"src/j1/JavadocSearched.java j1.JavadocSearched [JavadocSearched] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
/*
@@ -203,7 +263,7 @@
public void testJavadocFieldDeclarationWithJavadoc() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j1", "JavadocSearched.java").getType("JavadocSearched");
IField field = type.getField("javadocSearchedVar");
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -217,9 +277,9 @@
assertSearchResults(
"src/j1/JavadocSearched.java j1.JavadocSearched.javadocSearchedVar [javadocSearchedVar] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
/*
@@ -276,7 +336,7 @@
}
public void testJavadocMethodDeclarationWithJavadoc() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j1", "JavadocSearched.java").getType("JavadocSearched");
- try {
+// try {
setJavadocOptions();
IMethod method = type.getMethod("javadocSearchedMethod", null);
JavaSearchResultCollector result = new JavaSearchResultCollector();
@@ -291,13 +351,13 @@
assertSearchResults(
"src/j1/JavadocSearched.java void j1.JavadocSearched.javadocSearchedMethod() [javadocSearchedMethod] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testJavadocMethodArgDeclarationWithJavadoc() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j1", "JavadocSearched.java").getType("JavadocSearched");
- try {
+// try {
setJavadocOptions();
IMethod method = type.getMethod("javadocSearchedMethod", new String[] { "QString;" });
JavaSearchResultCollector result = new JavaSearchResultCollector();
@@ -312,9 +372,9 @@
assertSearchResults(
"src/j1/JavadocSearched.java void j1.JavadocSearched.javadocSearchedMethod(String) [javadocSearchedMethod] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
/*
@@ -373,7 +433,7 @@
}
public void testJavadocTypeReferenceWithJavadoc() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j1", "JavadocSearched.java").getType("JavadocSearched");
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -397,12 +457,12 @@
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [JavadocSearched] EXACT_MATCH\n"+
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [JavadocSearched] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testJavadocTypeStringReferenceWithJavadoc() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -427,9 +487,9 @@
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [JavadocSearched] EXACT_MATCH\n"+
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [JavadocSearched] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
/*
@@ -473,7 +533,7 @@
public void testJavadocFieldReferenceWithJavadoc() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j1", "JavadocSearched.java").getType("JavadocSearched");
IField field = type.getField("javadocSearchedVar");
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -488,12 +548,12 @@
"src/j1/JavadocInvalidRef.java void j1.JavadocInvalidRef.invalid() [javadocSearchedVar] POTENTIAL_MATCH\n" +
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [javadocSearchedVar] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testJavadocFieldStringReferenceWithJavadoc() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -510,9 +570,9 @@
"src/j1/JavadocInvalidRef.java void j1.JavadocInvalidRef.invalid() [javadocSearchedVar] POTENTIAL_MATCH\n" +
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [javadocSearchedVar] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
/*
@@ -572,7 +632,7 @@
}
public void testJavadocMethodReferenceWithJavadoc() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j1", "JavadocSearched.java").getType("JavadocSearched");
- try {
+// try {
setJavadocOptions();
IMethod method = type.getMethod("javadocSearchedMethod", null);
JavaSearchResultCollector result = new JavaSearchResultCollector();
@@ -588,13 +648,13 @@
"src/j1/JavadocInvalidRef.java void j1.JavadocInvalidRef.invalid() [javadocSearchedMethod] POTENTIAL_MATCH\n" +
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [javadocSearchedMethod] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testJavadocMethodArgReferenceWithJavadoc() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j1", "JavadocSearched.java").getType("JavadocSearched");
- try {
+// try {
setJavadocOptions();
IMethod method = type.getMethod("javadocSearchedMethod", new String[] { "QString;" });
JavaSearchResultCollector result = new JavaSearchResultCollector();
@@ -609,12 +669,12 @@
assertSearchResults(
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [javadocSearchedMethod] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testJavadocMethodStringReferenceWithJavadoc() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -632,9 +692,9 @@
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [javadocSearchedMethod] EXACT_MATCH\n" +
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [javadocSearchedMethod] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
/*
@@ -692,7 +752,7 @@
}
public void testJavadocConstructorReferenceWithJavadoc() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j1", "JavadocSearched.java").getType("JavadocSearched");
- try {
+// try {
setJavadocOptions();
IMethod method = type.getMethod("JavadocSearched", null);
JavaSearchResultCollector result = new JavaSearchResultCollector();
@@ -707,13 +767,13 @@
assertSearchResults(
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [JavadocSearched] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testJavadocConstructorArgReferenceWithJavadoc() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j1", "JavadocSearched.java").getType("JavadocSearched");
- try {
+// try {
setJavadocOptions();
IMethod method = type.getMethod("JavadocSearched", new String[] { "QString;" });
JavaSearchResultCollector result = new JavaSearchResultCollector();
@@ -728,12 +788,12 @@
assertSearchResults(
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [JavadocSearched] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testJavadocConstructorStringReferenceWithJavadoc() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -750,9 +810,9 @@
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [JavadocSearched] EXACT_MATCH\n" +
"src/j1/JavadocValidRef.java void j1.JavadocValidRef.valid() [JavadocSearched] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
/**
@@ -762,7 +822,7 @@
*/
public void testBug47909() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j3", "Y.java").getType("Y");
- try {
+// try {
setJavadocOptions();
IMethod method = type.getMethod("Y", new String[] { "I" });
JavaSearchResultCollector result = new JavaSearchResultCollector();
@@ -777,9 +837,9 @@
assertSearchResults(
"test47909.jar void j3.X.bar() EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
/**
@@ -789,7 +849,7 @@
*/
public void testBug47968type() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j2", "Bug47968.java").getType("Bug47968");
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -820,13 +880,13 @@
"src/j2/Bug47968s.java void j2.Bug47968s.bar() [Bug47968] EXACT_MATCH\n" +
"src/j2/Bug47968s.java void j2.Bug47968s.bar() [Bug47968] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testBug47968field() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j2", "Bug47968.java").getType("Bug47968");
- try {
+// try {
setJavadocOptions();
IField field = type.getField("x");
JavaSearchResultCollector result = new JavaSearchResultCollector();
@@ -844,13 +904,13 @@
"src/j2/Bug47968s.java j2.Bug47968s() [x] EXACT_MATCH\n" +
"src/j2/Bug47968s.java void j2.Bug47968s.bar() [x] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testBug47968method() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j2", "Bug47968.java").getType("Bug47968");
- try {
+// try {
setJavadocOptions();
IMethod method = type.getMethod("foo", new String[] { "I" });
JavaSearchResultCollector result = new JavaSearchResultCollector();
@@ -868,13 +928,13 @@
"src/j2/Bug47968s.java j2.Bug47968s() [foo] EXACT_MATCH\n" +
"src/j2/Bug47968s.java void j2.Bug47968s.bar() [foo] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testBug47968constructor() throws CoreException {
IType type = getCompilationUnit("JavaSearch", "src", "j2", "Bug47968.java").getType("Bug47968");
- try {
+// try {
setJavadocOptions();
IMethod method = type.getMethod("Bug47968", new String[] { "QString;" });
JavaSearchResultCollector result = new JavaSearchResultCollector();
@@ -892,9 +952,9 @@
"src/j2/Bug47968s.java j2.Bug47968s() [Bug47968] EXACT_MATCH\n" +
"src/j2/Bug47968s.java void j2.Bug47968s.bar() [Bug47968] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
/**
@@ -903,7 +963,7 @@
* @throws CoreException
*/
public void testBug47209type() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -921,12 +981,12 @@
"src/j4/TC47209.java j4.TC47209(String) [TC47209] EXACT_MATCH\n" +
"src/j4/TM47209.java void j4.TM47209.m47209(int) [TM47209] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testBug47209field() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -944,12 +1004,12 @@
"src/j4/FC47209.java j4.FC47209(String) [FC47209] EXACT_MATCH\n" +
"src/j4/FM47209.java void j4.FM47209.m47209(int) [FM47209] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testBug47209method() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -967,12 +1027,12 @@
"src/j4/MC47209.java j4.MC47209(String) [MC47209] EXACT_MATCH\n" +
"src/j4/MM47209.java void j4.MM47209.m47209(int) [MM47209] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testBug47209constructor() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -990,9 +1050,9 @@
"src/j4/CC47209.java j4.CC47209(String) [CC47209] EXACT_MATCH\n" +
"src/j4/CM47209.java void j4.CM47209.m47209(int) [CM47209] EXACT_MATCH",
result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
/**
@@ -1001,19 +1061,19 @@
* @throws CoreException
*/
public void testBug49994() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
IType type = getCompilationUnit("JavaSearch", "src", "j5", "Bug49994.java").getType("Bug49994");
new SearchEngine().search(getWorkspace(), type, REFERENCES, getJavaSearchScope(), result);
assertSearchResults("", result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testBug49994field() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -1021,12 +1081,12 @@
IField field = type.getField("field");
new SearchEngine().search(getWorkspace(), field, REFERENCES, getJavaSearchScope(), result);
assertSearchResults("src/j5/Bug49994.java void j5.Bug49994.foo() [field] EXACT_MATCH", result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testBug49994method() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -1034,12 +1094,12 @@
IMethod method = type.getMethod("bar", new String[0]);
new SearchEngine().search(getWorkspace(), method, REFERENCES, getJavaSearchScope(), result);
assertSearchResults("src/j5/Bug49994.java void j5.Bug49994.foo() [bar] EXACT_MATCH", result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
public void testBug49994constructor() throws CoreException {
- try {
+// try {
setJavadocOptions();
JavaSearchResultCollector result = new JavaSearchResultCollector();
result.showAccuracy = true;
@@ -1047,8 +1107,8 @@
IMethod method = type.getMethod("Bug49994", new String[] { "QString;" });
new SearchEngine().search(getWorkspace(), method, REFERENCES, getJavaSearchScope(), result);
assertSearchResults("src/j5/Bug49994.java void j5.Bug49994.foo() [Bug49994] EXACT_MATCH", result);
- } finally {
- resetProjectOptions();
- }
+// } finally {
+// resetProjectOptions();
+// }
}
}
diff --git a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
index 81177f2..a8229f2 100644
--- a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
+++ b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
@@ -842,39 +842,51 @@
isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
} else if (token.equals("javadoc")) {//$NON-NLS-1$
this.options.put(
- CompilerOptions.OPTION_ReportInvalidJavadoc,
- isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
- this.options.put(
- CompilerOptions.OPTION_ReportInvalidJavadocTags,
- isEnabling ? CompilerOptions.ENABLED : CompilerOptions.DISABLED);
- this.options.put(
- CompilerOptions.OPTION_ReportInvalidJavadocTagsVisibility,
- isEnabling ? CompilerOptions.PRIVATE : CompilerOptions.PUBLIC);
- this.options.put(
- CompilerOptions.OPTION_ReportMissingJavadocTags,
- isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
- this.options.put(
- CompilerOptions.OPTION_ReportMissingJavadocTagsVisibility,
- isEnabling ? CompilerOptions.PRIVATE : CompilerOptions.PUBLIC);
+ CompilerOptions.OPTION_DocCommentSupport,
+ isEnabling ? CompilerOptions.ENABLED: CompilerOptions.DISABLED);
+ // if disabling then it's not necessary to set other javadoc options
+ if (isEnabling) {
+ this.options.put(
+ CompilerOptions.OPTION_ReportInvalidJavadoc,
+ CompilerOptions.WARNING);
+ this.options.put(
+ CompilerOptions.OPTION_ReportInvalidJavadocTags,
+ CompilerOptions.ENABLED);
+ this.options.put(
+ CompilerOptions.OPTION_ReportInvalidJavadocTagsVisibility,
+ CompilerOptions.PRIVATE);
+ this.options.put(
+ CompilerOptions.OPTION_ReportMissingJavadocTags,
+ CompilerOptions.WARNING);
+ this.options.put(
+ CompilerOptions.OPTION_ReportMissingJavadocTagsVisibility,
+ CompilerOptions.PRIVATE);
+ }
} else if (token.equals("allJavadoc")) { //$NON-NLS-1$
this.options.put(
+ CompilerOptions.OPTION_DocCommentSupport,
+ isEnabling ? CompilerOptions.ENABLED: CompilerOptions.DISABLED);
+ // if disabling then it's not necessary to set other javadoc options
+ if (isEnabling) {
+ this.options.put(
CompilerOptions.OPTION_ReportInvalidJavadoc,
- isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
- this.options.put(
- CompilerOptions.OPTION_ReportInvalidJavadocTags,
- isEnabling ? CompilerOptions.ENABLED : CompilerOptions.DISABLED);
- this.options.put(
- CompilerOptions.OPTION_ReportInvalidJavadocTagsVisibility,
- isEnabling ? CompilerOptions.PRIVATE : CompilerOptions.PUBLIC);
- this.options.put(
- CompilerOptions.OPTION_ReportMissingJavadocTags,
- isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
- this.options.put(
- CompilerOptions.OPTION_ReportMissingJavadocTagsVisibility,
- isEnabling ? CompilerOptions.PRIVATE : CompilerOptions.PUBLIC);
- this.options.put(
- CompilerOptions.OPTION_ReportMissingJavadocComments,
- isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
+ CompilerOptions.WARNING);
+ this.options.put(
+ CompilerOptions.OPTION_ReportInvalidJavadocTags,
+ CompilerOptions.ENABLED);
+ this.options.put(
+ CompilerOptions.OPTION_ReportInvalidJavadocTagsVisibility,
+ CompilerOptions.PRIVATE);
+ this.options.put(
+ CompilerOptions.OPTION_ReportMissingJavadocTags,
+ CompilerOptions.WARNING);
+ this.options.put(
+ CompilerOptions.OPTION_ReportMissingJavadocTagsVisibility,
+ CompilerOptions.PRIVATE);
+ this.options.put(
+ CompilerOptions.OPTION_ReportMissingJavadocComments,
+ CompilerOptions.WARNING);
+ }
} else if (token.startsWith("tasks")) { //$NON-NLS-1$
String taskTags = ""; //$NON-NLS-1$
int start = token.indexOf('(');
diff --git a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
index f7ce4bd..510d4a7 100644
--- a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
+++ b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
@@ -12,7 +12,7 @@
### compiler
compiler.name = Eclipse Java Compiler
-compiler.version = 0.411
+compiler.version = 0.412
compiler.copyright = Copyright IBM Corp 2000, 2004. All rights reserved.
### scanning
diff --git a/org.eclipse.jdt.core/buildnotes_jdt-core.html b/org.eclipse.jdt.core/buildnotes_jdt-core.html
index e99c160..d50b2d2 100644
--- a/org.eclipse.jdt.core/buildnotes_jdt-core.html
+++ b/org.eclipse.jdt.core/buildnotes_jdt-core.html
@@ -54,6 +54,44 @@
ArrayStoreException in 1.5 parser
+<a name="v_412"></a>
+<p><hr><h1>
+Eclipse Platform Build Notes <br>
+Java Development Tooling Core</h1>
+Eclipse SDK 3.0M8 Build - ?th March 2004
+<br>Project org.eclipse.jdt.core v_412
+(<a href="http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jdt.core/?only_with_tag=v_412">cvs</a>).
+<h2>
+What's new in this drop</h2>
+<ul>
+<li>Added new global option for doc comment (Javadoc) support. By default, this option is enabled for backward compatibility.
+<pre>
+ * COMPILER / Javadoc Comment Support
+ * When this support is disabled, the compiler will ignore all javadoc problems options settings
+ * and will not report any javadoc problem. It will also not find any reference in javadoc comment and
+ * DOM AST Javadoc node will be only a flat text instead of having structured tag elements.
+ * - option id: "org.eclipse.jdt.core.compiler.doc.comment.support"
+ * - possible values: { "enabled", "disabled" }
+ * - default: "enabled"
+</pre>
+See bug <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=52264">52264</a>.
+</li>
+</ul>
+
+<h3>Problem Reports Fixed</h3>
+<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=53357">53357</a>
+Java AST creation error
+<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=52264">52264</a>
+Need a global preference to enable Javadoc support
+<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=51529">51529</a>
+"Organize imports" is confused by references inside Javadoc
+<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=53477">53477</a>
+AnonymousClassDeclaration has wrong range
+<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=53624">53624</a>
+StackOverFlow in Code assist
+<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=50433">50433</a>
+Rationalize signatures of AST.parse* methods
+
<a name="v_411"></a>
<p><hr><h1>
Eclipse Platform Build Notes <br>
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java
index c1e0db0..74b8ce6 100644
--- a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java
+++ b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java
@@ -1793,7 +1793,7 @@
pushOnElementStack(K_BETWEEN_CATCH_AND_RIGHT_PAREN);
break;
case TokenNameLPAREN:
- if (this.invocationType == NO_RECEIVER || this.invocationType == NAME_RECEIVER) {
+ if (this.invocationType == NO_RECEIVER || this.invocationType == NAME_RECEIVER || this.invocationType == SUPER_RECEIVER) {
this.qualifier = this.expressionPtr; // remenber the last expression so that arguments are correctly computed
}
switch (previous) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java
index 54c28ca..d652a22 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java
@@ -31,6 +31,7 @@
public static final String OPTION_LineNumberAttribute = "org.eclipse.jdt.core.compiler.debug.lineNumber"; //$NON-NLS-1$
public static final String OPTION_SourceFileAttribute = "org.eclipse.jdt.core.compiler.debug.sourceFile"; //$NON-NLS-1$
public static final String OPTION_PreserveUnusedLocal = "org.eclipse.jdt.core.compiler.codegen.unusedLocal"; //$NON-NLS-1$
+ public static final String OPTION_DocCommentSupport= "org.eclipse.jdt.core.compiler.doc.comment.support"; //$NON-NLS-1$
public static final String OPTION_ReportMethodWithConstructorName = "org.eclipse.jdt.core.compiler.problem.methodWithConstructorName"; //$NON-NLS-1$
public static final String OPTION_ReportOverridingPackageDefaultMethod = "org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod"; //$NON-NLS-1$
public static final String OPTION_ReportDeprecation = "org.eclipse.jdt.core.compiler.problem.deprecation"; //$NON-NLS-1$
@@ -230,6 +231,9 @@
// JSR bytecode usage
public boolean useJsrBytecode = true;
+ // javadoc comment support
+ public boolean docCommentSupport = false;
+
/**
* Initializing the compiler options with defaults
@@ -254,6 +258,7 @@
optionsMap.put(OPTION_LineNumberAttribute, (this.produceDebugAttributes & Lines) != 0 ? GENERATE : DO_NOT_GENERATE);
optionsMap.put(OPTION_SourceFileAttribute, (this.produceDebugAttributes & Source) != 0 ? GENERATE : DO_NOT_GENERATE);
optionsMap.put(OPTION_PreserveUnusedLocal, this.preserveAllLocalVariables ? PRESERVE : OPTIMIZE_OUT);
+ optionsMap.put(OPTION_DocCommentSupport, this.docCommentSupport ? ENABLED : DISABLED);
optionsMap.put(OPTION_ReportMethodWithConstructorName, getSeverityString(MethodWithConstructorName));
optionsMap.put(OPTION_ReportOverridingPackageDefaultMethod, getSeverityString(OverriddenPackageDefaultMethod));
optionsMap.put(OPTION_ReportDeprecation, getSeverityString(UsingDeprecatedAPI));
@@ -497,6 +502,13 @@
if ((optionValue = optionsMap.get(OPTION_ReportNoEffectAssignment)) != null) updateSeverity(NoEffectAssignment, optionValue);
// Javadoc options
+ if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {
+ if (ENABLED.equals(optionValue)) {
+ this.docCommentSupport = true;
+ } else if (DISABLED.equals(optionValue)) {
+ this.docCommentSupport = false;
+ }
+ }
if ((optionValue = optionsMap.get(OPTION_ReportInvalidJavadoc)) != null) {
updateSeverity(InvalidJavadoc, optionValue);
}
@@ -589,15 +601,16 @@
buf.append("\n\t- superfluous semicolon: ").append(getSeverityString(SuperfluousSemicolon)); //$NON-NLS-1$
buf.append("\n\t- uncommented empty block: ").append(getSeverityString(UndocumentedEmptyBlock)); //$NON-NLS-1$
buf.append("\n\t- unnecessary type check: ").append(getSeverityString(UnnecessaryTypeCheck)); //$NON-NLS-1$
- buf.append("\n\t- invalid javadoc: ").append(getSeverityString(InvalidJavadoc)); //$NON-NLS-1$
- buf.append("\n\t- report invalid javadoc tags: ").append(this.reportInvalidJavadocTags ? ENABLED : DISABLED); //$NON-NLS-1$
- buf.append("\n\t- visibility level to report invalid javadoc tags: ").append(getVisibilityString(this.reportInvalidJavadocTagsVisibility)); //$NON-NLS-1$
- buf.append("\n\t- missing javadoc tags: ").append(getSeverityString(MissingJavadocTags)); //$NON-NLS-1$
- buf.append("\n\t- visibility level to report missing javadoc tags: ").append(getVisibilityString(this.reportMissingJavadocTagsVisibility)); //$NON-NLS-1$
- buf.append("\n\t- report missing javadoc tags in overriding methods: ").append(this.reportMissingJavadocTagsOverriding ? ENABLED : DISABLED); //$NON-NLS-1$
- buf.append("\n\t- missing javadoc comments: ").append(getSeverityString(MissingJavadocComments)); //$NON-NLS-1$
- buf.append("\n\t- visibility level to report missing javadoc comments: ").append(getVisibilityString(this.reportMissingJavadocCommentsVisibility)); //$NON-NLS-1$
- buf.append("\n\t- report missing javadoc comments in overriding methods: ").append(this.reportMissingJavadocCommentsOverriding ? ENABLED : DISABLED); //$NON-NLS-1$
+ buf.append("\n\t- javadoc comment support: ").append(this.docCommentSupport ? "ON" : " OFF"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ buf.append("\n\t\t+ invalid javadoc: ").append(getSeverityString(InvalidJavadoc)); //$NON-NLS-1$
+ buf.append("\n\t\t+ report invalid javadoc tags: ").append(this.reportInvalidJavadocTags ? ENABLED : DISABLED); //$NON-NLS-1$
+ buf.append("\n\t\t+ visibility level to report invalid javadoc tags: ").append(getVisibilityString(this.reportInvalidJavadocTagsVisibility)); //$NON-NLS-1$
+ buf.append("\n\t\t+ missing javadoc tags: ").append(getSeverityString(MissingJavadocTags)); //$NON-NLS-1$
+ buf.append("\n\t\t+ visibility level to report missing javadoc tags: ").append(getVisibilityString(this.reportMissingJavadocTagsVisibility)); //$NON-NLS-1$
+ buf.append("\n\t\t+ report missing javadoc tags in overriding methods: ").append(this.reportMissingJavadocTagsOverriding ? ENABLED : DISABLED); //$NON-NLS-1$
+ buf.append("\n\t\t+ missing javadoc comments: ").append(getSeverityString(MissingJavadocComments)); //$NON-NLS-1$
+ buf.append("\n\t\t+ visibility level to report missing javadoc comments: ").append(getVisibilityString(this.reportMissingJavadocCommentsVisibility)); //$NON-NLS-1$
+ buf.append("\n\t\t+ report missing javadoc comments in overriding methods: ").append(this.reportMissingJavadocCommentsOverriding ? ENABLED : DISABLED); //$NON-NLS-1$
buf.append("\n\t- finally block not completing normally: ").append(getSeverityString(FinallyBlockNotCompleting)); //$NON-NLS-1$
buf.append("\n\t- unused declared thrown exception: ").append(getSeverityString(UnusedDeclaredThrownException)); //$NON-NLS-1$
buf.append("\n\t- unused declared thrown exception when overriding ").append(this.reportUnusedDeclaredThrownExceptionWhenOverriding ? ENABLED : DISABLED); //$NON-NLS-1$
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/AbstractCommentParser.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/AbstractCommentParser.java
index c118b0b..0bd6b1c 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/AbstractCommentParser.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/AbstractCommentParser.java
@@ -46,6 +46,7 @@
// Public fields
public Scanner scanner;
+ public boolean checkDocComment = false;
// Protected fields
protected boolean inherited, deprecated;
@@ -102,7 +103,8 @@
this.endComment = javadocEnd;
this.index = javadocStart;
readChar(); // starting '/'
- int charPosition = this.index;
+ int previousPosition = this.index;
+ int endTextPosition = this.index;
readChar(); // first '*'
char nextCharacter= readChar(); // second '*'
@@ -124,7 +126,7 @@
// Loop on each comment character
while (this.index < this.endComment) {
- int previousPosition = this.index;
+ previousPosition = this.index;
previousChar = nextCharacter;
// Calculate line end (cannot use this.scanner.linePtr as scanner does not parse line ends again)
@@ -163,12 +165,12 @@
this.lineStarted = true;
if (this.inlineTagStarted) {
this.inlineTagStarted = false;
- if (this.sourceParser != null) this.sourceParser.problemReporter().javadocInvalidTag(this.inlineTagStart, charPosition);
+ if (this.sourceParser != null) this.sourceParser.problemReporter().javadocInvalidTag(this.inlineTagStart, endTextPosition);
validComment = false;
} else {
if (previousChar == '{') {
- if (this.textStart != -1 && this.textStart <= charPosition) {
- pushText(this.textStart, charPosition);
+ if (this.textStart != -1 && this.textStart < endTextPosition) {
+ pushText(this.textStart, endTextPosition);
}
this.inlineTagStarted = true;
}
@@ -283,9 +285,8 @@
break;
case '\r':
case '\n':
- int position = previousChar == '{' ? this.inlineTagStart : charPosition;
- if (this.lineStarted && this.textStart <= position) {
- pushText(this.textStart, position);
+ if (this.lineStarted && this.textStart < previousPosition) {
+ pushText(this.textStart, previousPosition);
}
this.lineStarted = false;
this.inlineTagStarted = false;
@@ -294,18 +295,18 @@
break;
case '}' :
if (this.inlineTagStarted) {
- if (this.lineStarted && this.textStart != -1 && this.textStart <= charPosition) {
- pushText(this.textStart, charPosition);
+ if (this.lineStarted && this.textStart != -1 && this.textStart < previousPosition) {
+ pushText(this.textStart, previousPosition);
}
if (this.kind == DOM_PARSER) refreshInlineTagPosition(previousPosition);
this.textStart = this.index;
this.inlineTagStarted = false;
- } else /*if (this.index <= this.lineEnd)*/ {
+ } else {
if (!this.lineStarted) {
this.textStart = previousPosition;
}
this.lineStarted = true;
- charPosition = previousPosition;
+ endTextPosition = previousPosition;
}
break;
case '{' :
@@ -321,10 +322,11 @@
}
break;
case '*' :
- charPosition = previousPosition;
+ // do nothing for '*' character
+ endTextPosition = previousPosition;
break;
default :
- charPosition = previousPosition;
+ endTextPosition = previousPosition;
if (!CharOperation.isWhitespace(nextCharacter)) {
if (!this.lineStarted) {
this.textStart = previousPosition;
@@ -333,8 +335,8 @@
}
}
}
- if (this.lineStarted && this.textStart <= charPosition) {
- pushText(this.textStart, charPosition);
+ if (this.lineStarted && this.textStart < previousPosition) {
+ pushText(this.textStart, previousPosition);
}
updateDocComment();
} catch (Exception ex) {
@@ -678,7 +680,7 @@
if (this.source[this.index] == '\r' || this.source[this.index] == '\n') {
if (this.kind == DOM_PARSER) {
parseTag();
- pushText(previousPosition, this.index-1);
+ pushText(previousPosition, this.index);
}
return true;
}
@@ -698,7 +700,7 @@
if (this.source[this.index] == '\r' || this.source[this.index] == '\n') {
if (this.kind == DOM_PARSER) {
parseTag();
- pushText(previousPosition, this.index-1);
+ pushText(previousPosition, this.index);
}
return true;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/JavadocParser.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/JavadocParser.java
index 7016c8f..4f7d12b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/JavadocParser.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/JavadocParser.java
@@ -38,12 +38,10 @@
// Public fields
public Javadoc docComment;
- public boolean checkDocComment = false;
JavadocParser(Parser sourceParser) {
super(sourceParser);
- this.checkDocComment = (this.sourceParser.options.getSeverity(CompilerOptions.InvalidJavadoc) != ProblemSeverities.Ignore) ||
- (this.sourceParser.options.getSeverity(CompilerOptions.MissingJavadocTags) != ProblemSeverities.Ignore);
+ this.checkDocComment = this.sourceParser.options.docCommentSupport;
this.kind = COMPIL_PARSER;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
index 9e44d03..2d82112 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
@@ -501,7 +501,11 @@
case IProblem.JavadocInvalidSeeHref:
case IProblem.JavadocInvalidSeeArgs:
case IProblem.JavadocInvalidTag:
- return this.options.getSeverity(CompilerOptions.InvalidJavadoc);
+ if (this.options.docCommentSupport) {
+ return this.options.getSeverity(CompilerOptions.InvalidJavadoc);
+ } else {
+ return ProblemSeverities.Ignore;
+ }
/*
* Javadoc tags resolved references errors
@@ -533,10 +537,11 @@
case IProblem.JavadocInternalTypeNameProvided:
case IProblem.JavadocNoMessageSendOnArrayType:
case IProblem.JavadocNoMessageSendOnBaseType:
- if (!this.options.reportInvalidJavadocTags)
- return ProblemSeverities.Ignore;
- else
+ if (this.options.docCommentSupport && this.options.reportInvalidJavadocTags) {
return this.options.getSeverity(CompilerOptions.InvalidJavadoc);
+ } else {
+ return ProblemSeverities.Ignore;
+ }
/*
* Javadoc missing tags errors
@@ -544,13 +549,21 @@
case IProblem.JavadocMissingParamTag:
case IProblem.JavadocMissingReturnTag:
case IProblem.JavadocMissingThrowsTag:
- return this.options.getSeverity(CompilerOptions.MissingJavadocTags);
+ if (this.options.docCommentSupport) {
+ return this.options.getSeverity(CompilerOptions.MissingJavadocTags);
+ } else {
+ return ProblemSeverities.Ignore;
+ }
/*
* Missing Javadoc errors
*/
case IProblem.JavadocMissing:
- return this.options.getSeverity(CompilerOptions.MissingJavadocComments);
+ if (this.options.docCommentSupport) {
+ return this.options.getSeverity(CompilerOptions.MissingJavadocComments);
+ } else {
+ return ProblemSeverities.Ignore;
+ }
// by default problems are errors.
default:
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AST.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AST.java
index 539e35b..1f5fac3 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AST.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AST.java
@@ -395,7 +395,7 @@
}
try {
this.disableEvents++;
- this.eventHandler.preRemoveChildEvent(node, child, property);
+ this.eventHandler.postRemoveChildEvent(node, child, property);
// N.B. even if event handler blows up, the AST is not
// corrupted since node has not been changed yet
} finally {
@@ -469,7 +469,7 @@
}
try {
this.disableEvents++;
- this.eventHandler.postAddChildEvent(node, child, property);
+ this.eventHandler.preAddChildEvent(node, child, property);
// N.B. even if event handler blows up, the AST is not
// corrupted since node has already been changed
} finally {
@@ -517,7 +517,7 @@
}
try {
this.disableEvents++;
- this.eventHandler.postValueChangeEvent(node, property);
+ this.eventHandler.preValueChangeEvent(node, property);
// N.B. even if event handler blows up, the AST is not
// corrupted since node has already been changed
} finally {
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
index 92e5238..7a292dd 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
@@ -44,6 +44,7 @@
private IProgressMonitor monitor;
// comments
private boolean insideComments;
+ private DocCommentParser docParser;
private Comment[] commentsTable;
public ASTConverter(Map options, boolean resolveBindings, IProgressMonitor monitor) {
@@ -56,11 +57,12 @@
null /*taskTags*/,
null/*taskPriorities*/);
this.monitor = monitor;
- this.insideComments = true;
+ this.insideComments = JavaCore.ENABLED.equals(options.get(JavaCore.COMPILER_DOC_COMMENT_SUPPORT));
}
public void setAST(AST ast) {
this.ast = ast;
+ this.docParser = new DocCommentParser(this.ast, this.scanner, this.insideComments);
}
/*
@@ -132,7 +134,7 @@
// Parse comments
int[][] comments = unit.comments;
- if (comments != null && this.insideComments) {
+ if (comments != null) {
buildCommentsTable(compilationUnit, comments);
}
@@ -1124,7 +1126,7 @@
}
}
AnonymousClassDeclaration anonymousClassDeclaration = this.ast.newAnonymousClassDeclaration();
- int start = retrieveStartBlockPosition(declarationSourceStart, allocation.anonymousType.bodyEnd);
+ int start = retrieveStartBlockPosition(allocation.anonymousType.sourceEnd, allocation.anonymousType.bodyEnd);
anonymousClassDeclaration.setSourceRange(start, allocation.anonymousType.bodyEnd - start + 1);
classInstanceCreation.setAnonymousClassDeclaration(anonymousClassDeclaration);
buildBodyDeclarations(allocation.anonymousType, anonymousClassDeclaration);
@@ -3094,8 +3096,7 @@
int end = positions[1];
if (positions[1]>0) { // Javadoc comments have positive end position
this.ast.newJavadoc();
- DocCommentParser docParser = new DocCommentParser(this.ast, this.scanner);
- Javadoc docComment = docParser.parse(positions);
+ Javadoc docComment = this.docParser.parse(positions);
if (docComment == null) return null;
comment = docComment;
} else {
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter2.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter2.java
index 8514e9e..8a46fae 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter2.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter2.java
@@ -44,6 +44,7 @@
private IProgressMonitor monitor;
// comments
private boolean insideComments;
+ private DocCommentParser docParser;
private Comment[] commentsTable;
public ASTConverter2(Map options, boolean resolveBindings, IProgressMonitor monitor) {
@@ -56,11 +57,12 @@
null /*taskTags*/,
null/*taskPriorities*/);
this.monitor = monitor;
- this.insideComments = true;
+ this.insideComments = JavaCore.ENABLED.equals(options.get(JavaCore.COMPILER_DOC_COMMENT_SUPPORT));
}
public void setAST(AST ast) {
this.ast = ast;
+ this.docParser = new DocCommentParser(this.ast, this.scanner, this.insideComments);
}
/*
@@ -132,7 +134,7 @@
// Parse comments
int[][] comments = unit.comments;
- if (comments != null && this.insideComments) {
+ if (comments != null) {
buildCommentsTable(compilationUnit, comments);
}
@@ -1124,7 +1126,7 @@
}
}
AnonymousClassDeclaration anonymousClassDeclaration = this.ast.newAnonymousClassDeclaration();
- int start = retrieveStartBlockPosition(declarationSourceStart, allocation.anonymousType.bodyEnd);
+ int start = retrieveStartBlockPosition(allocation.anonymousType.sourceEnd, allocation.anonymousType.bodyEnd);
anonymousClassDeclaration.setSourceRange(start, allocation.anonymousType.bodyEnd - start + 1);
classInstanceCreation.setAnonymousClassDeclaration(anonymousClassDeclaration);
buildBodyDeclarations(allocation.anonymousType, anonymousClassDeclaration);
@@ -3094,8 +3096,7 @@
int end = positions[1];
if (positions[1]>0) { // Javadoc comments have positive end position
this.ast.newJavadoc();
- DocCommentParser docParser = new DocCommentParser(this.ast, this.scanner);
- Javadoc docComment = docParser.parse(positions);
+ Javadoc docComment = this.docParser.parse(positions);
if (docComment == null) return null;
comment = docComment;
} else {
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
index 8eeca85..68839d3 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
@@ -54,6 +54,7 @@
import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
+import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
/**
* Internal class for resolving bindings using old ASTs.
@@ -132,10 +133,14 @@
// a extra lookup is required
BlockScope internalScope = (BlockScope) this.astNodesToBlockScope.get(name);
Binding binding = null;
- if (internalScope == null) {
- binding = this.scope.getTypeOrPackage(CharOperation.subarray(tokens, 0, indexInQualifiedName));
- } else {
- binding = internalScope.getTypeOrPackage(CharOperation.subarray(tokens, 0, indexInQualifiedName));
+ try {
+ if (internalScope == null) {
+ binding = this.scope.getTypeOrPackage(CharOperation.subarray(tokens, 0, indexInQualifiedName));
+ } else {
+ binding = internalScope.getTypeOrPackage(CharOperation.subarray(tokens, 0, indexInQualifiedName));
+ }
+ } catch (AbortCompilation e) {
+ // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=53357
}
if (binding instanceof org.eclipse.jdt.internal.compiler.lookup.PackageBinding) {
return this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding)binding);
@@ -205,10 +210,14 @@
if (indexInQualifiedName >= 0) {
BlockScope internalScope = (BlockScope) this.astNodesToBlockScope.get(name);
Binding binding = null;
- if (internalScope == null) {
- binding = this.scope.getTypeOrPackage(CharOperation.subarray(qualifiedTypeReference.tokens, 0, indexInQualifiedName));
- } else {
- binding = internalScope.getTypeOrPackage(CharOperation.subarray(qualifiedTypeReference.tokens, 0, indexInQualifiedName));
+ try {
+ if (internalScope == null) {
+ binding = this.scope.getTypeOrPackage(CharOperation.subarray(qualifiedTypeReference.tokens, 0, indexInQualifiedName));
+ } else {
+ binding = internalScope.getTypeOrPackage(CharOperation.subarray(qualifiedTypeReference.tokens, 0, indexInQualifiedName));
+ }
+ } catch (AbortCompilation e) {
+ // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=53357
}
if (binding instanceof org.eclipse.jdt.internal.compiler.lookup.PackageBinding) {
return this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding)binding);
@@ -225,7 +234,12 @@
int importReferenceLength = importReference.tokens.length;
int indexInImportReference = importReferenceLength - index; // one-based
if (indexInImportReference >= 0) {
- Binding binding = this.scope.getTypeOrPackage(CharOperation.subarray(importReference.tokens, 0, indexInImportReference));
+ Binding binding = null;
+ try {
+ binding = this.scope.getTypeOrPackage(CharOperation.subarray(importReference.tokens, 0, indexInImportReference));
+ } catch (AbortCompilation e) {
+ // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=53357
+ }
if (binding != null) {
if (binding instanceof org.eclipse.jdt.internal.compiler.lookup.PackageBinding) {
return this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding)binding);
@@ -709,34 +723,38 @@
* @see BindingResolver#resolveImport(ImportDeclaration)
*/
IBinding resolveImport(ImportDeclaration importDeclaration) {
- org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(importDeclaration);
- if (node instanceof ImportReference) {
- ImportReference importReference = (ImportReference) node;
- if (importReference.onDemand) {
- Binding binding = this.scope.getTypeOrPackage(CharOperation.subarray(importReference.tokens, 0, importReference.tokens.length));
- if (binding != null) {
- if (binding.bindingType() == BindingIds.PACKAGE) {
- IPackageBinding packageBinding = this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding) binding);
- if (packageBinding == null) {
- return null;
+ try {
+ org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(importDeclaration);
+ if (node instanceof ImportReference) {
+ ImportReference importReference = (ImportReference) node;
+ if (importReference.onDemand) {
+ Binding binding = this.scope.getTypeOrPackage(CharOperation.subarray(importReference.tokens, 0, importReference.tokens.length));
+ if (binding != null) {
+ if (binding.bindingType() == BindingIds.PACKAGE) {
+ IPackageBinding packageBinding = this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding) binding);
+ if (packageBinding == null) {
+ return null;
+ }
+ return packageBinding;
+ } else {
+ // if it is not a package, it has to be a type
+ ITypeBinding typeBinding = this.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) binding);
+ if (typeBinding == null) {
+ return null;
+ }
+ return typeBinding;
}
- return packageBinding;
- } else {
- // if it is not a package, it has to be a type
+ }
+ } else {
+ Binding binding = this.scope.getTypeOrPackage(importReference.tokens);
+ if (binding != null && binding instanceof org.eclipse.jdt.internal.compiler.lookup.TypeBinding) {
ITypeBinding typeBinding = this.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) binding);
- if (typeBinding == null) {
- return null;
- }
- return typeBinding;
+ return typeBinding == null ? null : typeBinding;
}
}
- } else {
- Binding binding = this.scope.getTypeOrPackage(importReference.tokens);
- if (binding != null && binding instanceof org.eclipse.jdt.internal.compiler.lookup.TypeBinding) {
- ITypeBinding typeBinding = this.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) binding);
- return typeBinding == null ? null : typeBinding;
- }
}
+ } catch(AbortCompilation e) {
+ // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=53357
}
return null;
}
@@ -745,22 +763,26 @@
* @see BindingResolver#resolvePackage(PackageDeclaration)
*/
IPackageBinding resolvePackage(PackageDeclaration pkg) {
- org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(pkg);
- if (node instanceof ImportReference) {
- ImportReference importReference = (ImportReference) node;
- Binding binding = this.scope.getTypeOrPackage(CharOperation.subarray(importReference.tokens, 0, importReference.tokens.length));
- if ((binding != null) && (binding.isValidBinding())) {
- IPackageBinding packageBinding = this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding) binding);
- if (packageBinding == null) {
- return null;
+ try {
+ org.eclipse.jdt.internal.compiler.ast.ASTNode node = (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(pkg);
+ if (node instanceof ImportReference) {
+ ImportReference importReference = (ImportReference) node;
+ Binding binding = this.scope.getTypeOrPackage(CharOperation.subarray(importReference.tokens, 0, importReference.tokens.length));
+ if ((binding != null) && (binding.isValidBinding())) {
+ IPackageBinding packageBinding = this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding) binding);
+ if (packageBinding == null) {
+ return null;
+ }
+ this.bindingsToAstNodes.put(packageBinding, pkg);
+ String key = packageBinding.getKey();
+ if (key != null) {
+ this.bindingKeysToAstNodes.put(key, pkg);
+ }
+ return packageBinding;
}
- this.bindingsToAstNodes.put(packageBinding, pkg);
- String key = packageBinding.getKey();
- if (key != null) {
- this.bindingKeysToAstNodes.put(key, pkg);
- }
- return packageBinding;
}
+ } catch (AbortCompilation e) {
+ // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=53357
}
return null;
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DocCommentParser.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DocCommentParser.java
index dec3fb0..1e3d3d3 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DocCommentParser.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DocCommentParser.java
@@ -26,15 +26,16 @@
class DocCommentParser extends AbstractCommentParser {
// Public fields
- private Javadoc docComment;
- private AST ast;
// Private fields
+ private Javadoc docComment;
+ private AST ast;
- DocCommentParser(AST ast, Scanner scanner) {
+ DocCommentParser(AST ast, Scanner scanner, boolean check) {
super(null);
this.ast = ast;
this.scanner = scanner;
+ this.checkDocComment = check;
this.kind = DOM_PARSER;
}
@@ -55,7 +56,9 @@
this.docComment = this.ast.newJavadoc();
// Parse
- parseComment(start, start+length-1);
+ if (this.checkDocComment) {
+ parseComment(start, start+length-1);
+ }
this.docComment.setSourceRange(start, length);
setComment(start, length); // backward compatibility
return this.docComment;
@@ -344,13 +347,13 @@
*/
protected void pushText(int start, int end) {
TextElement text = this.ast.newTextElement();
- text.setText(new String( this.source, start, end-start+1));
- text.setSourceRange(start, end-start+1);
+ text.setText(new String( this.source, start, end-start));
+ text.setSourceRange(start, end-start);
TagElement previousTag = null;
int previousStart = start;
if (this.astPtr == -1) {
previousTag = this.ast.newTagElement();
- previousTag.setSourceRange(start, end-start+1);
+ previousTag.setSourceRange(start, end-start);
pushOnAstStack(previousTag, true);
} else {
previousTag = (TagElement) this.astStack[this.astPtr];
@@ -370,7 +373,7 @@
}
}
previousTag.fragments().add(text);
- previousTag.setSourceRange(previousStart, end-previousStart+1);
+ previousTag.setSourceRange(previousStart, end-previousStart);
this.textStart = -1;
}
/* (non-Javadoc)
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/EnumDeclaration.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/EnumDeclaration.java
index 86d5539..77e417e 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/EnumDeclaration.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/EnumDeclaration.java
@@ -22,7 +22,7 @@
* [ Javadoc ] { ExtendedModifier } <b>enum</b> Identifier
* [ <b>implements</b> Type { <b>,</b> Type } ]
* <b>{</b>
- * [ EnumConstantDeclaration { <b>,</b> EnumConstantDeclaration } ]
+ * [ EnumConstantDeclaration { <b>,</b> EnumConstantDeclaration } ] [ <b>,</b> ]
* [ <b>;</b> { ClassBodyDeclaration | <b>;</b> } ]
* <b>}</b>
* </pre>
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/ICompilationUnit.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/ICompilationUnit.java
index 0503c0c..b7c396c 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/ICompilationUnit.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/ICompilationUnit.java
@@ -537,6 +537,7 @@
* if the working copy was already consistent.
* </p>
*
+ * @param createAST boolean indicating whether a compilation unit AST should be created.
* @param forceProblemDetection boolean indicating whether problem should be recomputed
* even if the source hasn't changed.
* @param owner the owner of working copies that take precedence over the original compilation units,
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 e4e3a75..ac712ca 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
@@ -152,6 +152,12 @@
/**
* Possible configurable option ID.
* @see #getDefaultOptions()
+ * @since 3.0
+ */
+ public static final String COMPILER_DOC_COMMENT_SUPPORT = PLUGIN_ID + ".compiler.doc.comment.support"; //$NON-NLS-1$
+ /**
+ * Possible configurable option ID.
+ * @see #getDefaultOptions()
* @deprecated - discontinued since turning off would violate language specs
*/
public static final String COMPILER_PB_UNREACHABLE_CODE = PLUGIN_ID + ".compiler.problem.unreachableCode"; //$NON-NLS-1$
@@ -348,14 +354,6 @@
public static final String COMPILER_PB_INVALID_JAVADOC = PLUGIN_ID + ".compiler.problem.invalidJavadoc"; //$NON-NLS-1$
/**
* Possible configurable option ID.
- * @see #COMPILER_PB_INVALID_JAVADOC
- * @deprecated
- * TODO (frederic) remove after 3.0 M6
- */
- public static final String COMPILER_PB_INVALID_ANNOTATION = COMPILER_PB_INVALID_JAVADOC;
- public static final String OLD_COMPILER_PB_INVALID_ANNOTATION = PLUGIN_ID + ".compiler.problem.invalidAnnotation"; //$NON-NLS-1$
- /**
- * Possible configurable option ID.
* @see #getDefaultOptions()
* @since 3.0
*/
@@ -394,23 +392,6 @@
* Possible configurable option ID.
* @see #getDefaultOptions()
* @since 3.0
- * @deprecated
- * TODO (frederic) remove after 3.0 M7
- */
- public static final String COMPILER_PB_MISSING_JAVADOC = COMPILER_PB_MISSING_JAVADOC_COMMENTS;
- public static final String OLD_COMPILER_PB_MISSING_JAVADOC = PLUGIN_ID + ".compiler.problem.missingJavadoc"; //$NON-NLS-1$
- /**
- * Possible configurable option ID.
- * @see #COMPILER_PB_MISSING_JAVADOC
- * @deprecated
- * TODO (frederic) after 3.0 M6
- */
- public static final String COMPILER_PB_MISSING_ANNOTATION = COMPILER_PB_MISSING_JAVADOC;
- public static final String OLD_COMPILER_PB_MISSING_ANNOTATION = PLUGIN_ID + ".compiler.problem.missingAnnotation"; //$NON-NLS-1$
- /**
- * Possible configurable option ID.
- * @see #getDefaultOptions()
- * @since 3.0
*/
public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY = PLUGIN_ID + ".compiler.problem.missingJavadocCommentsVisibility"; //$NON-NLS-1$
/**
@@ -1420,6 +1401,14 @@
* - possible values: { "1.1", "1.2", "1.3", "1.4" }
* - default: "1.2"
*
+ * COMPILER / Javadoc Comment Support
+ * When this support is disabled, the compiler will ignore all javadoc problems options settings
+ * and will not report any javadoc problem. It will also not find any reference in javadoc comment and
+ * DOM AST Javadoc node will be only a flat text instead of having structured tag elements.
+ * - option id: "org.eclipse.jdt.core.compiler.doc.comment.support"
+ * - possible values: { "enabled", "disabled" }
+ * - default: "enabled"
+ *
* COMPILER / Reporting Attempt to Override Package-Default Method
* A package default method is not visible in a different package, and thus
* cannot be overridden. When enabling this option, the compiler will signal
@@ -2098,31 +2087,6 @@
if (optionNames.contains(propertyName)){
options.put(propertyName, value);
}
- // bug 45112 backward compatibility.
- // TODO (frederic) remove after 3.0 M6
- else if (CompilerOptions.OPTION_ReportInvalidAnnotation.equals(propertyName)) {
- options.put(COMPILER_PB_INVALID_JAVADOC, value);
- }
- else if (CompilerOptions.OPTION_ReportMissingAnnotation.equals(propertyName)) {
- if (ENABLED.equals(value)) {
- value = preferences.getString(CompilerOptions.OPTION_ReportInvalidAnnotation);
- } else {
- value = IGNORE;
- }
- options.put(COMPILER_PB_MISSING_JAVADOC_COMMENTS, value);
- }
- // end bug 45112
- // bug 46854 backward compatibility
- // TODO (frederic) remove after 3.0 M7
- else if (CompilerOptions.OPTION_ReportMissingJavadoc.equals(propertyName)) {
- if (ENABLED.equals(value)) {
- value = preferences.getString(COMPILER_PB_INVALID_JAVADOC);
- } else {
- value = IGNORE;
- }
- options.put(COMPILER_PB_MISSING_JAVADOC_COMMENTS, value);
- }
- // end bug 46854
// TODO (olivier) Remove after M7
else if (propertyName.startsWith(JavaCore.PLUGIN_ID + ".formatter")) {//$NON-NLS-1$
Util.convertFormatterDeprecatedOptions(propertyName, value, options);
@@ -2329,7 +2293,8 @@
preferences.setDefault(COMPILER_CODEGEN_UNUSED_LOCAL, PRESERVE);
preferences.setDefault(COMPILER_TASK_TAGS, DEFAULT_TASK_TAG);
preferences.setDefault(COMPILER_TASK_PRIORITIES, DEFAULT_TASK_PRIORITY);
-
+ preferences.setDefault(COMPILER_DOC_COMMENT_SUPPORT, ENABLED);
+
// Builder settings
preferences.setDefault(CORE_JAVA_BUILD_RESOURCE_COPY_FILTER, ""); //$NON-NLS-1$
optionNames.add(CORE_JAVA_BUILD_RESOURCE_COPY_FILTER);
@@ -3490,24 +3455,16 @@
preferences.setValue(key, value);
}
- // Backward compatibility
+ /* Test OPTION_DocCommentSupport
String[] propertyNames = preferences.propertyNames();
for (int i = 0; i < propertyNames.length; i++){
String propertyName = propertyNames[i];
- // bug 45112
- if (CompilerOptions.OPTION_ReportInvalidAnnotation.equals(propertyName)) {
- preferences.setToDefault(OLD_COMPILER_PB_INVALID_ANNOTATION);
+ // set same value than missing javadoc comments overriding
+ if (CompilerOptions.OPTION_ReportMissingJavadocCommentsOverriding.equals(propertyName)) {
+ preferences.setValue(COMPILER_DOC_COMMENT_SUPPORT, preferences.getString(propertyName));
}
- else if (CompilerOptions.OPTION_ReportMissingAnnotation.equals(propertyName)) {
- preferences.setToDefault(OLD_COMPILER_PB_MISSING_ANNOTATION);
- }
- // end bug 45112
- // bug 46854
- else if (CompilerOptions.OPTION_ReportMissingJavadoc.equals(propertyName)) {
- preferences.setToDefault(OLD_COMPILER_PB_MISSING_JAVADOC);
- }
- // end bug 46854
}
+ */
// persist options
getPlugin().savePluginPreferences();
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java
index 81451ad..1c603e7 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java
@@ -69,7 +69,6 @@
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.core.eval.IEvaluationContext;
import org.eclipse.jdt.internal.codeassist.ISearchableNameEnvironment;
-import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.util.ObjectVector;
import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
import org.eclipse.jdt.internal.core.eval.EvaluationContextWrapper;
@@ -1432,31 +1431,6 @@
if (optionNames.contains(propertyName)){
options.put(propertyName, value);
}
- // bug 45112 backward compatibility.
- // TODO (frederic) remove after 3.0 M6
- else if (CompilerOptions.OPTION_ReportInvalidAnnotation.equals(propertyName)) {
- options.put(JavaCore.COMPILER_PB_INVALID_JAVADOC, value);
- }
- else if (CompilerOptions.OPTION_ReportMissingAnnotation.equals(propertyName)) {
- if (JavaCore.ENABLED.equals(value)) {
- value = preferences.getString(JavaCore.COMPILER_PB_INVALID_JAVADOC);
- } else {
- value = JavaCore.IGNORE;
- }
- options.put(JavaCore.COMPILER_PB_MISSING_JAVADOC_COMMENTS, value);
- }
- // end bug 45112
- // bug 46854 backward compatibility
- // TODO (frederic) remove after 3.0 M7
- else if (CompilerOptions.OPTION_ReportMissingJavadoc.equals(propertyName)) {
- if (JavaCore.ENABLED.equals(value)) {
- value = preferences.getString(JavaCore.COMPILER_PB_INVALID_JAVADOC);
- } else {
- value = JavaCore.IGNORE;
- }
- options.put(JavaCore.COMPILER_PB_MISSING_JAVADOC_COMMENTS, value);
- }
- // end bug 46854
// TODO (olivier) Remove after M7
else if (propertyName.startsWith(JavaCore.PLUGIN_ID + ".formatter")) {//$NON-NLS-1$
Util.convertFormatterDeprecatedOptions(propertyName, value, options);
@@ -2521,24 +2495,16 @@
}
}
- // Backward compatibility
+ /* Test OPTION_DocCommentSupport
String[] propertyNames = preferences.propertyNames();
for (int i = 0; i < propertyNames.length; i++){
String propertyName = propertyNames[i];
- // bug 45112
- if (CompilerOptions.OPTION_ReportInvalidAnnotation.equals(propertyName)) {
- preferences.setToDefault(JavaCore.OLD_COMPILER_PB_INVALID_ANNOTATION);
+ // set same value than missing javadoc comments overriding
+ if (CompilerOptions.OPTION_ReportMissingJavadocCommentsOverriding.equals(propertyName)) {
+ preferences.setValue(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, preferences.getString(propertyName));
}
- else if (CompilerOptions.OPTION_ReportMissingAnnotation.equals(propertyName)) {
- preferences.setToDefault(JavaCore.OLD_COMPILER_PB_MISSING_ANNOTATION);
- }
- // end bug 45112
- // bug 46854
- else if (CompilerOptions.OPTION_ReportMissingJavadoc.equals(propertyName)) {
- preferences.setToDefault(JavaCore.OLD_COMPILER_PB_MISSING_JAVADOC);
- }
- // end bug 46854
}
+ */
// persist options
savePreferences(preferences);
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/CommentRecorderParser.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/CommentRecorderParser.java
index 922662a..6199584 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/CommentRecorderParser.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/CommentRecorderParser.java
@@ -35,7 +35,6 @@
*/
public CommentRecorderParser(ProblemReporter problemReporter, boolean optimizeStringLiterals) {
super(problemReporter, optimizeStringLiterals);
- this.javadocParser.checkDocComment = true;
}
// old javadoc style check which doesn't include all leading comments into declaration
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/PublicScanner.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/PublicScanner.java
index bd19da5..63bce13 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/PublicScanner.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/PublicScanner.java
@@ -62,6 +62,7 @@
public int[] commentStops = new int[10];
public int[] commentStarts = new int[10];
public int commentPtr = -1; // no comment test with commentPtr value -1
+ protected int lastCommentLinePosition = -1;
// task tag support
public char[][] foundTaskTags = null;
@@ -1226,6 +1227,7 @@
{
int test;
if ((test = getNextChar('/', '*')) == 0) { //line comment
+ this.lastCommentLinePosition = this.currentPosition;
try { //get the next char
if (((this.currentCharacter = this.source[this.currentPosition++]) == '\\')
&& (this.source[this.currentPosition] == 'u')) {
@@ -1256,6 +1258,7 @@
} //jump over the \\
boolean isUnicode = false;
while (this.currentCharacter != '\r' && this.currentCharacter != '\n') {
+ this.lastCommentLinePosition = this.currentPosition;
//get the next char
isUnicode = false;
if (((this.currentCharacter = this.source[this.currentPosition++]) == '\\')
@@ -1638,6 +1641,7 @@
int test;
if ((test = getNextChar('/', '*')) == 0) { //line comment
try {
+ this.lastCommentLinePosition = this.currentPosition;
//get the next char
if (((this.currentCharacter = this.source[this.currentPosition++]) == '\\')
&& (this.source[this.currentPosition] == 'u')) {
@@ -1668,6 +1672,7 @@
} //jump over the \\
boolean isUnicode = false;
while (this.currentCharacter != '\r' && this.currentCharacter != '\n') {
+ this.lastCommentLinePosition = this.currentPosition;
//get the next char
isUnicode = false;
if (((this.currentCharacter = this.source[this.currentPosition++]) == '\\')
@@ -2280,16 +2285,26 @@
}
}
public void recordComment(int token) {
+ // compute position
+ int stopPosition = this.currentPosition;
+ switch (token) {
+ case TokenNameCOMMENT_LINE:
+ stopPosition = -this.lastCommentLinePosition;
+ break;
+ case TokenNameCOMMENT_BLOCK:
+ stopPosition = -this.currentPosition;
+ break;
+ }
// a new comment is recorded
try {
- this.commentStops[++this.commentPtr] = (token==TokenNameCOMMENT_JAVADOC) ? this.currentPosition : -this.currentPosition;
+ this.commentStops[++this.commentPtr] = stopPosition;
} catch (IndexOutOfBoundsException e) {
int oldStackLength = this.commentStops.length;
int[] oldStack = this.commentStops;
this.commentStops = new int[oldStackLength + 30];
System.arraycopy(oldStack, 0, this.commentStops, 0, oldStackLength);
- this.commentStops[this.commentPtr] = (token==TokenNameCOMMENT_JAVADOC) ? this.currentPosition : -this.currentPosition;
+ this.commentStops[this.commentPtr] = stopPosition;
//grows the positions buffers too
int[] old = this.commentStarts;
this.commentStarts = new int[oldStackLength + 30];
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocatorParser.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocatorParser.java
index 59b1466..508d030 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocatorParser.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocatorParser.java
@@ -96,9 +96,6 @@
? new MethodButNoClassDeclarationVisitor()
: new NoClassNoMethodDeclarationVisitor();
}
-
- // Always check javadoc while matching indexes
- this.javadocParser.checkDocComment = true;
}
public void checkComment() {
super.checkComment();
