private void createClassObjectForEnumClass(
@NotNull MutableClassDescriptor mutableClassDescriptor) {
if (mutableClassDescriptor.getKind() == ClassKind.ENUM_CLASS) {
MutableClassDescriptor classObject = createSyntheticClassObject(mutableClassDescriptor);
mutableClassDescriptor.getBuilder().setClassObjectDescriptor(classObject);
classObject
.getBuilder()
.addFunctionDescriptor(
DescriptorResolver.createEnumClassObjectValuesMethod(classObject, trace));
classObject
.getBuilder()
.addFunctionDescriptor(
DescriptorResolver.createEnumClassObjectValueOfMethod(classObject, trace));
}
}
@NotNull
private MutablePackageFragmentDescriptor getOrCreatePackageFragmentForFile(
@NotNull JetFile file) {
JetPackageDirective packageDirective = file.getPackageDirective();
assert packageDirective != null : "scripts are not supported";
MutablePackageFragmentDescriptor fragment =
packageFragmentProvider.getOrCreateFragment(packageDirective.getFqName());
ModuleDescriptor module = packageFragmentProvider.getModule();
DescriptorResolver.resolvePackageHeader(
packageDirective, module, TypeHierarchyResolver.this.trace);
trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file, fragment);
// Register files corresponding to this package
// The trace currently does not support bi-di multimaps that would handle this task nicer
FqName fqName = fragment.getFqName();
Collection<JetFile> files = trace.get(PACKAGE_TO_FILES, fqName);
if (files == null) {
files = Sets.newIdentityHashSet();
}
files.add(file);
trace.record(BindingContext.PACKAGE_TO_FILES, fqName, files);
return fragment;
}
private void resolvePropertyInitializer(
JetProperty property,
PropertyDescriptor propertyDescriptor,
JetExpression initializer,
JetScope scope) {
// JetFlowInformationProvider flowInformationProvider =
// context.getDescriptorResolver().computeFlowData(property, initializer); // TODO : flow JET-15
JetType expectedTypeForInitializer =
property.getPropertyTypeRef() != null ? propertyDescriptor.getType() : NO_EXPECTED_TYPE;
JetType type =
expressionTypingServices.getType(
descriptorResolver.getPropertyDeclarationInnerScope(
scope,
propertyDescriptor,
propertyDescriptor.getTypeParameters(),
propertyDescriptor.getReceiverParameter(),
trace),
initializer,
expectedTypeForInitializer,
trace);
//
// JetType expectedType = propertyDescriptor.getInType();
// if (expectedType == null) {
// expectedType = propertyDescriptor.getType();
// }
// if (type != null && expectedType != null
// && !context.getSemanticServices().getTypeChecker().isSubtypeOf(type,
// expectedType)) {
//// trace.report(TYPE_MISMATCH.on(initializer, expectedType, type));
// }
}
@NotNull
private ConstructorDescriptorImpl createPrimaryConstructorForObject(
@Nullable PsiElement object, @NotNull MutableClassDescriptor mutableClassDescriptor) {
ConstructorDescriptorImpl constructorDescriptor =
DescriptorResolver.createAndRecordPrimaryConstructorForObject(
object, mutableClassDescriptor, trace);
mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor);
return constructorDescriptor;
}
private void resolveTypesInClassHeaders(@NotNull TopDownAnalysisContext c) {
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry :
c.getClasses().entrySet()) {
JetClassOrObject classOrObject = entry.getKey();
if (classOrObject instanceof JetClass) {
ClassDescriptorWithResolutionScopes descriptor = entry.getValue();
//noinspection unchecked
descriptorResolver.resolveGenericBounds(
(JetClass) classOrObject,
descriptor,
descriptor.getScopeForClassHeaderResolution(),
(List) descriptor.getTypeConstructor().getParameters(),
trace);
}
}
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry :
c.getClasses().entrySet()) {
descriptorResolver.resolveSupertypesForMutableClassDescriptor(
entry.getKey(), (MutableClassDescriptor) entry.getValue(), trace);
}
}
private void createTypeConstructors(@NotNull TopDownAnalysisContext c) {
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry :
c.getClasses().entrySet()) {
JetClassOrObject classOrObject = entry.getKey();
MutableClassDescriptor descriptor = (MutableClassDescriptor) entry.getValue();
if (classOrObject instanceof JetClass) {
descriptorResolver.resolveMutableClassDescriptor(
(JetClass) classOrObject, descriptor, trace);
} else if (classOrObject instanceof JetObjectDeclaration) {
descriptor.setModality(Modality.FINAL);
descriptor.setVisibility(
resolveVisibilityFromModifiers(classOrObject, getDefaultClassVisibility(descriptor)));
descriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
}
descriptor.createTypeConstructor();
ClassKind kind = descriptor.getKind();
if (kind == ClassKind.ENUM_ENTRY
|| kind == ClassKind.OBJECT
|| kind == ClassKind.ENUM_CLASS) {
MutableClassDescriptorLite classObject = descriptor.getClassObjectDescriptor();
assert classObject != null
: "Enum entries and named objects should have class objects: "
+ classOrObject.getText();
JetType supertype;
if (kind == ClassKind.ENUM_CLASS) {
supertype = KotlinBuiltIns.getInstance().getAnyType();
} else {
// This is a clever hack: each enum entry and object declaration (i.e. singleton) has a
// synthetic class object.
// We make this class object inherit from the singleton here, thus allowing to use the
// singleton's class object where
// the instance of the singleton is applicable. Effectively all members of the singleton
// would be present in its class
// object as fake overrides, so you can access them via standard class object notation:
// ObjectName.memberName()
supertype = descriptor.getDefaultType();
}
classObject.setSupertypes(Collections.singleton(supertype));
classObject.createTypeConstructor();
}
}
}
private JetScope makeScopeForPropertyAccessor(
@NotNull JetPropertyAccessor accessor, PropertyDescriptor propertyDescriptor) {
JetScope declaringScope = context.getDeclaringScopes().get(accessor);
JetScope propertyDeclarationInnerScope =
descriptorResolver.getPropertyDeclarationInnerScope(
declaringScope,
propertyDescriptor,
propertyDescriptor.getTypeParameters(),
propertyDescriptor.getReceiverParameter(),
trace);
WritableScope accessorScope =
new WritableScopeImpl(
propertyDeclarationInnerScope,
declaringScope.getContainingDeclaration(),
new TraceBasedRedeclarationHandler(trace))
.setDebugName("Accessor scope");
accessorScope.changeLockLevel(WritableScope.LockLevel.READING);
return accessorScope;
}