From 2d3b98e847b9dc1878b657de97fce2f54104776d Mon Sep 17 00:00:00 2001 From: Reinier Zwitserloot Date: Fri, 16 Oct 2009 10:16:03 +0200 Subject: Switched all use of in javadoc to {@code}. --- src/lombok/Data.java | 8 +++--- src/lombok/EqualsAndHashCode.java | 30 +++++++++++----------- src/lombok/Getter.java | 6 ++--- src/lombok/Lombok.java | 6 ++--- src/lombok/NonNull.java | 8 +++--- src/lombok/Setter.java | 2 +- src/lombok/SneakyThrows.java | 8 +++--- src/lombok/Synchronized.java | 4 +-- src/lombok/ToString.java | 24 ++++++++--------- src/lombok/core/SpiLoadUtil.java | 6 ++--- src/lombok/core/TransformationsUtil.java | 4 +-- src/lombok/eclipse/EclipseAnnotationHandler.java | 8 +++--- src/lombok/eclipse/HandlerLibrary.java | 8 +++--- src/lombok/eclipse/TransformEclipseAST.java | 2 +- src/lombok/eclipse/handlers/HandleCleanup.java | 2 +- src/lombok/eclipse/handlers/HandleData.java | 2 +- .../eclipse/handlers/HandleEqualsAndHashCode.java | 2 +- src/lombok/eclipse/handlers/HandleGetter.java | 4 +-- src/lombok/eclipse/handlers/HandlePrintAST.java | 2 +- src/lombok/eclipse/handlers/HandleSetter.java | 4 +-- .../eclipse/handlers/HandleSneakyThrows.java | 2 +- .../eclipse/handlers/HandleSynchronized.java | 2 +- src/lombok/eclipse/handlers/HandleToString.java | 2 +- src/lombok/javac/HandlerLibrary.java | 8 +++--- src/lombok/javac/Javac.java | 6 ++--- src/lombok/javac/JavacAST.java | 2 +- src/lombok/javac/JavacAnnotationHandler.java | 8 +++--- src/lombok/javac/handlers/HandleCleanup.java | 2 +- src/lombok/javac/handlers/HandleData.java | 2 +- .../javac/handlers/HandleEqualsAndHashCode.java | 2 +- src/lombok/javac/handlers/HandleGetter.java | 4 +-- src/lombok/javac/handlers/HandlePrintAST.java | 2 +- src/lombok/javac/handlers/HandleSetter.java | 4 +-- src/lombok/javac/handlers/HandleSneakyThrows.java | 2 +- src/lombok/javac/handlers/HandleSynchronized.java | 2 +- src/lombok/javac/handlers/HandleToString.java | 2 +- src/lombok/javac/handlers/PKG.java | 8 +++--- 37 files changed, 100 insertions(+), 100 deletions(-) (limited to 'src/lombok') diff --git a/src/lombok/Data.java b/src/lombok/Data.java index fa424c24..488de640 100644 --- a/src/lombok/Data.java +++ b/src/lombok/Data.java @@ -37,10 +37,10 @@ import java.lang.annotation.Target; * while the generated hashCode and equals take into account all non-transient fields.
* Static fields are skipped (no getter or setter, and they are not included in toString, equals, hashCode, or the constructor). *

- * toString, equals, and hashCode use the deepX variants in the - * java.util.Arrays utility class. Therefore, if your class has arrays that contain themselves, - * these methods will just loop endlessly until the inevitable StackOverflowError. This behaviour - * is no different from java.util.ArrayList, though. + * {@code toString}, {@code equals}, and {@code hashCode} use the deepX variants in the + * {@code java.util.Arrays} utility class. Therefore, if your class has arrays that contain themselves, + * these methods will just loop endlessly until the inevitable {@code StackOverflowError}. This behaviour + * is no different from {@code java.util.ArrayList}, though. */ @Target(ElementType.TYPE) @Retention(RetentionPolicy.SOURCE) diff --git a/src/lombok/EqualsAndHashCode.java b/src/lombok/EqualsAndHashCode.java index f752d70c..88d72051 100644 --- a/src/lombok/EqualsAndHashCode.java +++ b/src/lombok/EqualsAndHashCode.java @@ -27,29 +27,29 @@ import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** - * Generates implementations for the equals and hashCode methods inherited by all objects. + * Generates implementations for the {@code equals} and {@code hashCode} methods inherited by all objects. *

- * If either method already exists, then @EqualsAndHashCode will not generate that particular method. - * If they all exist, @EqualsAndHashCode generates no methods, and emits a warning instead to highlight + * If either method already exists, then {@code @EqualsAndHashCode} will not generate that particular method. + * If they all exist, {@code @EqualsAndHashCode} generates no methods, and emits a warning instead to highlight * that its doing nothing at all. The parameter list and return type are not relevant when deciding to skip generation of - * a method; any method named hashCode will make @EqualsAndHashCode not generate that method, + * a method; any method named {@code hashCode} will make {@code @EqualsAndHashCode} not generate that method, * for example. *

* By default, all fields that are non-static and non-transient are used in the equality check and hashCode generation. - * You can exclude more fields by specifying them in the exclude parameter. You can also explicitly specify - * the fields that are to be used by specifying them in the of parameter. + * You can exclude more fields by specifying them in the {@code exclude} parameter. You can also explicitly specify + * the fields that are to be used by specifying them in the {@code of} parameter. *

