コード例 #1
0
  private static void checkForUnexpectedErrors() {
    AnalyzeExhaust exhaust =
        WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile((JetFile) getFile());
    Collection<Diagnostic> diagnostics = exhaust.getBindingContext().getDiagnostics();

    if (diagnostics.size() != 0) {
      String[] expectedErrorStrings =
          InTextDirectivesUtils.findListWithPrefix("// ERROR:", getFile().getText());

      System.out.println(getFile().getText());

      Collection<String> expectedErrors = new HashSet<String>(Arrays.asList(expectedErrorStrings));

      StringBuilder builder = new StringBuilder();
      boolean hasErrors = false;

      for (Diagnostic diagnostic : diagnostics) {
        if (diagnostic.getSeverity() == Severity.ERROR) {
          String errorText = IdeErrorMessages.RENDERER.render(diagnostic);
          if (!expectedErrors.contains(errorText)) {
            hasErrors = true;
            builder.append("// ERROR: ").append(errorText).append("\n");
          }
        }
      }

      Assert.assertFalse(
          "There should be no unexpected errors after applying fix (Use \"// ERROR:\" directive): \n"
              + builder.toString(),
          hasErrors);
    }
  }
コード例 #2
0
 @SuppressWarnings({"unchecked", "ConstantConditions"})
 private static void checkResolvedCallsInDiagnostics(BindingContext bindingContext) {
   Set<DiagnosticFactory> diagnosticsStoringResolvedCalls1 =
       Sets.<DiagnosticFactory>newHashSet(
           OVERLOAD_RESOLUTION_AMBIGUITY,
           NONE_APPLICABLE,
           CANNOT_COMPLETE_RESOLVE,
           UNRESOLVED_REFERENCE_WRONG_RECEIVER,
           ASSIGN_OPERATOR_AMBIGUITY,
           ITERATOR_AMBIGUITY);
   Set<DiagnosticFactory> diagnosticsStoringResolvedCalls2 =
       Sets.<DiagnosticFactory>newHashSet(
           COMPONENT_FUNCTION_AMBIGUITY,
           DELEGATE_SPECIAL_FUNCTION_AMBIGUITY,
           DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE);
   Diagnostics diagnostics = bindingContext.getDiagnostics();
   for (Diagnostic diagnostic : diagnostics) {
     DiagnosticFactory factory = diagnostic.getFactory();
     if (diagnosticsStoringResolvedCalls1.contains(factory)) {
       assertResolvedCallsAreCompleted(
           diagnostic,
           ((DiagnosticWithParameters1<PsiElement, Collection<? extends ResolvedCall<?>>>)
                   diagnostic)
               .getA());
     }
     if (diagnosticsStoringResolvedCalls2.contains(factory)) {
       assertResolvedCallsAreCompleted(
           diagnostic,
           ((DiagnosticWithParameters2<PsiElement, Object, Collection<? extends ResolvedCall<?>>>)
                   diagnostic)
               .getB());
     }
   }
 }
コード例 #3
0
  private static void assertResolvedCallsAreCompleted(
      @NotNull Diagnostic diagnostic,
      @NotNull Collection<? extends ResolvedCall<?>> resolvedCalls) {
    boolean allCallsAreCompleted = true;
    for (ResolvedCall<?> resolvedCall : resolvedCalls) {
      if (!((MutableResolvedCall<?>) resolvedCall).isCompleted()) {
        allCallsAreCompleted = false;
      }
    }

    PsiElement element = diagnostic.getPsiElement();
    DiagnosticUtils.LineAndColumn lineAndColumn =
        DiagnosticUtils.getLineAndColumnInPsiFile(
            element.getContainingFile(), element.getTextRange());

    assertTrue(
        "Resolved calls stored in "
            + diagnostic.getFactory().getName()
            + "\n"
            + "for '"
            + element.getText()
            + "'"
            + lineAndColumn
            + " are not completed",
        allCallsAreCompleted);
  }
コード例 #4
0
  /*
   * Add a quick fix if and return modified annotation.
   */
  @Nullable
  private static Annotation registerQuickFix(
      @Nullable Annotation annotation, @NotNull Diagnostic diagnostic) {
    if (annotation == null) {
      return null;
    }

    Collection<JetIntentionActionFactory> intentionActionFactories =
        QuickFixes.getActionFactories(diagnostic.getFactory());
    for (JetIntentionActionFactory intentionActionFactory : intentionActionFactories) {
      IntentionAction action = null;
      if (intentionActionFactory != null) {
        action = intentionActionFactory.createAction(diagnostic);
      }
      if (action != null) {
        annotation.registerFix(action);
      }
    }

    Collection<IntentionAction> actions = QuickFixes.getActions(diagnostic.getFactory());
    for (IntentionAction action : actions) {
      annotation.registerFix(action);
    }

    return annotation;
  }
コード例 #5
0
 @NotNull
 private static String getMessage(@NotNull Diagnostic diagnostic) {
   if (ApplicationManager.getApplication().isInternal()
       || ApplicationManager.getApplication().isUnitTestMode()) {
     return "[" + diagnostic.getFactory().getName() + "] " + diagnostic.getMessage();
   }
   return diagnostic.getMessage();
 }
