Esempio n. 1
0
 @Override
 public boolean hasUnknownParameters() {
   for (TypeConstraintsImpl constraints : typeParameterConstraints.values()) {
     if (constraints.isEmpty()) {
       return true;
     }
   }
   return false;
 }
Esempio n. 2
0
 @Override
 public boolean hasConflictingConstraints() {
   for (TypeParameterDescriptor typeParameter : typeParameterConstraints.keySet()) {
     TypeConstraints typeConstraints = getTypeConstraints(typeParameter);
     if (typeConstraints != null && ConstraintsUtil.getValues(typeConstraints).size() > 1)
       return true;
   }
   return false;
 }
Esempio n. 3
0
 @Override
 @NotNull
 public ConstraintSystem copy() {
   ConstraintSystemImpl newConstraintSystem = new ConstraintSystemImpl();
   for (Map.Entry<TypeParameterDescriptor, TypeConstraintsImpl> entry :
       typeParameterConstraints.entrySet()) {
     TypeParameterDescriptor typeParameter = entry.getKey();
     TypeConstraintsImpl typeConstraints = entry.getValue();
     newConstraintSystem.typeParameterConstraints.put(typeParameter, typeConstraints.copy());
   }
   newConstraintSystem.errorConstraintPositions.addAll(errorConstraintPositions);
   newConstraintSystem.hasErrorInConstrainingTypes = hasErrorInConstrainingTypes;
   return newConstraintSystem;
 }
Esempio n. 4
0
  @NotNull
  public ConstraintSystem replaceTypeVariables(
      @NotNull Function<TypeParameterDescriptor, TypeParameterDescriptor> typeVariablesMap) {
    ConstraintSystemImpl newConstraintSystem = new ConstraintSystemImpl();
    for (Map.Entry<TypeParameterDescriptor, TypeConstraintsImpl> entry :
        typeParameterConstraints.entrySet()) {
      TypeParameterDescriptor typeParameter = entry.getKey();
      TypeConstraintsImpl typeConstraints = entry.getValue();

      TypeParameterDescriptor newTypeParameter = typeVariablesMap.apply(typeParameter);
      assert newTypeParameter != null;
      newConstraintSystem.typeParameterConstraints.put(newTypeParameter, typeConstraints);
    }
    newConstraintSystem.errorConstraintPositions.addAll(errorConstraintPositions);
    newConstraintSystem.hasErrorInConstrainingTypes = hasErrorInConstrainingTypes;
    return newConstraintSystem;
  }
Esempio n. 5
0
 @Override
 @Nullable
 public TypeConstraints getTypeConstraints(@NotNull TypeParameterDescriptor typeVariable) {
   return typeParameterConstraints.get(typeVariable);
 }
Esempio n. 6
0
 @NotNull
 @Override
 public Set<TypeParameterDescriptor> getTypeVariables() {
   return typeParameterConstraints.keySet();
 }
