Esempio n. 1
0
 @NotNull
 @Override
 public String render(@NotNull InferenceErrorData inferenceErrorData) {
   return renderUpperBoundViolatedInferenceError(
           inferenceErrorData, TabledDescriptorRenderer.create())
       .toString();
 }
Esempio n. 2
0
 @NotNull
 @Override
 public String render(@NotNull ExtendedInferenceErrorData inferenceErrorData) {
   return renderNoInformationForParameterError(
           inferenceErrorData, TabledDescriptorRenderer.create())
       .toString();
 }
Esempio n. 3
0
 @NotNull
 @Override
 public String render(@NotNull ExtendedInferenceErrorData inferenceErrorData) {
   return renderTypeConstructorMismatchError(
           inferenceErrorData, TabledDescriptorRenderer.create())
       .toString();
 }
Esempio n. 4
0
 @NotNull
 @Override
 public String render(@NotNull ExtendedInferenceErrorData inferenceErrorData) {
   return renderConflictingSubstitutionsInferenceError(
           inferenceErrorData, TabledDescriptorRenderer.create())
       .toString();
 }
Esempio n. 5
0
  public static TabledDescriptorRenderer renderUpperBoundViolatedInferenceError(
      InferenceErrorData inferenceErrorData, TabledDescriptorRenderer result) {
    TypeParameterDescriptor typeParameterDescriptor = null;
    for (TypeParameterDescriptor typeParameter :
        inferenceErrorData.descriptor.getTypeParameters()) {
      if (!ConstraintsUtil.checkUpperBoundIsSatisfied(
          inferenceErrorData.constraintSystem, typeParameter, true)) {
        typeParameterDescriptor = typeParameter;
        break;
      }
    }
    assert typeParameterDescriptor != null;

    result
        .text(
            newText()
                .normal("Type parameter bound for ")
                .strong(typeParameterDescriptor.getName())
                .normal(" in "))
        .table(newTable().descriptor(inferenceErrorData.descriptor));

    JetType inferredValueForTypeParameter =
        ConstraintsUtil.getValue(
            inferenceErrorData.constraintSystem.getTypeConstraints(typeParameterDescriptor));
    assert inferredValueForTypeParameter != null;
    JetType upperBound = typeParameterDescriptor.getUpperBoundsAsType();
    JetType upperBoundWithSubstitutedInferredTypes =
        inferenceErrorData
            .constraintSystem
            .getResultingSubstitutor()
            .substitute(upperBound, Variance.INVARIANT);
    assert upperBoundWithSubstitutedInferredTypes != null;

    Renderer<JetType> typeRenderer = result.getTypeRenderer();
    result.text(
        newText()
            .normal(" is not satisfied: inferred type ")
            .error(typeRenderer.render(inferredValueForTypeParameter))
            .normal(" is not a subtype of ")
            .strong(typeRenderer.render(upperBoundWithSubstitutedInferredTypes)));
    return result;
  }
Esempio n. 6
0
 public static TabledDescriptorRenderer renderTypeConstructorMismatchError(
     final ExtendedInferenceErrorData inferenceErrorData, TabledDescriptorRenderer renderer) {
   Predicate<ConstraintPosition> isErrorPosition =
       new Predicate<ConstraintPosition>() {
         @Override
         public boolean apply(@Nullable ConstraintPosition constraintPosition) {
           assert constraintPosition != null;
           return inferenceErrorData.constraintSystem.hasTypeConstructorMismatchAt(
               constraintPosition);
         }
       };
   return renderer.table(
       TabledDescriptorRenderer.newTable()
           .descriptor(inferenceErrorData.descriptor)
           .text("cannot be applied to")
           .functionArgumentTypeList(
               inferenceErrorData.receiverArgumentType,
               inferenceErrorData.valueArgumentsTypes,
               isErrorPosition));
 }