- * Normally, auto-generating hashCode and equals implementations in a subclass is a bad idea, as + * Normally, auto-generating {@code hashCode} and {@code equals} implementations in a subclass is a bad idea, as * the superclass also defines fields, for which equality checks/hashcodes won't be auto-generated. Therefore, a warning - * is emitted when you try. Instead, you can set the callSuper parameter to true which will call - * super.equals and super.hashCode. Doing this with java.lang.Object as superclass is + * is emitted when you try. Instead, you can set the {@code callSuper} parameter to true which will call + * {@code super.equals} and {@code super.hashCode}. Doing this with {@code java.lang.Object} as superclass is * pointless, so, conversely, setting this flag when NOT extending something (other than Object) will also generate - * a warning. Be aware that not all implementations of equals correctly handle being called from a subclass! - * Fortunately, lombok-generated equals implementations do correctly handle it. + * a warning. Be aware that not all implementations of {@code equals} correctly handle being called from a subclass! + * Fortunately, lombok-generated {@code equals} implementations do correctly handle it. *

* Array fields are handled by way of {@link java.util.Arrays#deepEquals(Object[], Object[])} where necessary, as well - * as deepHashCode. The downside is that arrays with circular references (arrays that contain themselves, - * possibly indirectly) results in calls to hashCode and equals throwing a + * as {@code deepHashCode}. The downside is that arrays with circular references (arrays that contain themselves, + * possibly indirectly) results in calls to {@code hashCode} and {@code equals} throwing a * {@link java.lang.StackOverflowError}. However, the implementations for java's own {@link java.util.ArrayList} suffer * from the same flaw. */ @@ -58,7 +58,7 @@ import java.lang.annotation.Target; public @interface EqualsAndHashCode { /** * Any fields listed here will not be taken into account in the generated - * equals and hashCode implementations. + * {@code equals} and {@code hashCode} implementations. * Mutually exclusive with {@link #of()}. */ String[] exclude() default {}; @@ -72,7 +72,7 @@ public @interface EqualsAndHashCode { String[] of() default {}; /** - * Call on the superclass's implementations of equals and hashCode before calculating + * Call on the superclass's implementations of {@code equals} and {@code hashCode} before calculating * for the fields in this class. * default: false */ diff --git a/src/lombok/Getter.java b/src/lombok/Getter.java index 210957a0..fa84954c 100644 --- a/src/lombok/Getter.java +++ b/src/lombok/Getter.java @@ -42,10 +42,10 @@ import java.lang.annotation.Target; * } * * - * Note that fields of type boolean (but not java.lang.Boolean) will result in an - * isFoo name instead of getFoo. + * Note that fields of type {@code boolean} (but not {@code java.lang.Boolean}) will result in an + * {@code isFoo} name instead of {@code getFoo}. *

- * If any method named getFoo/isFoo exists, regardless of return type or parameters, no method is generated, + * If any method named {@code getFoo}/{@code isFoo} exists, regardless of return type or parameters, no method is generated, * and instead a compiler warning is emitted. */ @Target(ElementType.FIELD) diff --git a/src/lombok/Lombok.java b/src/lombok/Lombok.java index f2f196ed..71684f4f 100644 --- a/src/lombok/Lombok.java +++ b/src/lombok/Lombok.java @@ -39,9 +39,9 @@ public class Lombok { * about the concept of a 'checked exception'. All this method does is hide the act of throwing a checked exception * from the java compiler. *

- * Note that this method has a return type of RuntimeException it is advised you always call this - * method as argument to the throw statement to avoid compiler errors regarding no return - * statement and similar problems. This method won't of course return an actual RuntimeException - + * Note that this method has a return type of {@code RuntimeException} it is advised you always call this + * method as argument to the {@code throw} statement to avoid compiler errors regarding no return + * statement and similar problems. This method won't of course return an actual {@code RuntimeException} - * it never returns, it always throws the provided exception. * * @param t The throwable to throw without requiring you to catch its type. diff --git a/src/lombok/NonNull.java b/src/lombok/NonNull.java index 80dc381a..08eec2a5 100644 --- a/src/lombok/NonNull.java +++ b/src/lombok/NonNull.java @@ -27,16 +27,16 @@ import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** - * Lombok is smart enough to translate any annotation named @NonNull or @NotNull in any casing and + * Lombok is smart enough to translate any annotation named {@code @NonNull} or {@code @NotNull} in any casing and * with any package name to the return type of generated getters and the parameter of generated setters and constructors, * as well as generate the appropriate null checks in the setter and constructor. * * You can use this annotation for the purpose, though you can also use JSR305's annotation, findbugs's, pmd's, or IDEA's, or just - * about anyone elses. As long as it is named @NonNull or @NotNull. + * about anyone elses. As long as it is named {@code @NonNull} or {@code @NotNull}. * - * WARNING: If the java community ever does decide on supporting a single @NonNull annotation (for example via JSR305), then + * WARNING: If the java community ever does decide on supporting a single {@code @NonNull} annotation (for example via JSR305), then * this annotation will be deleted from the lombok package. If the need to update an import statement scares - * you, you should use your own annotation named @NonNull instead of this one. + * you, you should use your own annotation named {@code @NonNull} instead of this one. */ @Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE}) @Retention(RetentionPolicy.CLASS) diff --git a/src/lombok/Setter.java b/src/lombok/Setter.java index 213ca9c6..778bb00d 100644 --- a/src/lombok/Setter.java +++ b/src/lombok/Setter.java @@ -42,7 +42,7 @@ import java.lang.annotation.Target; * } * * - * If any method named setFoo exists, regardless of return type or parameters, no method is generated, + * If any method named {@code setFoo} exists, regardless of return type or parameters, no method is generated, * and instead a compiler warning is emitted. */ @Target(ElementType.FIELD) diff --git a/src/lombok/SneakyThrows.java b/src/lombok/SneakyThrows.java index 6db29dce..1feeadf1 100644 --- a/src/lombok/SneakyThrows.java +++ b/src/lombok/SneakyThrows.java @@ -37,8 +37,8 @@ import java.lang.annotation.Target; * You should use this annotation ONLY in the following two cases:

    *
  1. You are certain the listed exception can't actually ever happen, or only in vanishingly rare situations. * You don't try to catch OutOfMemoryError on every statement either. Examples:
    - * IOException in ByteArrayOutputStream
    - * UnsupportedEncodingException in new String(byteArray, "UTF-8").
    2. + * {@code IOException} in {@code ByteArrayOutputStream}
    + * {@code UnsupportedEncodingException} in new String(byteArray, "UTF-8"). *
  2. You know for certain the caller can handle the exception (for example, because the caller is * an app manager that will handle all throwables that fall out of your method the same way), but due * to interface restrictions you can't just add these exceptions to your 'throws' clause. @@ -58,8 +58,8 @@ import java.lang.annotation.Target; * } * * - * @SneakyThrows without a parameter defaults to allowing every checked exception. - * (The default is Throwable.class). + * {@code @SneakyThrows} without a parameter defaults to allowing every checked exception. + * (The default is {@code Throwable.class}). * * @see Lombok#sneakyThrow(Throwable) */ diff --git a/src/lombok/Synchronized.java b/src/lombok/Synchronized.java index 91b3827c..72c44c71 100644 --- a/src/lombok/Synchronized.java +++ b/src/lombok/Synchronized.java @@ -31,8 +31,8 @@ import java.lang.annotation.Target; * Object, so that other code not under your control doesn't meddle with your thread management by locking on * your own instance. *

    - * For non-static methods, a field named $lock is used, and for static methods, - * $LOCK is used. These will be generated if needed and if they aren't already present. The contents + * For non-static methods, a field named {@code $lock} is used, and for static methods, + * {@code $LOCK} is used. These will be generated if needed and if they aren't already present. The contents * of the fields will be serializable. */ @Target(ElementType.METHOD) diff --git a/src/lombok/ToString.java b/src/lombok/ToString.java index 46d9dabe..7b89d481 100644 --- a/src/lombok/ToString.java +++ b/src/lombok/ToString.java @@ -27,28 +27,28 @@ import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** - * Generates an implementation for the toString method inherited by all objects. + * Generates an implementation for the {@code toString} method inherited by all objects. *

    - * If the method already exists, then @ToString will not generate any method, and instead warns + * If the method already exists, then {@code ToString} will not generate any method, and instead warns * that it's doing nothing at all. The parameter list and return type are not relevant when deciding to skip generation of - * the method; any method named toString will make @ToString not generate anything. + * the method; any method named {@code toString} will make {@code ToString} not generate anything. *

    * By default, all fields that are non-static are used in the toString generation. You can exclude fields by specifying them - * in the exclude parameter. You can also explicitly specify the fields that - * are to be used by specifying them in the of parameter. + * in the {@code exclude} parameter. You can also explicitly specify the fields that + * are to be used by specifying them in the {@code of} parameter. *

    * Array fields are handled by way of {@link java.util.Arrays#deepToString(Object[])} where necessary. * The downside is that arrays with circular references (arrays that contain themselves, - * possibly indirectly) results in calls to toString throwing a + * possibly indirectly) results in calls to {@code toString} throwing a * {@link java.lang.StackOverflowError}. However, the implementations for java's own {@link java.util.ArrayList} suffer * from the same flaw. *

    - * The toString method that is generated will print the class name as well as each field (both the name + * The {@code toString} method that is generated will print the class name as well as each field (both the name * and the value). You can optionally choose to suppress the printing of the field name, by setting the - * includeFieldNames flag to false. + * {@code includeFieldNames} flag to false. *

    - * You can also choose to include the result of toString in your class's superclass by setting the - * callSuper to true. + * You can also choose to include the result of {@code toString} in your class's superclass by setting the + * {@code callSuper} to true. */ @Target(ElementType.TYPE) @Retention(RetentionPolicy.SOURCE) @@ -60,7 +60,7 @@ public @interface ToString { boolean includeFieldNames() default true; /** - * Any fields listed here will not be printed in the generated toString implementation. + * Any fields listed here will not be printed in the generated {@code toString} implementation. * Mutually exclusive with {@link #of()}. */ String[] exclude() default {}; @@ -74,7 +74,7 @@ public @interface ToString { String[] of() default {}; /** - * Include the result of the superclass's implementation of toString in the output. + * Include the result of the superclass's implementation of {@code toString} in the output. * default: false */ boolean callSuper() default false; diff --git a/src/lombok/core/SpiLoadUtil.java b/src/lombok/core/SpiLoadUtil.java index 6245cf5b..3031576a 100644 --- a/src/lombok/core/SpiLoadUtil.java +++ b/src/lombok/core/SpiLoadUtil.java @@ -41,7 +41,7 @@ import lombok.Lombok; * The java core libraries have a SPI discovery system, but it works only in Java 1.6 and up. For at least Eclipse, * lombok actually works in java 1.5, so we've rolled our own SPI discovery system. * - * It is not API compatible with ServiceLoader. + * It is not API compatible with {@code ServiceLoader}. * * @see java.util.ServiceLoader */ @@ -57,7 +57,7 @@ public class SpiLoadUtil { * Like ServiceLoader, each listed class is turned into an instance by calling the public no-args constructor. * * Convenience method that calls the more elaborate {@link #findServices(Class, ClassLoader)} method with - * this {@link java.lang.Thread}'s context class loader as ClassLoader. + * this {@link java.lang.Thread}'s context class loader as {@code ClassLoader}. * * @param target class to find implementations for. */ @@ -129,7 +129,7 @@ public class SpiLoadUtil { } /** - * This method will find the T in public class Foo extends BaseType<T>. + * This method will find the @{code T} in {@code public class Foo extends BaseType}. * * It returns an annotation type because it is used exclusively to figure out which annotations are * being handled by {@link lombok.eclipse.EclipseAnnotationHandler} and {@link lombok.javac.JavacAnnotationHandler}. diff --git a/src/lombok/core/TransformationsUtil.java b/src/lombok/core/TransformationsUtil.java index 050dc370..6b457927 100644 --- a/src/lombok/core/TransformationsUtil.java +++ b/src/lombok/core/TransformationsUtil.java @@ -47,7 +47,7 @@ public class TransformationsUtil { * * Strategy: * - * First, pick a prefix. 'get' normally, but 'is' if isBoolean is true. + * First, pick a prefix. 'get' normally, but 'is' if {@code isBoolean} is true. * * Then, check if the first character of the field is lowercase. If so, check if the second character * exists and is title or upper case. If so, uppercase the first character. If not, titlecase the first character. @@ -59,7 +59,7 @@ public class TransformationsUtil { * any prefix. * * @param fieldName the name of the field. - * @param isBoolean if the field is of type 'boolean'. For fields of type 'java.lang.Boolean', you should provide false. + * @param isBoolean if the field is of type 'boolean'. For fields of type 'java.lang.Boolean', you should provide {@code false}. */ public static String toGetterName(CharSequence fieldName, boolean isBoolean) { final String prefix = isBoolean ? "is" : "get"; diff --git a/src/lombok/eclipse/EclipseAnnotationHandler.java b/src/lombok/eclipse/EclipseAnnotationHandler.java index 96626cca..aaa57603 100644 --- a/src/lombok/eclipse/EclipseAnnotationHandler.java +++ b/src/lombok/eclipse/EclipseAnnotationHandler.java @@ -28,11 +28,11 @@ import lombok.core.AnnotationValues; * * You MUST replace 'T' with a specific annotation type, such as: * - * public class HandleGetter implements EclipseAnnotationHandler<Getter> + * {@code public class HandleGetter implements EclipseAnnotationHandler} * * Because this generics parameter is inspected to figure out which class you're interested in. * - * You also need to register yourself via SPI discovery as being an implementation of EclipseAnnotationHandler. + * You also need to register yourself via SPI discovery as being an implementation of {@code EclipseAnnotationHandler}. */ public interface EclipseAnnotationHandler { /** @@ -47,8 +47,8 @@ public interface EclipseAnnotationHandlertrue if you don't want to be called again about this annotation during this - * compile session (you've handled it), or false to indicate you aren't done yet. + * @return {@code true} if you don't want to be called again about this annotation during this + * compile session (you've handled it), or {@code false} to indicate you aren't done yet. */ boolean handle(AnnotationValues annotation, org.eclipse.jdt.internal.compiler.ast.Annotation ast, EclipseNode annotationNode); } diff --git a/src/lombok/eclipse/HandlerLibrary.java b/src/lombok/eclipse/HandlerLibrary.java index be0e0b14..36c41504 100644 --- a/src/lombok/eclipse/HandlerLibrary.java +++ b/src/lombok/eclipse/HandlerLibrary.java @@ -131,11 +131,11 @@ public class HandlerLibrary { * instance of {@link AnnotationValues}. * * Note that depending on the printASTOnly flag, the {@link lombok.core.PrintAST} annotation - * will either be silently skipped, or everything that isn't PrintAST will be skipped. + * will either be silently skipped, or everything that isn't {@code PrintAST} will be skipped. * * The HandlerLibrary will attempt to guess if the given annotation node represents a lombok annotation. - * For example, if lombok.* is in the import list, then this method will guess that - * Getter refers to lombok.Getter, presuming that {@link lombok.eclipse.handlers.HandleGetter} + * For example, if {@code lombok.*} is in the import list, then this method will guess that + * {@code Getter} refers to {@code lombok.Getter}, presuming that {@link lombok.eclipse.handlers.HandleGetter} * has been loaded. * * @param ast The Compilation Unit that contains the Annotation AST Node. @@ -184,7 +184,7 @@ public class HandlerLibrary { /** * Lombok does not currently support triggering annotations in a specified order; the order is essentially - * random right now. This lack of order is particularly annoying for the PrintAST annotation, + * random right now. This lack of order is particularly annoying for the {@code PrintAST} annotation, * which is almost always intended to run last. Hence, this hack, which lets it in fact run last. * * @see #skipAllButPrintAST() diff --git a/src/lombok/eclipse/TransformEclipseAST.java b/src/lombok/eclipse/TransformEclipseAST.java index 6c0567c5..3b5482ca 100644 --- a/src/lombok/eclipse/TransformEclipseAST.java +++ b/src/lombok/eclipse/TransformEclipseAST.java @@ -42,7 +42,7 @@ import org.eclipse.jdt.internal.compiler.parser.Parser; * Note that, for any Method body, if Bit24 is set, the Eclipse parser has been patched to never attempt to * (re)parse it. You should set Bit24 on any MethodDeclaration object you inject into the AST: * - * methodDeclaration.bits |= ASTNode.Bit24; //0x800000 + * {@code methodDeclaration.bits |= ASTNode.Bit24; //0x800000} * * @author rzwitserloot * @author rspilker diff --git a/src/lombok/eclipse/handlers/HandleCleanup.java b/src/lombok/eclipse/handlers/HandleCleanup.java index 9cb23067..d296e96b 100644 --- a/src/lombok/eclipse/handlers/HandleCleanup.java +++ b/src/lombok/eclipse/handlers/HandleCleanup.java @@ -47,7 +47,7 @@ import org.eclipse.jdt.internal.compiler.ast.TryStatement; import org.mangosdk.spi.ProviderFor; /** - * Handles the lombok.Cleanup annotation for eclipse. + * Handles the {@code lombok.Cleanup} annotation for eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) public class HandleCleanup implements EclipseAnnotationHandler { diff --git a/src/lombok/eclipse/handlers/HandleData.java b/src/lombok/eclipse/handlers/HandleData.java index d760e1c6..555b311f 100644 --- a/src/lombok/eclipse/handlers/HandleData.java +++ b/src/lombok/eclipse/handlers/HandleData.java @@ -64,7 +64,7 @@ import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants; import org.mangosdk.spi.ProviderFor; /** - * Handles the lombok.Data annotation for eclipse. + * Handles the {@code lombok.Data} annotation for eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) public class HandleData implements EclipseAnnotationHandler { diff --git a/src/lombok/eclipse/handlers/HandleEqualsAndHashCode.java b/src/lombok/eclipse/handlers/HandleEqualsAndHashCode.java index 847ea7d1..c5945e6c 100644 --- a/src/lombok/eclipse/handlers/HandleEqualsAndHashCode.java +++ b/src/lombok/eclipse/handlers/HandleEqualsAndHashCode.java @@ -84,7 +84,7 @@ import lombok.eclipse.EclipseAnnotationHandler; import lombok.eclipse.EclipseNode; /** - * Handles the EqualsAndHashCode annotation for eclipse. + * Handles the {@code EqualsAndHashCode} annotation for eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) public class HandleEqualsAndHashCode implements EclipseAnnotationHandler { diff --git a/src/lombok/eclipse/handlers/HandleGetter.java b/src/lombok/eclipse/handlers/HandleGetter.java index ad9f59f7..86ab4c88 100644 --- a/src/lombok/eclipse/handlers/HandleGetter.java +++ b/src/lombok/eclipse/handlers/HandleGetter.java @@ -46,7 +46,7 @@ import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants; import org.mangosdk.spi.ProviderFor; /** - * Handles the lombok.Getter annotation for eclipse. + * Handles the {@code lombok.Getter} annotation for eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) public class HandleGetter implements EclipseAnnotationHandler { @@ -57,7 +57,7 @@ public class HandleGetter implements EclipseAnnotationHandler { * * The difference between this call and the handle method is as follows: * - * If there is a lombok.Getter annotation on the field, it is used and the + * If there is a {@code lombok.Getter} annotation on the field, it is used and the * same rules apply (e.g. warning if the method already exists, stated access level applies). * If not, the getter is still generated if it isn't already there, though there will not * be a warning if its already there. The default access level is used. diff --git a/src/lombok/eclipse/handlers/HandlePrintAST.java b/src/lombok/eclipse/handlers/HandlePrintAST.java index 3e1df93d..580a54a2 100644 --- a/src/lombok/eclipse/handlers/HandlePrintAST.java +++ b/src/lombok/eclipse/handlers/HandlePrintAST.java @@ -36,7 +36,7 @@ import lombok.eclipse.EclipseAnnotationHandler; import lombok.eclipse.EclipseNode; /** - * Handles the lombok.core.PrintAST annotation for eclipse. + * Handles the {@code lombok.core.PrintAST} annotation for eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) public class HandlePrintAST implements EclipseAnnotationHandler { diff --git a/src/lombok/eclipse/handlers/HandleSetter.java b/src/lombok/eclipse/handlers/HandleSetter.java index 0ef3c44b..2f342992 100644 --- a/src/lombok/eclipse/handlers/HandleSetter.java +++ b/src/lombok/eclipse/handlers/HandleSetter.java @@ -53,7 +53,7 @@ import org.eclipse.jdt.internal.compiler.lookup.TypeIds; import org.mangosdk.spi.ProviderFor; /** - * Handles the lombok.Setter annotation for eclipse. + * Handles the {@code lombok.Setter} annotation for eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) public class HandleSetter implements EclipseAnnotationHandler { @@ -64,7 +64,7 @@ public class HandleSetter implements EclipseAnnotationHandler { * * The difference between this call and the handle method is as follows: * - * If there is a lombok.Setter annotation on the field, it is used and the + * If there is a {@code lombok.Setter} annotation on the field, it is used and the * same rules apply (e.g. warning if the method already exists, stated access level applies). * If not, the setter is still generated if it isn't already there, though there will not * be a warning if its already there. The default access level is used. diff --git a/src/lombok/eclipse/handlers/HandleSneakyThrows.java b/src/lombok/eclipse/handlers/HandleSneakyThrows.java index 5cb5dca7..38f22b2a 100644 --- a/src/lombok/eclipse/handlers/HandleSneakyThrows.java +++ b/src/lombok/eclipse/handlers/HandleSneakyThrows.java @@ -51,7 +51,7 @@ import org.eclipse.jdt.internal.compiler.ast.TypeReference; import org.mangosdk.spi.ProviderFor; /** - * Handles the lombok.HandleSneakyThrows annotation for eclipse. + * Handles the {@code lombok.HandleSneakyThrows} annotation for eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) public class HandleSneakyThrows implements EclipseAnnotationHandler { diff --git a/src/lombok/eclipse/handlers/HandleSynchronized.java b/src/lombok/eclipse/handlers/HandleSynchronized.java index 5f1d0864..0666ace7 100644 --- a/src/lombok/eclipse/handlers/HandleSynchronized.java +++ b/src/lombok/eclipse/handlers/HandleSynchronized.java @@ -50,7 +50,7 @@ import org.eclipse.jdt.internal.compiler.lookup.TypeConstants; import org.mangosdk.spi.ProviderFor; /** - * Handles the lombok.Synchronized annotation for eclipse. + * Handles the {@code lombok.Synchronized} annotation for eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) public class HandleSynchronized implements EclipseAnnotationHandler { diff --git a/src/lombok/eclipse/handlers/HandleToString.java b/src/lombok/eclipse/handlers/HandleToString.java index 263a588c..b8bbb064 100644 --- a/src/lombok/eclipse/handlers/HandleToString.java +++ b/src/lombok/eclipse/handlers/HandleToString.java @@ -64,7 +64,7 @@ import org.eclipse.jdt.internal.compiler.lookup.TypeConstants; import org.mangosdk.spi.ProviderFor; /** - * Handles the ToString annotation for eclipse. + * Handles the {@code ToString} annotation for eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) public class HandleToString implements EclipseAnnotationHandler { diff --git a/src/lombok/javac/HandlerLibrary.java b/src/lombok/javac/HandlerLibrary.java index 3d44db7f..bbe9dec0 100644 --- a/src/lombok/javac/HandlerLibrary.java +++ b/src/lombok/javac/HandlerLibrary.java @@ -155,11 +155,11 @@ public class HandlerLibrary { * instance of {@link lombok.core.AnnotationValues}. * * Note that depending on the printASTOnly flag, the {@link lombok.core.PrintAST} annotation - * will either be silently skipped, or everything that isn't PrintAST will be skipped. + * will either be silently skipped, or everything that isn't {@code PrintAST} will be skipped. * * The HandlerLibrary will attempt to guess if the given annotation node represents a lombok annotation. - * For example, if lombok.* is in the import list, then this method will guess that - * Getter refers to lombok.Getter, presuming that {@link lombok.javac.handlers.HandleGetter} + * For example, if {@code lombok.*} is in the import list, then this method will guess that + * {@code Getter} refers to {@code lombok.Getter}, presuming that {@link lombok.javac.handlers.HandleGetter} * has been loaded. * * @param unit The Compilation Unit that contains the Annotation AST Node. @@ -203,7 +203,7 @@ public class HandlerLibrary { /** * Lombok does not currently support triggering annotations in a specified order; the order is essentially - * random right now. This lack of order is particularly annoying for the PrintAST annotation, + * random right now. This lack of order is particularly annoying for the {@code PrintAST} annotation, * which is almost always intended to run last. Hence, this hack, which lets it in fact run last. * * @see #skipAllButPrintAST() diff --git a/src/lombok/javac/Javac.java b/src/lombok/javac/Javac.java index 99a7c928..58a24207 100644 --- a/src/lombok/javac/Javac.java +++ b/src/lombok/javac/Javac.java @@ -56,7 +56,7 @@ public class Javac { /** * Checks if the Annotation AST Node provided is likely to be an instance of the provided annotation type. * - * @param type An actual annotation type, such as lombok.Getter.class. + * @param type An actual annotation type, such as {@code lombok.Getter.class}. * @param node A Lombok AST node representing an annotation in source code. */ public static boolean annotationTypeMatches(Class type, JavacNode node) { @@ -76,9 +76,9 @@ public class Javac { } /** - * Creates an instance of AnnotationValues for the provided AST Node. + * Creates an instance of {@code AnnotationValues} for the provided AST Node. * - * @param type An annotation class type, such as lombok.Getter.class. + * @param type An annotation class type, such as {@code lombok.Getter.class}. * @param node A Lombok AST node representing an annotation in source code. */ public static AnnotationValues createAnnotation(Class type, final JavacNode node) { diff --git a/src/lombok/javac/JavacAST.java b/src/lombok/javac/JavacAST.java index 2ee3d5be..eea1bad9 100644 --- a/src/lombok/javac/JavacAST.java +++ b/src/lombok/javac/JavacAST.java @@ -66,7 +66,7 @@ public class JavacAST extends AST { * Creates a new JavacAST of the provided Compilation Unit. * * @param trees The trees instance to use to inspect the compilation unit. Generate via: - * Trees.getInstance(env) + * {@code Trees.getInstance(env)} * @param env The ProcessingEnvironment object passed e.g. to an annotation processor. * @param top The compilation unit, which serves as the top level node in the tree to be built. */ diff --git a/src/lombok/javac/JavacAnnotationHandler.java b/src/lombok/javac/JavacAnnotationHandler.java index 84302a74..5b6fe4ce 100644 --- a/src/lombok/javac/JavacAnnotationHandler.java +++ b/src/lombok/javac/JavacAnnotationHandler.java @@ -32,11 +32,11 @@ import com.sun.tools.javac.tree.JCTree.JCAnnotation; * * You MUST replace 'T' with a specific annotation type, such as: * - * public class HandleGetter implements JavacAnnotationHandler<Getter> + * {@code public class HandleGetter implements JavacAnnotationHandler} * * Because this generics parameter is inspected to figure out which class you're interested in. * - * You also need to register yourself via SPI discovery as being an implementation of JavacAnnotationHandler. + * You also need to register yourself via SPI discovery as being an implementation of {@code JavacAnnotationHandler}. */ public interface JavacAnnotationHandler { /** @@ -51,8 +51,8 @@ public interface JavacAnnotationHandler { * @param annotationNode The Lombok AST wrapper around the 'ast' parameter. You can use this object * to travel back up the chain (something javac AST can't do) to the parent of the annotation, as well * as access useful methods such as generating warnings or errors focused on the annotation. - * @return true if you don't want to be called again about this annotation during this - * compile session (you've handled it), or false to indicate you aren't done yet. + * @return {@code true} if you don't want to be called again about this annotation during this + * compile session (you've handled it), or {@code false} to indicate you aren't done yet. */ boolean handle(AnnotationValues annotation, JCAnnotation ast, JavacNode annotationNode); } diff --git a/src/lombok/javac/handlers/HandleCleanup.java b/src/lombok/javac/handlers/HandleCleanup.java index acee24b1..88a8e1d7 100644 --- a/src/lombok/javac/handlers/HandleCleanup.java +++ b/src/lombok/javac/handlers/HandleCleanup.java @@ -48,7 +48,7 @@ import com.sun.tools.javac.util.List; import com.sun.tools.javac.util.Name; /** - * Handles the lombok.Cleanup annotation for javac. + * Handles the {@code lombok.Cleanup} annotation for javac. */ @ProviderFor(JavacAnnotationHandler.class) public class HandleCleanup implements JavacAnnotationHandler { diff --git a/src/lombok/javac/handlers/HandleData.java b/src/lombok/javac/handlers/HandleData.java index f18af241..8aa744c7 100644 --- a/src/lombok/javac/handlers/HandleData.java +++ b/src/lombok/javac/handlers/HandleData.java @@ -54,7 +54,7 @@ import com.sun.tools.javac.tree.JCTree.JCVariableDecl; import com.sun.tools.javac.util.List; /** - * Handles the lombok.Data annotation for javac. + * Handles the {@code lombok.Data} annotation for javac. */ @ProviderFor(JavacAnnotationHandler.class) public class HandleData implements JavacAnnotationHandler { diff --git a/src/lombok/javac/handlers/HandleEqualsAndHashCode.java b/src/lombok/javac/handlers/HandleEqualsAndHashCode.java index fa1f4d0d..12eed02b 100644 --- a/src/lombok/javac/handlers/HandleEqualsAndHashCode.java +++ b/src/lombok/javac/handlers/HandleEqualsAndHashCode.java @@ -54,7 +54,7 @@ import com.sun.tools.javac.util.List; import com.sun.tools.javac.util.Name; /** - * Handles the lombok.EqualsAndHashCode annotation for javac. + * Handles the {@code lombok.EqualsAndHashCode} annotation for javac. */ @ProviderFor(JavacAnnotationHandler.class) public class HandleEqualsAndHashCode implements JavacAnnotationHandler { diff --git a/src/lombok/javac/handlers/HandleGetter.java b/src/lombok/javac/handlers/HandleGetter.java index fd39bda2..49f732d8 100644 --- a/src/lombok/javac/handlers/HandleGetter.java +++ b/src/lombok/javac/handlers/HandleGetter.java @@ -47,7 +47,7 @@ import com.sun.tools.javac.util.Name; import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition; /** - * Handles the lombok.Getter annotation for javac. + * Handles the {@code lombok.Getter} annotation for javac. */ @ProviderFor(JavacAnnotationHandler.class) public class HandleGetter implements JavacAnnotationHandler { @@ -58,7 +58,7 @@ public class HandleGetter implements JavacAnnotationHandler { * * The difference between this call and the handle method is as follows: * - * If there is a lombok.Getter annotation on the field, it is used and the + * If there is a {@code lombok.Getter} annotation on the field, it is used and the * same rules apply (e.g. warning if the method already exists, stated access level applies). * If not, the getter is still generated if it isn't already there, though there will not * be a warning if its already there. The default access level is used. diff --git a/src/lombok/javac/handlers/HandlePrintAST.java b/src/lombok/javac/handlers/HandlePrintAST.java index 77ecd54f..4c25694b 100644 --- a/src/lombok/javac/handlers/HandlePrintAST.java +++ b/src/lombok/javac/handlers/HandlePrintAST.java @@ -37,7 +37,7 @@ import lombok.javac.JavacAnnotationHandler; import lombok.javac.JavacNode; /** - * Handles the lombok.core.PrintAST annotation for javac. + * Handles the {@code lombok.core.PrintAST} annotation for javac. */ @ProviderFor(JavacAnnotationHandler.class) public class HandlePrintAST implements JavacAnnotationHandler { diff --git a/src/lombok/javac/handlers/HandleSetter.java b/src/lombok/javac/handlers/HandleSetter.java index f7360988..08387895 100644 --- a/src/lombok/javac/handlers/HandleSetter.java +++ b/src/lombok/javac/handlers/HandleSetter.java @@ -49,7 +49,7 @@ import com.sun.tools.javac.util.Name; import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition; /** - * Handles the lombok.Setter annotation for javac. + * Handles the {@code lombok.Setter} annotation for javac. */ @ProviderFor(JavacAnnotationHandler.class) public class HandleSetter implements JavacAnnotationHandler { @@ -60,7 +60,7 @@ public class HandleSetter implements JavacAnnotationHandler { * * The difference between this call and the handle method is as follows: * - * If there is a lombok.Setter annotation on the field, it is used and the + * If there is a {@code lombok.Setter} annotation on the field, it is used and the * same rules apply (e.g. warning if the method already exists, stated access level applies). * If not, the setter is still generated if it isn't already there, though there will not * be a warning if its already there. The default access level is used. diff --git a/src/lombok/javac/handlers/HandleSneakyThrows.java b/src/lombok/javac/handlers/HandleSneakyThrows.java index 3cbad7f6..a9cfc7a2 100644 --- a/src/lombok/javac/handlers/HandleSneakyThrows.java +++ b/src/lombok/javac/handlers/HandleSneakyThrows.java @@ -46,7 +46,7 @@ import com.sun.tools.javac.tree.JCTree.JCVariableDecl; import com.sun.tools.javac.util.List; /** - * Handles the lombok.SneakyThrows annotation for javac. + * Handles the {@code lombok.SneakyThrows} annotation for javac. */ @ProviderFor(JavacAnnotationHandler.class) public class HandleSneakyThrows implements JavacAnnotationHandler { diff --git a/src/lombok/javac/handlers/HandleSynchronized.java b/src/lombok/javac/handlers/HandleSynchronized.java index 559c116a..4573deda 100644 --- a/src/lombok/javac/handlers/HandleSynchronized.java +++ b/src/lombok/javac/handlers/HandleSynchronized.java @@ -43,7 +43,7 @@ import lombok.javac.JavacAnnotationHandler; import lombok.javac.JavacNode; /** - * Handles the lombok.Synchronized annotation for javac. + * Handles the {@code lombok.Synchronized} annotation for javac. */ @ProviderFor(JavacAnnotationHandler.class) public class HandleSynchronized implements JavacAnnotationHandler { diff --git a/src/lombok/javac/handlers/HandleToString.java b/src/lombok/javac/handlers/HandleToString.java index 4c9b9c89..d1c98525 100644 --- a/src/lombok/javac/handlers/HandleToString.java +++ b/src/lombok/javac/handlers/HandleToString.java @@ -50,7 +50,7 @@ import com.sun.tools.javac.tree.JCTree.JCVariableDecl; import com.sun.tools.javac.util.List; /** - * Handles the ToString annotation for javac. + * Handles the {@code ToString} annotation for javac. */ @ProviderFor(JavacAnnotationHandler.class) public class HandleToString implements JavacAnnotationHandler { diff --git a/src/lombok/javac/handlers/PKG.java b/src/lombok/javac/handlers/PKG.java index e2fceb08..d6fd1c61 100644 --- a/src/lombok/javac/handlers/PKG.java +++ b/src/lombok/javac/handlers/PKG.java @@ -169,7 +169,7 @@ class PKG { } /** - * Turns an AccessLevel instance into the flag bit used by javac. + * Turns an {@code AccessLevel} instance into the flag bit used by javac. * * @see java.lang.Modifier */ @@ -241,9 +241,9 @@ class PKG { } /** - * In javac, dotted access of any kind, from java.lang.String to var.methodName - * is represented by a fold-left of Select nodes with the leftmost string represented by - * a Ident node. This method generates such an expression. + * In javac, dotted access of any kind, from {@code java.lang.String} to {@code var.methodName} + * is represented by a fold-left of {@code Select} nodes with the leftmost string represented by + * a {@code Ident} node. This method generates such an expression. * * For example, maker.Select(maker.Select(maker.Ident(NAME[java]), NAME[lang]), NAME[String]). * -- cgit