Esempio n. 7
0
  private void addConstraint(
      @NotNull ConstraintKind constraintKind,
      @NotNull JetType subjectType,
      @Nullable JetType constrainingType,
      @NotNull ConstraintPosition constraintPosition) {

    if (constrainingType == TypeUtils.NO_EXPECTED_TYPE
        || constrainingType == DONT_CARE
        || constrainingType == CANT_INFER) {
      return;
    }

    if (constrainingType == null
        || (ErrorUtils.isErrorType(constrainingType)
            && constrainingType != PLACEHOLDER_FUNCTION_TYPE)) {
      hasErrorInConstrainingTypes = true;
      return;
    }

    assert subjectType != TypeUtils.NO_EXPECTED_TYPE
        : "Subject type shouldn't be NO_EXPECTED_TYPE (in position " + constraintPosition + " )";
    if (ErrorUtils.isErrorType(subjectType)) return;

    DeclarationDescriptor subjectTypeDescriptor =
        subjectType.getConstructor().getDeclarationDescriptor();

    KotlinBuiltIns kotlinBuiltIns = KotlinBuiltIns.getInstance();
    if (constrainingType == PLACEHOLDER_FUNCTION_TYPE) {
      if (!kotlinBuiltIns.isFunctionOrExtensionFunctionType(subjectType)) {
        if (subjectTypeDescriptor instanceof TypeParameterDescriptor
            && typeParameterConstraints.get(subjectTypeDescriptor) != null) {
          // a constraint binds type parameter and any function type, so there is no new info and no
          // error
          return;
        }
        errorConstraintPositions.add(constraintPosition);
      }
      return;
    }

    // todo temporary hack
    // function literal without declaring receiver type { x -> ... }
    // can be considered as extension function if one is expected
    // (special type constructor for function/ extension function should be introduced like
    // PLACEHOLDER_FUNCTION_TYPE)
    if (constraintKind == SUB_TYPE
        && kotlinBuiltIns.isFunctionType(constrainingType)
        && kotlinBuiltIns.isExtensionFunctionType(subjectType)) {
      constrainingType = createCorrespondingExtensionFunctionType(constrainingType, DONT_CARE);
    }

    DeclarationDescriptor constrainingTypeDescriptor =
        constrainingType.getConstructor().getDeclarationDescriptor();

    if (subjectTypeDescriptor instanceof TypeParameterDescriptor) {
      TypeParameterDescriptor typeParameter = (TypeParameterDescriptor) subjectTypeDescriptor;
      TypeConstraintsImpl typeConstraints = typeParameterConstraints.get(typeParameter);
      if (typeConstraints != null) {
        if (TypeUtils.dependsOnTypeParameterConstructors(
            constrainingType, Collections.singleton(DONT_CARE.getConstructor()))) {
          return;
        }
        if (subjectType.isNullable() && constrainingType.isNullable()) {
          constrainingType = TypeUtils.makeNotNullable(constrainingType);
        }
        typeConstraints.addBound(constraintKind, constrainingType);
        return;
      }
    }
    if (constrainingTypeDescriptor instanceof TypeParameterDescriptor) {
      assert typeParameterConstraints.get(constrainingTypeDescriptor) == null
          : "Constraining type contains type variable " + constrainingTypeDescriptor.getName();
    }
    if (constraintKind == SUB_TYPE && kotlinBuiltIns.isNothingOrNullableNothing(constrainingType)) {
      // following constraints are always true:
      // 'Nothing' is a subtype of any type
      if (!constrainingType.isNullable()) return;
      // 'Nothing?' is a subtype of nullable type
      if (subjectType.isNullable()) return;
    }
    if (!(constrainingTypeDescriptor instanceof ClassDescriptor)
        || !(subjectTypeDescriptor instanceof ClassDescriptor)) {
      errorConstraintPositions.add(constraintPosition);
      return;
    }
    switch (constraintKind) {
      case SUB_TYPE:
        {
          if (kotlinBuiltIns.isNothingOrNullableNothing(constrainingType)) break;
          JetType correspondingSupertype =
              TypeCheckingProcedure.findCorrespondingSupertype(constrainingType, subjectType);
          if (correspondingSupertype != null) {
            constrainingType = correspondingSupertype;
          }
          break;
        }
      case SUPER_TYPE:
        {
          if (kotlinBuiltIns.isNothingOrNullableNothing(subjectType)) break;
          JetType correspondingSupertype =
              TypeCheckingProcedure.findCorrespondingSupertype(subjectType, constrainingType);
          if (correspondingSupertype != null) {
            subjectType = correspondingSupertype;
          }
        }
      case EQUAL: // nothing
    }
    if (constrainingType.getConstructor() != subjectType.getConstructor()) {
      errorConstraintPositions.add(constraintPosition);
      return;
    }
    TypeConstructor typeConstructor = subjectType.getConstructor();
    List<TypeProjection> subjectArguments = subjectType.getArguments();
    List<TypeProjection> constrainingArguments = constrainingType.getArguments();
    List<TypeParameterDescriptor> parameters = typeConstructor.getParameters();
    for (int i = 0; i < subjectArguments.size(); i++) {
      Variance typeParameterVariance = parameters.get(i).getVariance();
      TypeProjection subjectArgument = subjectArguments.get(i);
      TypeProjection constrainingArgument = constrainingArguments.get(i);

      ConstraintKind typeParameterConstraintKind =
          getTypeParameterConstraintKind(
              typeParameterVariance, subjectArgument, constrainingArgument, constraintKind);

      addConstraint(
          typeParameterConstraintKind,
          subjectArgument.getType(),
          constrainingArgument.getType(),
          constraintPosition);
    }
  }
Esempio n. 8
0
 @Override
 public void registerTypeVariable(
     @NotNull TypeParameterDescriptor typeVariable, @NotNull Variance positionVariance) {
   typeParameterConstraints.put(typeVariable, new TypeConstraintsImpl(positionVariance));
 }