Java ProblemHighlightType.GENERIC_ERROR_OR_WARNING屬性代碼示例

@Override
protected void registerError(@NotNull PsiElement location,
                             @NotNull String description,
                             @Nullable LocalQuickFix[] fixes,
                             ProblemHighlightType highlightType) {
  if (PsiUtil.isCompileStatic(location)) {
    // filter all errors here, error will be highlighted by annotator
    if (highlightType != ProblemHighlightType.GENERIC_ERROR) {
      super.registerError(location, description, fixes, highlightType);
    }
  }
  else {
    if (highlightType == ProblemHighlightType.GENERIC_ERROR) {
      // if this visitor works within non-static context we will highlight all errors as warnings
      super.registerError(location, description, fixes, ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
    }
    else {
      // if this visitor works within static context errors will be highlighted as errors by annotator, warnings will be highlighted as warnings here
      super.registerError(location, description, fixes, highlightType);
    }
  }
}
 

private static IntentionAction createIntention(PsiElement node, TextRange range, String message, LocalQuickFix fix) {
  LocalQuickFix[] quickFixes = {fix};
  CommonProblemDescriptorImpl descr = new ProblemDescriptorImpl(node, node, message,
                                                                quickFixes, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, true,
                                                                range, true);
  return QuickFixWrapper.wrap((ProblemDescriptor)descr, 0);
}
 

private static ProblemHighlightType getProblemHighlightType(final DomElementProblemDescriptor problemDescriptor) {
  if (problemDescriptor.getHighlightType() != null) {
    return problemDescriptor.getHighlightType();
  }
  if (problemDescriptor instanceof DomElementResolveProblemDescriptor) {
    final TextRange range = ((DomElementResolveProblemDescriptor)problemDescriptor).getPsiReference().getRangeInElement();
    if (range.getStartOffset() != range.getEndOffset()) {
      return ProblemHighlightType.LIKE_UNKNOWN_SYMBOL;
    }
  }
  return ProblemHighlightType.GENERIC_ERROR_OR_WARNING;
}
 

@Override
public void visitCastExpression(GrTypeCastExpression expression) {
  super.visitCastExpression(expression);

  final GrExpression operand = expression.getOperand();
  if (operand == null) return;
  final PsiType actualType = operand.getType();
  if (actualType == null) return;

  if (expression.getCastTypeElement() == null) return;
  final PsiType expectedType = expression.getCastTypeElement().getType();
  
  final ConversionResult result = TypesUtil.canCast(expectedType, actualType, expression);
  if (result == ConversionResult.OK) return;
  final ProblemHighlightType highlightType = result == ConversionResult.ERROR
                                             ? ProblemHighlightType.GENERIC_ERROR
                                             : ProblemHighlightType.GENERIC_ERROR_OR_WARNING;
  final String message = GroovyBundle.message(
    "cannot.cast",
    actualType.getPresentableText(),
    expectedType.getPresentableText()
  );
  registerError(
    expression,
    highlightType,
    message
  );
}
 

@Nullable
private static Pair<String, ProblemHighlightType> checkTypes(@Nullable PyType expected,
                                                             @Nullable PyType actual,
                                                             @NotNull TypeEvalContext context,
                                                             @NotNull Map<PyGenericType, PyType> substitutions) {
  if (actual != null && expected != null) {
    if (!PyTypeChecker.match(expected, actual, context, substitutions)) {
      final String expectedName = PythonDocumentationProvider.getTypeName(expected, context);
      String quotedExpectedName = String.format("'%s'", expectedName);
      final boolean hasGenerics = PyTypeChecker.hasGenerics(expected, context);
      ProblemHighlightType highlightType = ProblemHighlightType.GENERIC_ERROR_OR_WARNING;
      if (hasGenerics) {
        final PyType substitute = PyTypeChecker.substitute(expected, substitutions, context);
        if (substitute != null) {
          quotedExpectedName = String.format("'%s' (matched generic type '%s')",
                                   PythonDocumentationProvider.getTypeName(substitute, context),
                                   expectedName);
          highlightType = ProblemHighlightType.WEAK_WARNING;
        }
      }
      final String actualName = PythonDocumentationProvider.getTypeName(actual, context);
      String msg= String.format("Expected type %s, got '%s' instead", quotedExpectedName, actualName);
      if (expected instanceof PyStructuralType) {
        final Set<String> expectedAttributes = ((PyStructuralType)expected).getAttributeNames();
        final Set<String> actualAttributes = getAttributes(actual, context);
        if (actualAttributes != null) {
          final Sets.SetView<String> missingAttributes = Sets.difference(expectedAttributes, actualAttributes);
          if (missingAttributes.size() == 1) {
            msg = String.format("Type '%s' doesn't have expected attribute '%s'", actualName, missingAttributes.iterator().next());
          }
          else {
            msg = String.format("Type '%s' doesn't have expected attributes %s",
                                actualName,
                                StringUtil.join(missingAttributes, new Function<String, String>() {
                                  @Override
                                  public String fun(String s) {
                                    return String.format("'%s'", s);
                                  }
                                }, ", "));
          }
        }
      }
      return Pair.create(msg, highlightType);
    }
  }
  return null;
}
 

public static Effect invalid(String attrName, String text) {
  return new InvalidAttrEffect(attrName, text, ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
}
 

public RequireAttributeOneOf(String ... attributeNames) {
  myAttributeNames = attributeNames;
  myProblemHighlightType = ProblemHighlightType.GENERIC_ERROR_OR_WARNING;
}
 

public SqliteMagicProblem(String message) {
  this(message, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, EMPTY_QUICK_FIXS);
}