.gitignore

+build
+/.idea
+/.gradle
\ No newline at end of file

CODE_OF_CONDUCT.md

+## Code of Conduct
+
+This project and the corresponding community is governed by the [JetBrains Open Source and Community Code of Conduct](https://confluence.jetbrains.com/display/ALL/JetBrains+Open+Source+and+Community+Code+of+Conduct). Please make sure you read it. 
+

CONTRIBUTING.md

@@ -12,6 +12,11 @@ a new annotation highly related to an existing one
 Also update version number in the examples in README.md file.  
 
 ### Backward compatibility
-All the changes should be backward compatible i.e. you can add new annotations and new elements into existing annotation. 
+All the changes should be backward compatible i.e. you can only add new annotations and new elements into existing annotation. 
 If it's absolutely necessary to remove an annotation or its element we must firstly release a new major version where 
 the corresponding element is marked as deprecated and then remove it in one of the next major versions.
+
+### Retention policy
+No annotation in this package should have `RUNTIME` retention policy. Only `SOURCE` and `CLASS` policy is accepted. 
+The `CLASS` policy is preferred. The `SOURCE` policy could be used in rare cases when compilation could not preserve all 
+the necessary information (e.g. `@MagicConstant` annotation).
\ No newline at end of file

README.md

@@ -6,10 +6,10 @@ interpreted by IDEs and static analysis tools to improve code analysis.
 
 ## Using the annotations
 The annotations are published on [Maven Central](http://repo1.maven.org/maven2/org/jetbrains/annotations/) and [JCenter](https://jcenter.bintray.com/org/jetbrains/annotations/). To add a dependency
-using gradle write the following in `build.gradle` file:
+using gradle write the following in the `build.gradle` file:
 ```
 dependencies {
-    compile 'org.jetbrains:annotations:16.0.3'
+    compileOnly 'org.jetbrains:annotations:18.0.0'
 }
 
 ```
@@ -18,12 +18,12 @@ To add a dependency using Maven write the following in `pom.xml`:
 <dependency>
   <groupId>org.jetbrains</groupId>
   <artifactId>annotations</artifactId>
-  <version>16.0.3</version>
+  <version>18.0.0</version>
 </dependency>
 ```
 
-`annotations` artifact require JDK 1.8 or higher. If your project is compiled using JDK 1.5, 1.6 or 1.7 you can use 
-`annotations-java5` artifact instead.
+`annotations` artifact requires JDK 1.8 or higher. If your project is compiled using JDK 1.5, 1.6 or 1.7 you can use 
+the `annotations-java5` artifact instead.
 
 
     

build.gradle

@@ -11,6 +11,7 @@ ext.projectVersion = projectVersion
 if (System.getenv('BINTRAY_USER') == null) {
     ext.projectVersion = ext.projectVersion + '-SNAPSHOT'
 }
+println "##teamcity[setParameter name='java.annotations.version' value='$projectVersion']"
 
 allprojects {
     group 'org.jetbrains'
@@ -86,7 +87,7 @@ configure([project(':java5'), project(':java8')]) {
                         licenses {
                             license {
                                 name 'The Apache Software License, Version 2.0'
-                                url 'http://www.apache.org/license/LICENSE-2.0.txt'
+                                url 'https://www.apache.org/licenses/LICENSE-2.0.txt'
                                 distribution 'repo'
                             }
                         }

common/src/main/java/org/jetbrains/annotations/ApiStatus.java

+// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+package org.jetbrains.annotations;
+
+import java.lang.annotation.*;
+
+/**
+ * Set of annotations which can be used to specify status of API Element.
+ *
+ * @since 18.0.0
+ */
+public final class ApiStatus {
+  /**
+   * <p>Indicates that a public API of the annotated element (class, method or field) is not in stable state yet. It may be renamed, changed or
+   * even removed in a future version. This annotation refers to API status only, it doesn't mean that the implementation has
+   * an 'experimental' quality.</p>
+   *
+   * <p>It's safe to use an element marked with this annotation if the usage is located in the same sources codebase as the declaration. However,
+   * if the declaration belongs to an external library such usages may lead to problems when the library will be updated to another version.</p>
+   *
+   * <p>If a package is marked with this annotation, all its containing classes are considered experimental.
+   * Subpackages of this package are not affected and should be marked independently.</p>
+   *
+   * <p>If a type is marked with this annotation, all its members are considered experimental, but its inheritors are not.</p>
+   *
+   * <p>If a method is marked with this annotation, overriding methods are not considered experimental.</p>
+   */
+  @Documented
+  @Retention(RetentionPolicy.CLASS)
+  @Target({
+    ElementType.TYPE, ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.PACKAGE
+  })
+  public @interface Experimental {}
+
+  /**
+   * Indicates that the annotated element (class, method, field, etc) must not be considered as a public API. It's made visible to allow
+   * usages in other packages of the declaring module, but it must not be used outside of that module. Such elements
+   * may be renamed, changed or removed in future versions.
+   *
+   * <p>If a package is marked with this annotation, all its containing classes are considered internal.
+   * Subpackages of this package are not affected and should be marked independently.</p>
+   *
+   * <p>If a type is marked with this annotation, all its members are considered internal, but its inheritors are not.</p>
+   *
+   * <p>If a method is marked with this annotation, overriding methods are not considered internal.</p>
+   */
+  @Documented
+  @Retention(RetentionPolicy.CLASS)
+  @Target({
+    ElementType.TYPE, ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.PACKAGE
+  })
+  public @interface Internal {}
+
+  /**
+   * <p>Indicates that a public API of the annotated element (class, method or field) is subject to removal in a future version.
+   * It's a stronger variant of {@link Deprecated} annotation.</p>
+   *
+   * <p>Since many tools aren't aware of this annotation it should be used as an addition to {@code @Deprecated} annotation
+   * or {@code @deprecated} Javadoc tag only.</p>
+   */
+  @Documented
+  @Retention(RetentionPolicy.CLASS)
+  @Target({
+    ElementType.TYPE, ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.PACKAGE
+  })
+  public @interface ScheduledForRemoval {
+    /**
+     * Specifies in which version the API will be removed.
+     */
+    String inVersion() default "";
+  }
+
+  /**
+   * <p>Indicates that the annotated element firstly appeared in the specified version of the library, so the code using that element
+   * won't be compatible with older versions of the library. This information may be used by IDEs and static analysis tools.
+   * This annotation can be used instead of '@since' Javadoc tag if it's needed to keep that information in *.class files or if you need
+   * to generate them automatically.</p>
+   */
+  @Documented
+  @Retention(RetentionPolicy.CLASS)
+  @Target({
+    ElementType.TYPE, ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.PACKAGE
+  })
+  public @interface AvailableSince {
+    /**
+     * Specifies a version where the annotation API firstly appeared.
+     */
+    String value();
+  }
+
+  /**
+   * <p>Indicates that the annotated API class, interface or method <strong>must not be extended, implemented or overridden</strong>.</p>
+   *
+   * <p>API class, interface or method may not be marked {@code final} because it is extended by classes of the declaring library
+   * but it is not supposed to be extended outside the library. Instances of classes and interfaces marked with this annotation
+   * may be cast to an internal implementing class in the library code, leading to {@code ClassCastException}
+   * if a different implementation is provided by a client.</p>
+   *
+   * <p>New abstract methods may be added to such classes and interfaces in new versions of the library breaking compatibility
+   * with a client's implementations.</p>
+   */
+  @Documented
+  @Retention(RetentionPolicy.CLASS)
+  @Target({
+    ElementType.TYPE, ElementType.METHOD
+  })
+  public @interface NonExtendable { }
+
+  /**
+   * <p>Indicates that the annotated method is part of SPI (Service Provider Interface), which is intended to be
+   * <strong>only implemented or overridden</strong> but not called by clients of the declaring library.
+   * If a class or interface is marked with this annotation it means that all its methods can be only overridden.</p>
+   *
+   * <p>Although there is a standard mechanism of {@code protected} methods, it is not applicable to interface's methods.
+   * Also, API method may be made {@code public} to allow calls only from different parts of the declaring library but not outside it.</p>
+   *
+   * <p>Signatures of such methods may be changed in new versions of the library in the following steps. Firstly, a method with new signature
+   * is added to the library delegating to the old method by default. Secondly, all clients implement the new method and remove
+   * implementations of the old one. This leads to compatibility breakage with code that calls the methods directly.</p>
+   */
+  @Documented
+  @Retention(RetentionPolicy.CLASS)
+  @Target({
+    ElementType.TYPE, ElementType.METHOD
+  })
+  public @interface OverrideOnly { }
+}
\ No newline at end of file

common/src/main/java/org/jetbrains/annotations/Async.java

@@ -12,7 +12,7 @@ import java.lang.annotation.Target;
  *
  * @author egor
  */
-public interface Async {
+public final class Async {
 
   /**
    * Indicates that the marked method schedules async computation.
@@ -20,7 +20,7 @@ public interface Async {
    */
   @Retention(RetentionPolicy.CLASS)
   @Target({ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PARAMETER})
-  @interface Schedule {}
+  public @interface Schedule {}
 
   /**
    * Indicates that the marked method executes async computation.
@@ -29,5 +29,5 @@ public interface Async {
    */
   @Retention(RetentionPolicy.CLASS)
   @Target({ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PARAMETER})
-  @interface Execute {}
+  public @interface Execute {}
 }

common/src/main/java/org/jetbrains/annotations/Debug.java

+// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+package org.jetbrains.annotations;
+
+import org.intellij.lang.annotations.Language;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @since 18.0.0
+ */
+public final class Debug {
+  /**
+   * Allows to change the presentation of an object in debuggers
+   */
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.CLASS)
+  public @interface Renderer {
+    /**
+     * Expression to be evaluated and used as the textual representation of the object.<br>
+     * {@code this} refers to the class instance being presented
+     */
+    @Language(value = "JAVA", prefix = "class Renderer{String $text(){return ", suffix = ";}}")
+    String text() default "";
+
+    /**
+     * Expression to be evaluated to obtain an array of object's children.<br>
+     * Usually the result is an array of elements in a collection, or an array of entries in a map.<br>
+     * {@code this} refers to the class instance being presented
+     */
+    @Language(value = "JAVA", prefix = "class Renderer{Object[] $childrenArray(){return ", suffix = ";}}")
+    String childrenArray() default "";
+
+    /**
+     * Expression to be evaluated to check if the object has any children at all.<br>
+     * This should work faster than {@link #childrenArray()} and return boolean.<br>
+     * {@code this} refers to the class instance being presented
+     */
+    @Language(value = "JAVA", prefix = "class Renderer{boolean $hasChildren(){return ", suffix = ";}}")
+    String hasChildren() default "";
+  }
+}

gradle.properties

-projectVersion=16.0.3
\ No newline at end of file
+projectVersion=18.0.0
\ No newline at end of file

java8/src/main/java/org/jetbrains/annotations/Range.java

+package org.jetbrains.annotations;
+
+import java.lang.annotation.*;
+
+/**
+ * An annotation which allows to specify for integral type (byte, char, short, int, long) an allowed values range.
+ * Applying this annotation to other types is not correct.
+ * <p>
+ * Example:
+ * <pre>{@code public @Range(from = 0, to = Integer.MAX_VALUE) int length() { 
+ *   return this.length; // returns a non-negative integer
+ * }}</pre>
+ *
+ * @since 17.0.0
+ */
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.TYPE_USE})
+public @interface Range {
+  /**
+   * @return minimal allowed value (inclusive)
+   */
+  long from();
+
+  /**
+   * @return maximal allowed value (inclusive)
+   */
+  long to();
+}
\ No newline at end of file