From ad67700b1cc685f115da14a5af759b8859f1e9c2 Mon Sep 17 00:00:00 2001 From: Jakob Odersky Date: Fri, 22 Jul 2016 18:34:47 -0700 Subject: Javadoc: fix problems in community build - fix initialization NPE in doc headers - fix assertion errors for java fields - ignore comments when deciding where to put interface methods - consider DocDefs when checking for constructors --- test/scaladoc/resources/SI-4826.java | 289 +++++++++++++++++++++++++++++++++++ test/scaladoc/run/SI-4826.scala | 2 +- 2 files changed, 290 insertions(+), 1 deletion(-) (limited to 'test') diff --git a/test/scaladoc/resources/SI-4826.java b/test/scaladoc/resources/SI-4826.java index f735ce6335..18a1cb86f2 100644 --- a/test/scaladoc/resources/SI-4826.java +++ b/test/scaladoc/resources/SI-4826.java @@ -1,3 +1,6 @@ +/** + * A package header + */ package test.scaladoc; /** @@ -6,6 +9,29 @@ package test.scaladoc; */ public class JavaComments { + /** A field */ + public final int x; + /** A field */ + protected int y; + /** A field */ + private int z; + + /** + * Inner class + */ + public class Inner { + /** Inner method */ + public void foo() { + } + } + + /** + * A typed inner class + * @param some type + */ + public class InnerTyped { + } + /** * Compute the answer to the ultimate question of life, the * universe, and everything. :marker: @@ -16,5 +42,268 @@ public class JavaComments { return 42 * factor; } + /** Private */ + private double foo(double value) { + return value; + } + + /** Protected */ + protected double bar(double value) { + return value; + } + + /** No qualifier*/ + String noqualifier() { + return "something"; + } + + /** Void */ + public void voidmethod(boolean t) { + } + + /** + * Typed parameter + * @param the parameter type + * @param a parameter + * @return something + */ + public void tparams(A a) { + } + + /** + * Typed parameter + * @param the return type + * @param the parameter typeA + * @param b parameter + * @return casts B to A + */ + public A cast(B b) { + return (B) b; + } + } +// The following snippet is taken from Akka, it mainly tests interfaces + +/** + * Class that encapsulates all the Functional Interfaces + * used for creating partial functions. + * + * This is an EXPERIMENTAL feature and is subject to change until it has received more real world testing. + */ +public final class FI { + + /** Doc comment on constructor */ + private FI() { + } + + /** + * Functional interface for an application. + * + * @param the input type, that this Apply will be applied to + * @param the return type, that the results of the application will have + */ + public static interface Apply { + /** + * The application to perform. + * + * @param i an instance that the application is performed on + * @return the result of the application + */ + public R apply(I i) throws Exception; + } + + /** + * Functional interface for an application. + * + * @param the first input type, that this Apply will be applied to + * @param the second input type, that this Apply will be applied to + * @param the return type, that the results of the application will have + */ + public static interface Apply2 { + /** + * The application to perform. + * + * @param i1 an instance that the application is performed on + * @param i2 an instance that the application is performed on + * @return the result of the application + */ + public R apply(I1 i1, I2 i2) throws Exception; + } + + /** + * Functional interface for a predicate. + * + * @param the type that the predicate will operate on. + */ + public static interface TypedPredicate { + /** + * The predicate to evaluate. + * + * @param t an instance that the predicate is evaluated on. + * @return the result of the predicate + */ + public boolean defined(T t); + } + + /** + * Functional interface for a predicate. + * + * @param the type that the predicate will operate on. + * @param the type that the predicate will operate on. + */ + public static interface TypedPredicate2 { + /** + * The predicate to evaluate. + * + * @param t an instance that the predicate is evaluated on. + * @param u an instance that the predicate is evaluated on. + * @return the result of the predicate + */ + public boolean defined(T t, U u); + } + + /** + * Functional interface for an application. + * + * @param the input type, that this Apply will be applied to + */ + public static interface UnitApply { + /** + * The application to perform. + * + * @param i an instance that the application is performed on + */ + public void apply(I i) throws Exception; + } + + /** + * Functional interface for an application. + * + * @param the first input type, that this Apply will be applied to + * @param the second input type, that this Apply will be applied to + */ + public static interface UnitApply2 { + /** + * The application to perform. + * + * @param i1 an instance that the application is performed on + * @param i2 an instance that the application is performed on + */ + public void apply(I1 i1, I2 i2) throws Exception; + } + + /** + * Functional interface for an application. + * + * @param the first input type, that this Apply will be applied to + * @param the second input type, that this Apply will be applied to + * @param the third input type, that this Apply will be applied to + */ + public static interface UnitApply3 { + /** + * The application to perform. + * + * @param i1 an instance that the application is performed on + * @param i2 an instance that the application is performed on + * @param i3 an instance that the application is performed on + */ + public void apply(I1 i1, I2 i2, I3 i3) throws Exception; + } + + /** + * Functional interface for an application. + * + * @param the first input type, that this Apply will be applied to + * @param the second input type, that this Apply will be applied to + * @param the third input type, that this Apply will be applied to + * @param the fourth input type, that this Apply will be applied to + */ + public static interface UnitApply4 { + /** + * The application to perform. + * + * @param i1 an instance that the application is performed on + * @param i2 an instance that the application is performed on + * @param i3 an instance that the application is performed on + * @param i4 an instance that the application is performed on + */ + public void apply(I1 i1, I2 i2, I3 i3, I4 i4) throws Exception; + } + + /** + * Functional interface for an application. + */ + public static interface UnitApplyVoid { + /** + * The application to perform. + */ + public void apply() throws Exception; + } + + /** + * Package scoped functional interface for a predicate. Used internally to match against arbitrary types. + */ + static interface Predicate { + /** + * The predicate to evaluate. + * + * @param o an instance that the predicate is evaluated on. + * @return the result of the predicate + */ + public boolean defined(Object o); + } + + /** comment about */ + /** a comment about */ + /** a comment */ + void foo() {} + + /** someone forgot to uncomment */ + //void thisMethod() {} + /** and also this */ + //void otherMethod() {} +} + +/** + * Functional interface for an application. + * + * @param the first input type, that this Apply will be applied to + * @param the second input type, that this Apply will be applied to + * @param the third input type, that this Apply will be applied to + * @param the fourth input type, that this Apply will be applied to + */ +public interface UnitApply4 { + /** + * The application to perform. + * + * @param i1 an instance that the application is performed on + * @param i2 an instance that the application is performed on + * @param i3 an instance that the application is performed on + * @param i4 an instance that the application is performed on + */ + public void apply(I1 i1, I2 i2, I3 i3, I4 i4) throws Exception; +} + +/** + * Functional interface for an application. + */ +public interface UnitApplyVoid { + /** + * The application to perform. + */ + public void apply() throws Exception; +} + +/** + * Package scoped functional interface for a predicate. Used internally to match against arbitrary types. + */ +interface Predicate { + /** + * The predicate to evaluate. + * + * @param o an instance that the predicate is evaluated on. + * @return the result of the predicate + */ + public boolean defined(Object o); +} diff --git a/test/scaladoc/run/SI-4826.scala b/test/scaladoc/run/SI-4826.scala index 50e4468002..277ff37692 100644 --- a/test/scaladoc/run/SI-4826.scala +++ b/test/scaladoc/run/SI-4826.scala @@ -14,7 +14,7 @@ object Test extends ScaladocModelTest { } // no need for special settings - def scaladocSettings = "" + override def scaladocSettings = "" def testModel(rootPackage: Package) = { import access._ -- cgit v1.2.3