ImplicitSubclassInspection and ImplicitSubclassProvider description fixes

java/java-analysis-impl/src/com/intellij/codeInspection/inheritance/ImplicitSubclassProvider.java

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import static org.jetbrains.annotations.Nls.Capitalization.Sentence;
 
 /**
  * Provides information about classes/interfaces that will be implicitly subclassed/implemented at runtime,
@@ -49,8 +50,9 @@ public abstract class ImplicitSubclassProvider {
   /**
    * Checks if this provider will implicitly subclass passed class.
    * <b>Note:<b/> this method could be computationally costly because in some cases it could require deep annotations checks
-   * not only for class but also for all it's methods.
-   * Default implementations don't check methods, so implementors should override this methods if target framework
+   * not only for class but also for all its methods.
+   *
+   * Default implementation doesn't check methods, so implementors should override this methods if target framework
    * makes decision about overriding basing on methods annotations.
    *
    * @param psiClass a class to check for possible subclass.
@@ -67,7 +69,7 @@ public abstract class ImplicitSubclassProvider {
    * @param psiClass a class to check for possible subclass.
    * @return explanation why this class will be implicitly subclassed, or {@code null} if it will not be subclassed.
    */
-  @Nls
+  @Nls(capitalization = Sentence)
   @Nullable
   public abstract String findSubclassingReason(@NotNull PsiClass psiClass);
 
@@ -78,7 +80,7 @@ public abstract class ImplicitSubclassProvider {
    * @param psiMethod a method to check for implicit override.
    * @return explanation why this method will be implicitly overridden, or {@code null} if it will not be overridden.
    */
-  @Nls
+  @Nls(capitalization = Sentence)
   @Nullable
   public String findOverridingReason(@NotNull PsiMethod psiMethod) {
     return null;

java/openapi/src/com/intellij/codeInsight/MetaAnnotationUtil.java

@@ -199,12 +199,11 @@ public class MetaAnnotationUtil {
   @NotNull
   public static Stream<PsiAnnotation> findMetaAnnotations(@NotNull PsiModifierListOwner listOwner,
                                                           @NotNull final Collection<String> annotations) {
-
     Stream<PsiAnnotation> directAnnotations = Stream.of(AnnotationUtil.findAnnotations(listOwner, annotations));
 
     Stream<PsiClass> lazyResolvedAnnotations =
       Stream.generate(() -> getResolvedClassesInAnnotationsList(listOwner)).limit(1)
-        .flatMap(e -> e.stream());
+        .flatMap(it -> it.stream());
 
     Stream<PsiAnnotation> metaAnnotations =
       lazyResolvedAnnotations

platform/platform-resources-en/src/messages/InspectionsBundle.properties

@@ -827,8 +827,8 @@ inspection.reflection.invocation.array.not.assignable=Array {0,choice,1#item has
 
 inspection.implicit.subclass.display.forClass=Class ''{0}'' is eligible for implicit subclassing and must not be final
 inspection.implicit.subclass.display.forMethod=Method ''{0}'' should be overridable
-inspection.implicit.subclass.make.class.extendable=Make class open for extension
+inspection.implicit.subclass.make.class.extendable=Make class extendable
 inspection.implicit.subclass.extendable=Make ''{0}'' overridable
-inspection.implicit.subclass.display.name=Class could be implicitly overridden by framework
+inspection.implicit.subclass.display.name=Final class is eligible for implicit subclassing
 
 inspection.reflection.visibility.name=Reflective access across modules issues

spellchecker/src/com/intellij/spellchecker/english.dic

@@ -120422,7 +120422,9 @@ subcategory
 subcategory's
 subclass
 subclass's
+subclassed
 subclasses
+subclassing
 subclauses
 subcommittee
 subcommittees

spellchecker/src/com/intellij/spellchecker/jetbrains.dic

@@ -173,6 +173,7 @@ eval
 evex
 exif
 expr
+extendable
 externalizer
 facebook
 facelet