// 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));
}
}
}
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;
}
}
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());
}
}
}
@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;
}
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;
}
}
@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;
}
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());
}
}
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());
}
}
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);
}
}