Example #1
0
  @NotNull
  public static Modality resolveModalityFromModifiers(
      @Nullable JetModifierList modifierList, @NotNull Modality defaultModality) {
    if (modifierList == null) return defaultModality;
    boolean hasAbstractModifier = modifierList.hasModifier(ABSTRACT_KEYWORD);
    boolean hasOverrideModifier = modifierList.hasModifier(OVERRIDE_KEYWORD);

    if (modifierList.hasModifier(SEALED_KEYWORD)) {
      return Modality.SEALED;
    }
    if (modifierList.hasModifier(OPEN_KEYWORD)) {
      if (hasAbstractModifier || defaultModality == Modality.ABSTRACT) {
        return Modality.ABSTRACT;
      }
      return Modality.OPEN;
    }
    if (hasAbstractModifier) {
      return Modality.ABSTRACT;
    }
    boolean hasFinalModifier = modifierList.hasModifier(FINAL_KEYWORD);
    if (hasOverrideModifier && !hasFinalModifier && !(defaultModality == Modality.ABSTRACT)) {
      return Modality.OPEN;
    }
    if (hasFinalModifier) {
      return Modality.FINAL;
    }
    return defaultModality;
  }
Example #2
0
 public static Visibility resolveVisibilityFromModifiers(
     @Nullable JetModifierList modifierList, @NotNull Visibility defaultVisibility) {
   if (modifierList == null) return defaultVisibility;
   if (modifierList.hasModifier(PRIVATE_KEYWORD)) return Visibilities.PRIVATE;
   if (modifierList.hasModifier(PUBLIC_KEYWORD)) return Visibilities.PUBLIC;
   if (modifierList.hasModifier(PROTECTED_KEYWORD)) return Visibilities.PROTECTED;
   if (modifierList.hasModifier(INTERNAL_KEYWORD)) return Visibilities.INTERNAL;
   return defaultVisibility;
 }
Example #3
0
 @NotNull
 public Map<JetModifierKeywordToken, PsiElement> getTokensCorrespondingToModifiers(
     @NotNull JetModifierList modifierList,
     @NotNull Collection<JetModifierKeywordToken> possibleModifiers) {
   Map<JetModifierKeywordToken, PsiElement> tokens = Maps.newHashMap();
   for (JetModifierKeywordToken modifier : possibleModifiers) {
     if (modifierList.hasModifier(modifier)) {
       tokens.put(modifier, modifierList.getModifier(modifier));
     }
   }
   return tokens;
 }
Example #4
0
 private void checkTraitModifiers(JetClass aClass) {
   reportErrorIfHasIllegalModifier(aClass);
   JetModifierList modifierList = aClass.getModifierList();
   if (modifierList == null) return;
   if (modifierList.hasModifier(JetTokens.FINAL_KEYWORD)) {
     trace.report(Errors.TRAIT_CAN_NOT_BE_FINAL.on(aClass));
   }
   if (modifierList.hasModifier(JetTokens.SEALED_KEYWORD)) {
     trace.report(Errors.TRAIT_CAN_NOT_BE_SEALED.on(aClass));
   }
   if (modifierList.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
     trace.report(Errors.ABSTRACT_MODIFIER_IN_TRAIT.on(aClass));
   }
   if (modifierList.hasModifier(JetTokens.OPEN_KEYWORD)) {
     trace.report(Errors.OPEN_MODIFIER_IN_TRAIT.on(aClass));
   }
 }
 @Override
 public void invoke(@NotNull Project project, Editor editor, @NotNull JetFile file)
     throws IncorrectOperationException {
   JetPsiFactory factory = new JetPsiFactory(annotationClass.getProject());
   JetModifierList list = annotationClass.getModifierList();
   String annotation = KotlinBuiltIns.FQ_NAMES.annotation.shortName().asString();
   PsiElement added;
   if (list == null) {
     JetModifierList newModifierList = factory.createModifierList(annotation);
     added =
         annotationClass.addBefore(newModifierList, annotationClass.getClassOrInterfaceKeyword());
   } else {
     JetAnnotationEntry entry = factory.createAnnotationEntry(annotation);
     added = list.addBefore(entry, list.getFirstChild());
   }
   annotationClass.addAfter(factory.createWhiteSpace(), added);
 }
Example #6
0
  private void checkModifiersAndAnnotationsInPackageDirective(JetFile file) {
    JetPackageDirective packageDirective = file.getPackageDirective();
    if (packageDirective == null) return;

    JetModifierList modifierList = packageDirective.getModifierList();
    if (modifierList == null) return;

    for (JetAnnotationEntry annotationEntry : modifierList.getAnnotationEntries()) {
      JetConstructorCalleeExpression calleeExpression = annotationEntry.getCalleeExpression();
      if (calleeExpression != null) {
        JetReferenceExpression reference = calleeExpression.getConstructorReferenceExpression();
        if (reference != null) {
          trace.report(UNRESOLVED_REFERENCE.on(reference, reference));
        }
      }
    }
    AnnotationTargetChecker.INSTANCE$.check(packageDirective, trace);

    ModifiersChecker.reportIllegalModifiers(
        modifierList, Arrays.asList(JetTokens.MODIFIER_KEYWORDS_ARRAY), trace);
  }
Example #7
0
  private void checkPropertyAbstractness(
      @NotNull JetProperty property,
      @NotNull PropertyDescriptor propertyDescriptor,
      @NotNull ClassDescriptor classDescriptor) {
    JetPropertyAccessor getter = property.getGetter();
    JetPropertyAccessor setter = property.getSetter();
    JetModifierList modifierList = property.getModifierList();
    ASTNode abstractNode =
        modifierList != null ? modifierList.getModifierNode(JetTokens.ABSTRACT_KEYWORD) : null;

    if (abstractNode != null) { // has abstract modifier
      if (!classCanHaveAbstractMembers(classDescriptor)) {
        String name = property.getName();
        trace.report(
            ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.on(
                property, name != null ? name : "", classDescriptor));
        return;
      }
      if (classDescriptor.getKind() == ClassKind.INTERFACE) {
        trace.report(ABSTRACT_MODIFIER_IN_TRAIT.on(property));
      }
    }

    if (propertyDescriptor.getModality() == Modality.ABSTRACT) {
      JetExpression initializer = property.getInitializer();
      if (initializer != null) {
        trace.report(ABSTRACT_PROPERTY_WITH_INITIALIZER.on(initializer));
      }
      JetPropertyDelegate delegate = property.getDelegate();
      if (delegate != null) {
        trace.report(ABSTRACT_DELEGATED_PROPERTY.on(delegate));
      }
      if (getter != null && getter.hasBody()) {
        trace.report(ABSTRACT_PROPERTY_WITH_GETTER.on(getter));
      }
      if (setter != null && setter.hasBody()) {
        trace.report(ABSTRACT_PROPERTY_WITH_SETTER.on(setter));
      }
    }
  }
Example #8
0
 public static boolean isInnerClass(@Nullable JetModifierList modifierList) {
   return modifierList != null && modifierList.hasModifier(INNER_KEYWORD);
 }