Esempio n. 7
0
  public static TabledDescriptorRenderer renderNoInformationForParameterError(
      ExtendedInferenceErrorData inferenceErrorData, TabledDescriptorRenderer renderer) {
    TypeParameterDescriptor firstUnknownParameter = null;
    for (TypeParameterDescriptor typeParameter :
        inferenceErrorData.constraintSystem.getTypeVariables()) {
      if (inferenceErrorData.constraintSystem.getTypeConstraints(typeParameter).isEmpty()) {
        firstUnknownParameter = typeParameter;
        break;
      }
    }
    assert firstUnknownParameter != null;

    return renderer
        .text(
            newText()
                .normal("Not enough information to infer parameter ")
                .strong(firstUnknownParameter.getName())
                .normal(" in "))
        .table(
            newTable()
                .descriptor(inferenceErrorData.descriptor)
                .text("Please specify it explicitly."));
  }
Esempio n. 8
0
  public static TabledDescriptorRenderer renderConflictingSubstitutionsInferenceError(
      ExtendedInferenceErrorData inferenceErrorData, TabledDescriptorRenderer result) {
    assert inferenceErrorData.constraintSystem.hasConflictingConstraints();

    Collection<CallableDescriptor> substitutedDescriptors = Lists.newArrayList();
    Collection<TypeSubstitutor> substitutors =
        ConstraintsUtil.getSubstitutorsForConflictingParameters(
            inferenceErrorData.constraintSystem);
    for (TypeSubstitutor substitutor : substitutors) {
      CallableDescriptor substitutedDescriptor =
          inferenceErrorData.descriptor.substitute(substitutor);
      substitutedDescriptors.add(substitutedDescriptor);
    }

    TypeParameterDescriptor firstConflictingParameter =
        ConstraintsUtil.getFirstConflictingParameter(inferenceErrorData.constraintSystem);
    assert firstConflictingParameter != null;

    result.text(
        newText()
            .normal("Cannot infer type parameter ")
            .strong(firstConflictingParameter.getName())
            .normal(" in"));
    // String type = strong(firstConflictingParameter.getName());
    TableRenderer table = newTable();
    result.table(table);
    table.descriptor(inferenceErrorData.descriptor).text("None of the following substitutions");

    for (CallableDescriptor substitutedDescriptor : substitutedDescriptors) {
      JetType receiverType =
          DescriptorUtils.getReceiverParameterType(substitutedDescriptor.getReceiverParameter());

      final Collection<ConstraintPosition> errorPositions = Sets.newHashSet();
      List<JetType> parameterTypes = Lists.newArrayList();
      for (ValueParameterDescriptor valueParameterDescriptor :
          substitutedDescriptor.getValueParameters()) {
        parameterTypes.add(valueParameterDescriptor.getType());
        if (valueParameterDescriptor.getIndex() >= inferenceErrorData.valueArgumentsTypes.size())
          continue;
        JetType actualType =
            inferenceErrorData.valueArgumentsTypes.get(valueParameterDescriptor.getIndex());
        if (!JetTypeChecker.INSTANCE.isSubtypeOf(actualType, valueParameterDescriptor.getType())) {
          errorPositions.add(
              ConstraintPosition.getValueParameterPosition(valueParameterDescriptor.getIndex()));
        }
      }

      if (receiverType != null
          && inferenceErrorData.receiverArgumentType != null
          && !JetTypeChecker.INSTANCE.isSubtypeOf(
              inferenceErrorData.receiverArgumentType, receiverType)) {
        errorPositions.add(ConstraintPosition.RECEIVER_POSITION);
      }

      Predicate<ConstraintPosition> isErrorPosition =
          new Predicate<ConstraintPosition>() {
            @Override
            public boolean apply(@Nullable ConstraintPosition constraintPosition) {
              return errorPositions.contains(constraintPosition);
            }
          };
      table.functionArgumentTypeList(receiverType, parameterTypes, isErrorPosition);
    }

    table
        .text("can be applied to")
        .functionArgumentTypeList(
            inferenceErrorData.receiverArgumentType, inferenceErrorData.valueArgumentsTypes);

    return result;
  }