コード例 #6
0
  @Override
  public void annotate(@NotNull PsiElement element, @NotNull final AnnotationHolder holder) {
    for (HighlightingVisitor visitor : getBeforeAnalysisVisitors(holder)) {
      element.accept(visitor);
    }

    if (element instanceof JetFile) {
      JetFile file = (JetFile) element;

      try {
        BindingContext bindingContext =
            WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile(file).getBindingContext();

        if (errorReportingEnabled) {
          Collection<Diagnostic> diagnostics =
              Sets.newLinkedHashSet(bindingContext.getDiagnostics());
          Set<PsiElement> redeclarations = Sets.newHashSet();
          for (Diagnostic diagnostic : diagnostics) {
            // This is needed because we have the same context for all files
            if (diagnostic.getPsiFile() != file) continue;

            registerDiagnosticAnnotations(diagnostic, redeclarations, holder);
          }
        }

        for (HighlightingVisitor visitor : getAfterAnalysisVisitor(holder, bindingContext)) {
          file.acceptChildren(visitor);
        }
      } catch (ProcessCanceledException e) {
        throw e;
      } catch (AssertionError e) {
        // For failing tests and to notify about idea internal error in -ea mode
        holder.createErrorAnnotation(
            element, e.getClass().getCanonicalName() + ": " + e.getMessage());
        throw e;
      } catch (Throwable e) {
        // TODO
        holder.createErrorAnnotation(
            element, e.getClass().getCanonicalName() + ": " + e.getMessage());
        e.printStackTrace();
      }
    }
  }
コード例 #7
0
  private static void checkNoUnresolvedReferences(@NotNull final JetFile file) {
    AnalyzeExhaust exhaust = AnalyzerFacadeWithCache.analyzeFileWithCache(file);
    for (Diagnostic diagnostic : exhaust.getBindingContext().getDiagnostics()) {
      if (Errors.UNRESOLVED_REFERENCE_DIAGNOSTICS.contains(diagnostic.getFactory())) {
        List<TextRange> textRanges = diagnostic.getTextRanges();
        String diagnosticText = DefaultErrorMessages.RENDERER.render(diagnostic);
        if (diagnostic.getPsiFile() == file) {
          fail(
              diagnostic.getFactory().getName()
                  + ": "
                  + diagnosticText
                  + " "
                  + DiagnosticUtils.atLocation(file, textRanges.get(0)));
        }
      }
    }
    DebugInfoUtil.markDebugAnnotations(
        file,
        exhaust.getBindingContext(),
        new DebugInfoUtil.DebugInfoReporter() {
          @Override
          public void reportElementWithErrorType(@NotNull JetReferenceExpression expression) {
            // do nothing
          }

          @Override
          public void reportMissingUnresolved(@NotNull JetReferenceExpression expression) {
            // this may happen if incorrect psi transformations are done
            fail(
                expression.getText()
                    + " is unresolved but not marked "
                    + DiagnosticUtils.atLocation(file, expression.getTextRange()));
          }

          @Override
          public void reportUnresolvedWithTarget(
              @NotNull JetReferenceExpression expression, @NotNull String target) {
            // do nothing
          }
        });
  }
コード例 #8
0
  private static void registerDiagnosticAnnotations(
      @NotNull Diagnostic diagnostic,
      @NotNull Set<PsiElement> redeclarations,
      @NotNull final AnnotationHolder holder) {
    List<TextRange> textRanges = diagnostic.getTextRanges();
    if (diagnostic.getSeverity() == Severity.ERROR) {
      if (diagnostic.getFactory() == Errors.UNRESOLVED_IDE_TEMPLATE) {
        return;
      }
      if (diagnostic instanceof UnresolvedReferenceDiagnostic) {
        UnresolvedReferenceDiagnostic unresolvedReferenceDiagnostic =
            (UnresolvedReferenceDiagnostic) diagnostic;
        JetReferenceExpression referenceExpression = unresolvedReferenceDiagnostic.getPsiElement();
        PsiReference reference = referenceExpression.getReference();
        if (reference instanceof MultiRangeReference) {
          MultiRangeReference mrr = (MultiRangeReference) reference;
          for (TextRange range : mrr.getRanges()) {
            Annotation annotation =
                holder.createErrorAnnotation(
                    range.shiftRight(referenceExpression.getTextOffset()), diagnostic.getMessage());

            registerQuickFix(annotation, diagnostic);

            annotation.setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL);
          }
        } else {
          for (TextRange textRange : textRanges) {
            Annotation annotation =
                holder.createErrorAnnotation(textRange, diagnostic.getMessage());
            registerQuickFix(annotation, diagnostic);
            annotation.setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL);
          }
        }

        return;
      }

      if (diagnostic.getFactory() == Errors.ILLEGAL_ESCAPE_SEQUENCE) {
        for (TextRange textRange : diagnostic.getTextRanges()) {
          Annotation annotation = holder.createErrorAnnotation(textRange, diagnostic.getMessage());
          annotation.setTextAttributes(JetHighlightingColors.INVALID_STRING_ESCAPE);
        }
      }

      if (diagnostic instanceof RedeclarationDiagnostic) {
        RedeclarationDiagnostic redeclarationDiagnostic = (RedeclarationDiagnostic) diagnostic;
        registerQuickFix(
            markRedeclaration(redeclarations, redeclarationDiagnostic, holder), diagnostic);
        return;
      }

      // Generic annotation
      for (TextRange textRange : textRanges) {
        Annotation errorAnnotation =
            holder.createErrorAnnotation(textRange, getMessage(diagnostic));
        registerQuickFix(errorAnnotation, diagnostic);

        if (diagnostic.getFactory() == Errors.INVISIBLE_REFERENCE) {
          errorAnnotation.setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL);
        }
      }
    } else if (diagnostic.getSeverity() == Severity.WARNING) {
      for (TextRange textRange : textRanges) {
        Annotation annotation = holder.createWarningAnnotation(textRange, getMessage(diagnostic));
        registerQuickFix(annotation, diagnostic);

        if (diagnostic.getFactory() instanceof UnusedElementDiagnosticFactory) {
          annotation.setHighlightType(ProblemHighlightType.LIKE_UNUSED_SYMBOL);
        }
      }
    }
  }