Пример #1
0
  // allowedFinalSupertypes typically contains a enum type of which supertypeOwner is an entry
  private void checkSupertypeList(
      @NotNull MutableClassDescriptor supertypeOwner,
      @NotNull Map<JetTypeReference, JetType> supertypes,
      Set<TypeConstructor> allowedFinalSupertypes) {
    Set<TypeConstructor> typeConstructors = Sets.newHashSet();
    boolean classAppeared = false;
    for (Map.Entry<JetTypeReference, JetType> entry : supertypes.entrySet()) {
      JetTypeReference typeReference = entry.getKey();
      JetType supertype = entry.getValue();

      ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype);
      if (classDescriptor != null) {
        if (classDescriptor.getKind() != ClassKind.TRAIT) {
          if (classAppeared) {
            trace.report(MANY_CLASSES_IN_SUPERTYPE_LIST.on(typeReference));
          } else {
            classAppeared = true;
          }
        }
      } else {
        trace.report(SUPERTYPE_NOT_A_CLASS_OR_TRAIT.on(typeReference));
      }

      TypeConstructor constructor = supertype.getConstructor();
      if (!typeConstructors.add(constructor)) {
        trace.report(SUPERTYPE_APPEARS_TWICE.on(typeReference));
      }

      if (constructor.isSealed() && !allowedFinalSupertypes.contains(constructor)) {
        trace.report(FINAL_SUPERTYPE.on(typeReference));
      }
    }
  }
Пример #2
0
  private void resolveSecondaryConstructorBodies() {
    for (Map.Entry<JetSecondaryConstructor, ConstructorDescriptor> entry :
        this.context.getConstructors().entrySet()) {
      JetSecondaryConstructor constructor = entry.getKey();
      ConstructorDescriptor descriptor = entry.getValue();

      resolveSecondaryConstructorBody(constructor, descriptor);

      assert descriptor.getReturnType() != null;
    }
  }
Пример #3
0
 private void resolvePrimaryConstructorParameters() {
   for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
     JetClass klass = entry.getKey();
     MutableClassDescriptor classDescriptor = entry.getValue();
     ConstructorDescriptor unsubstitutedPrimaryConstructor =
         classDescriptor.getUnsubstitutedPrimaryConstructor();
     if (unsubstitutedPrimaryConstructor != null) {
       checkDefaultParameterValues(
           klass.getPrimaryConstructorParameters(),
           unsubstitutedPrimaryConstructor.getValueParameters(),
           classDescriptor.getScopeForInitializers());
     }
   }
 }
Пример #4
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;
 }
Пример #5
0
  private void resolveFunctionBodies() {
    for (Map.Entry<JetNamedFunction, SimpleFunctionDescriptor> entry :
        this.context.getFunctions().entrySet()) {
      JetNamedFunction declaration = entry.getKey();
      SimpleFunctionDescriptor descriptor = entry.getValue();

      computeDeferredType(descriptor.getReturnType());

      JetScope declaringScope = this.context.getDeclaringScopes().get(declaration);
      assert declaringScope != null;

      resolveFunctionBody(trace, declaration, descriptor, declaringScope);

      assert descriptor.getReturnType() != null;
    }
  }
Пример #6
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;
  }
Пример #7
0
 private void resolveAnonymousInitializers() {
   for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
     resolveAnonymousInitializers(entry.getKey(), entry.getValue());
   }
   for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry :
       context.getObjects().entrySet()) {
     resolveAnonymousInitializers(entry.getKey(), entry.getValue());
   }
 }
Пример #8
0
 private void resolveDelegationSpecifierLists() {
   // TODO : Make sure the same thing is not initialized twice
   for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
     resolveDelegationSpecifierList(entry.getKey(), entry.getValue());
   }
   for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry :
       context.getObjects().entrySet()) {
     resolveDelegationSpecifierList(entry.getKey(), entry.getValue());
   }
 }
Пример #9
0
  private void resolvePropertyDeclarationBodies() {

    // Member properties
    Set<JetProperty> processed = Sets.newHashSet();
    for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
      JetClass jetClass = entry.getKey();
      if (!context.completeAnalysisNeeded(jetClass)) continue;
      MutableClassDescriptor classDescriptor = entry.getValue();

      for (JetProperty property : jetClass.getProperties()) {
        final PropertyDescriptor propertyDescriptor = this.context.getProperties().get(property);
        assert propertyDescriptor != null;

        computeDeferredType(propertyDescriptor.getReturnType());

        JetExpression initializer = property.getInitializer();
        if (initializer != null) {
          ConstructorDescriptor primaryConstructor =
              classDescriptor.getUnsubstitutedPrimaryConstructor();
          if (primaryConstructor != null) {
            JetScope declaringScopeForPropertyInitializer =
                this.context.getDeclaringScopes().get(property);
            resolvePropertyInitializer(
                property, propertyDescriptor, initializer, declaringScopeForPropertyInitializer);
          }
        }

        resolvePropertyAccessors(property, propertyDescriptor);
        processed.add(property);
      }
    }

    // Top-level properties & properties of objects
    for (Map.Entry<JetProperty, PropertyDescriptor> entry :
        this.context.getProperties().entrySet()) {
      JetProperty property = entry.getKey();
      if (!context.completeAnalysisNeeded(property)) continue;
      if (processed.contains(property)) continue;

      final PropertyDescriptor propertyDescriptor = entry.getValue();

      computeDeferredType(propertyDescriptor.getReturnType());

      JetScope declaringScope = this.context.getDeclaringScopes().get(property);

      JetExpression initializer = property.getInitializer();
      if (initializer != null) {
        resolvePropertyInitializer(property, propertyDescriptor, initializer, declaringScope);
      }

      resolvePropertyAccessors(property, propertyDescriptor);
    }
  }