azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Store third-party annotations in a separate directory

Browse Source
This commit is contained in:
Dmitry Jemerov
2017-09-08 17:26:12 +02:00
parent 296638a7c4
commit cc8fbf6078
41 changed files with 11 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/foreignAnnotationsJava8/annotations/javax/annotation/CheckForNull.java
Vendored
-16
View File
@@ -1,16 +0,0 @@
package javax.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import javax.annotation.meta.TypeQualifierNickname;
import javax.annotation.meta.When;
@Documented
@TypeQualifierNickname
@Nonnull(when = When.MAYBE)
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckForNull {
}
compiler/testData/foreignAnnotationsJava8/annotations/javax/annotation/Nonnull.java
Vendored
-26
View File
@@ -1,26 +0,0 @@
package javax.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import javax.annotation.meta.TypeQualifier;
import javax.annotation.meta.TypeQualifierValidator;
import javax.annotation.meta.When;
@Documented
@TypeQualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface Nonnull {
When when() default When.ALWAYS;
static class Checker implements TypeQualifierValidator<Nonnull> {
public When forConstantValue(Nonnull qualifierqualifierArgument,
Object value) {
if (value == null)
return When.NEVER;
return When.ALWAYS;
}
}
}
compiler/testData/foreignAnnotationsJava8/annotations/javax/annotation/Nullable.java
Vendored
-16
View File
@@ -1,16 +0,0 @@
package javax.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import javax.annotation.meta.TypeQualifierNickname;
import javax.annotation.meta.When;
@Documented
@TypeQualifierNickname
@Nonnull(when = When.UNKNOWN)
@Retention(RetentionPolicy.RUNTIME)
public @interface Nullable {
}
compiler/testData/foreignAnnotationsJava8/annotations/javax/annotation/ParametersAreNonnullByDefault.java
Vendored
-28
View File
@@ -1,28 +0,0 @@
package javax.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import javax.annotation.meta.TypeQualifierDefault;
/**
* This annotation can be applied to a package, class or method to indicate that
* the method parameters in that element are nonnull by default unless there is:
* <ul>
* <li>An explicit nullness annotation
* <li>The method overrides a method in a superclass (in which case the
* annotation of the corresponding parameter in the superclass applies)
* <li>There is a default parameter annotation (like {@link ParametersAreNullableByDefault})
* applied to a more tightly nested element.
* </ul>
*
* @see Nonnull
*/
@Documented
@Nonnull
@TypeQualifierDefault(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface ParametersAreNonnullByDefault {
}
compiler/testData/foreignAnnotationsJava8/annotations/javax/annotation/meta/TypeQualifier.java
Vendored
-27
View File
@@ -1,27 +0,0 @@
package javax.annotation.meta;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* This qualifier is applied to an annotation to denote that the annotation
* should be treated as a type qualifier.
*/
@Documented
@Target(ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TypeQualifier {
/**
* Describes the kinds of values the qualifier can be applied to. If a
* numeric class is provided (e.g., Number.class or Integer.class) then the
* annotation can also be applied to the corresponding primitive numeric
* types.
*/
Class<?> applicableTo() default Object.class;
}
compiler/testData/foreignAnnotationsJava8/annotations/javax/annotation/meta/TypeQualifierDefault.java
Vendored
-20
View File
@@ -1,20 +0,0 @@
package javax.annotation.meta;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* This qualifier is applied to an annotation to denote that the annotation
* defines a default type qualifier that is visible within the scope of the
* element it is applied to.
*/
@Documented
@Target(ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TypeQualifierDefault {
ElementType[] value() default {};
}
compiler/testData/foreignAnnotationsJava8/annotations/javax/annotation/meta/TypeQualifierNickname.java
Vendored
-33
View File
@@ -1,33 +0,0 @@
package javax.annotation.meta;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
/**
*
* This annotation is applied to a annotation, and marks the annotation as being
* a qualifier nickname. Applying a nickname annotation X to a element Y should
* be interpreted as having the same meaning as applying all of annotations of X
* (other than QualifierNickname) to Y.
*
* <p>
* Thus, you might define a qualifier SocialSecurityNumber as follows:
* </p>
*
*
* <code>
@Documented
@TypeQualifierNickname @Pattern("[0-9]{3}-[0-9]{2}-[0-9]{4}")
@Retention(RetentionPolicy.RUNTIME)
public @interface SocialSecurityNumber {
}
</code>
*
*
*/
@Documented
@Target(ElementType.ANNOTATION_TYPE)
public @interface TypeQualifierNickname {
}
compiler/testData/foreignAnnotationsJava8/annotations/javax/annotation/meta/TypeQualifierValidator.java
Vendored
-21
View File
@@ -1,21 +0,0 @@
package javax.annotation.meta;
import java.lang.annotation.Annotation;
import javax.annotation.Nonnull;
public interface TypeQualifierValidator<A extends Annotation> {
/**
* Given a type qualifier, check to see if a known specific constant value
* is an instance of the set of values denoted by the qualifier.
*
* @param annotation
* the type qualifier
* @param value
* the value to check
* @return a value indicating whether or not the value is an member of the
* values denoted by the type qualifier
*/
public @Nonnull
When forConstantValue(@Nonnull A annotation, Object value);
}
compiler/testData/foreignAnnotationsJava8/annotations/javax/annotation/meta/When.java
Vendored
-23
View File
@@ -1,23 +0,0 @@
package javax.annotation.meta;
/**
* Used to describe the relationship between a qualifier T and the set of values
* S possible on an annotated element.
*
* In particular, an issues should be reported if an ALWAYS or MAYBE value is
* used where a NEVER value is required, or if a NEVER or MAYBE value is used
* where an ALWAYS value is required.
*
*
*/
public enum When {
/** S is a subset of T */
ALWAYS,
/** nothing definitive is known about the relation between S and T */
UNKNOWN,
/** S intersection T is non empty and S - T is nonempty */
MAYBE,
/** S intersection T is empty */
NEVER;
}
compiler/testData/foreignAnnotationsJava8/annotations/org/checkerframework/checker/nullness/qual/NonNull.java
Vendored
-40
View File
@@ -1,40 +0,0 @@
package org.checkerframework.checker.nullness.qual;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* {@link NonNull} is a type annotation that indicates that an expression is
* never {@code null}.
*
* <p>
* For fields of a class, the {@link NonNull} annotation indicates that this
* field is never {@code null}
* <em>after the class has been fully initialized</em>. Class initialization is
* controlled by the Freedom Before Commitment type system, see
* {@link InitializationChecker} for more details.
*
* <p>
* For static fields, the {@link NonNull} annotation indicates that this field
* is never {@code null} <em>after the containing class is initialized</em>.
*
* <p>
* This annotation is rarely written in source code, because it is the default.
*
* <p>
* This annotation is associated with the {@link AbstractNullnessChecker}.
*
* @see Nullable
* @see MonotonicNonNull
* @see AbstractNullnessChecker
* @checker_framework.manual #nullness-checker Nullness Checker
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE_USE, ElementType.TYPE_PARAMETER })
public @interface NonNull {
}
compiler/testData/foreignAnnotationsJava8/annotations/org/checkerframework/checker/nullness/qual/Nullable.java
Vendored
-27
View File
@@ -1,27 +0,0 @@
package org.checkerframework.checker.nullness.qual;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* {@link Nullable} is a type annotation that indicates that the value is not
* known to be non-null (see {@link NonNull}). Only if an expression has a
* {@link Nullable} type may it be assigned {@code null}.
*
* <p>
* This annotation is associated with the {@link AbstractNullnessChecker}.
*
* @see NonNull
* @see MonotonicNonNull
* @see AbstractNullnessChecker
* @checker_framework.manual #nullness-checker Nullness Checker
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE_USE, ElementType.TYPE_PARAMETER })
public @interface Nullable {
}
compiler/testData/foreignAnnotationsJava8/annotations/org/eclipse/jdt/annotation/NonNull.java
Vendored
-55
View File
@@ -1,55 +0,0 @@
/*******************************************************************************
* Copyright (c) 2011, 2013 Stephan Herrmann and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Stephan Herrmann - initial API and implementation
* IBM Corporation - bug fixes
*******************************************************************************/
package org.eclipse.jdt.annotation;
import static java.lang.annotation.ElementType.TYPE_USE;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Qualifier for a reference type in a {@link ElementType#TYPE_USE TYPE_USE} position:
* The type that has this annotation is intended to not include the value <code>null</code>.
* <p>
* If annotation based null analysis is enabled using this annotation has two consequences:
* </p>
* <ol>
* <li>Dereferencing an expression of this type is safe, i.e., no <code>NullPointerException</code> can occur at runtime.</li>
* <li>An attempt to bind a <code>null</code> value to an entity (field, local variable, method parameter or method return value)
* of this type is a compile time error.</li>
* </ol>
* For the second case, diagnostics issued by the compiler should distinguish three situations:
* <ol>
* <li>Nullness of the value can be statically determined, the entity is definitely bound from either of:
* <ul><li>the value <code>null</code>, or</li>
* <li>an entity with a {@link Nullable @Nullable} type.</li></ul></li>
* <li>Nullness cannot definitely be determined, because different code branches yield different results.</li>
* <li>Nullness cannot be determined, because other program elements are involved for which
* null annotations are lacking.</li>
* </ol>
* <p>
* <b>Note:</b> Since org.eclipse.jdt.annotation 2.0.0, the
* <code>@Target</code> is <code>{TYPE_USE}</code>. For the old API, see
* <a href="http://help.eclipse.org/kepler/topic/org.eclipse.jdt.doc.isv/reference/api/org/eclipse/jdt/annotation/NonNull.html">
* <code>@NonNull</code> in 1.1.0</a>.
* </p>
* @since 1.0
*/
@Documented
@Retention(RetentionPolicy.CLASS)
@Target({ TYPE_USE })
public @interface NonNull {
// marker annotation with no members
}
compiler/testData/foreignAnnotationsJava8/annotations/org/eclipse/jdt/annotation/Nullable.java
Vendored
-46
View File
@@ -1,46 +0,0 @@
/*******************************************************************************
* Copyright (c) 2011, 2013 Stephan Herrmann and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Stephan Herrmann - initial API and implementation
* IBM Corporation - bug fixes
*******************************************************************************/
package org.eclipse.jdt.annotation;
import static java.lang.annotation.ElementType.TYPE_USE;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Qualifier for a reference type in a {@link ElementType#TYPE_USE TYPE_USE} position:
* The type that has this annotation explicitly includes the value <code>null</code>.
* <p>
* If annotation based null analysis is enabled using this annotation has two consequences:
* </p>
* <ol>
* <li>Binding a <code>null</code> value to an entity (field, local variable, method parameter or method return value)
* of this type is legal.</li>
* <li>Dereferencing an expression of this type is unsafe, i.e., a <code>NullPointerException</code> can occur at runtime.</li>
* </ol>
* <p>
* <b>Note:</b> Since org.eclipse.jdt.annotation 2.0.0, the
* <code>@Target</code> is <code>{TYPE_USE}</code>. For the old API, see
* <a href="http://help.eclipse.org/kepler/topic/org.eclipse.jdt.doc.isv/reference/api/org/eclipse/jdt/annotation/Nullable.html">
* <code>@Nullable</code> in 1.1.0</a>.
* </p>
* @since 1.0
*/
@Documented
@Retention(RetentionPolicy.CLASS)
@Target({ TYPE_USE })
public @interface Nullable {
// marker annotation with no members
}