Examples with CompositeAnnotations org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations used on opensource projects

Example 1 with CompositeAnnotations

use of org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations in project kotlin by JetBrains.

the class DescriptorResolver method resolvePropertyGetterDescriptor.

@NotNull
private PropertyGetterDescriptorImpl resolvePropertyGetterDescriptor(@NotNull LexicalScope scopeForDeclarationResolution, @NotNull KtProperty property, @NotNull PropertyDescriptor propertyDescriptor, @NotNull AnnotationSplitter annotationSplitter, @NotNull BindingTrace trace, @Nullable KotlinType propertyTypeIfKnown) {
    PropertyGetterDescriptorImpl getterDescriptor;
    KtPropertyAccessor getter = property.getGetter();
    KotlinType getterType;
    if (getter != null) {
        Annotations getterAnnotations = new CompositeAnnotations(CollectionsKt.listOf(annotationSplitter.getAnnotationsForTarget(PROPERTY_GETTER), annotationResolver.resolveAnnotationsWithoutArguments(scopeForDeclarationResolution, getter.getModifierList(), trace)));
        getterDescriptor = new PropertyGetterDescriptorImpl(propertyDescriptor, getterAnnotations, resolveMemberModalityFromModifiers(getter, propertyDescriptor.getModality(), trace.getBindingContext(), propertyDescriptor.getContainingDeclaration()), resolveVisibilityFromModifiers(getter, propertyDescriptor.getVisibility()), /* isDefault = */
        false, getter.hasModifier(EXTERNAL_KEYWORD), property.hasModifier(KtTokens.INLINE_KEYWORD) || getter.hasModifier(KtTokens.INLINE_KEYWORD), CallableMemberDescriptor.Kind.DECLARATION, null, KotlinSourceElementKt.toSourceElement(getter));
        getterType = determineGetterReturnType(scopeForDeclarationResolution, trace, getterDescriptor, getter, propertyTypeIfKnown);
        trace.record(BindingContext.PROPERTY_ACCESSOR, getter, getterDescriptor);
    } else {
        Annotations getterAnnotations = annotationSplitter.getAnnotationsForTarget(PROPERTY_GETTER);
        getterDescriptor = DescriptorFactory.createGetter(propertyDescriptor, getterAnnotations, !property.hasDelegate(), /* isExternal = */
        false, property.hasModifier(KtTokens.INLINE_KEYWORD));
        getterType = propertyTypeIfKnown;
    }
    getterDescriptor.initialize(getterType != null ? getterType : VariableTypeAndInitializerResolver.STUB_FOR_PROPERTY_WITHOUT_TYPE);
    return getterDescriptor;
}

Example 2 with CompositeAnnotations

use of org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations in project kotlin by JetBrains.

the class TypeSubstitutor method unsafeSubstitute.

@NotNull
private TypeProjection unsafeSubstitute(@NotNull TypeProjection originalProjection, int recursionDepth) throws SubstitutionException {
    assertRecursionDepth(recursionDepth, originalProjection, substitution);
    if (originalProjection.isStarProjection())
        return originalProjection;
    // The type is within the substitution range, i.e. T or T?
    KotlinType type = originalProjection.getType();
    if (DynamicTypesKt.isDynamic(type) || type.unwrap() instanceof RawType) {
        // todo investigate
        return originalProjection;
    }
    TypeProjection replacement = substitution.get(type);
    Variance originalProjectionKind = originalProjection.getProjectionKind();
    if (replacement == null && FlexibleTypesKt.isFlexible(type) && !TypeCapabilitiesKt.isCustomTypeVariable(type)) {
        FlexibleType flexibleType = FlexibleTypesKt.asFlexibleType(type);
        TypeProjection substitutedLower = unsafeSubstitute(new TypeProjectionImpl(originalProjectionKind, flexibleType.getLowerBound()), recursionDepth + 1);
        TypeProjection substitutedUpper = unsafeSubstitute(new TypeProjectionImpl(originalProjectionKind, flexibleType.getUpperBound()), recursionDepth + 1);
        Variance substitutedProjectionKind = substitutedLower.getProjectionKind();
        assert (substitutedProjectionKind == substitutedUpper.getProjectionKind()) && originalProjectionKind == Variance.INVARIANT || originalProjectionKind == substitutedProjectionKind : "Unexpected substituted projection kind: " + substitutedProjectionKind + "; original: " + originalProjectionKind;
        KotlinType substitutedFlexibleType = KotlinTypeFactory.flexibleType(TypeSubstitutionKt.asSimpleType(substitutedLower.getType()), TypeSubstitutionKt.asSimpleType(substitutedUpper.getType()));
        return new TypeProjectionImpl(substitutedProjectionKind, substitutedFlexibleType);
    }
    if (KotlinBuiltIns.isNothing(type) || type.isError())
        return originalProjection;
    if (replacement != null) {
        VarianceConflictType varianceConflict = conflictType(originalProjectionKind, replacement.getProjectionKind());
        // Captured type might be substituted in an opposite projection:
        // out 'Captured (in Int)' = out Int
        // in 'Captured (out Int)' = in Int
        boolean allowVarianceConflict = CapturedTypeConstructorKt.isCaptured(type);
        if (!allowVarianceConflict) {
            //noinspection EnumSwitchStatementWhichMissesCases
            switch(varianceConflict) {
                case OUT_IN_IN_POSITION:
                    throw new SubstitutionException("Out-projection in in-position");
                case IN_IN_OUT_POSITION:
                    // todo use the right type parameter variance and upper bound
                    return new TypeProjectionImpl(Variance.OUT_VARIANCE, type.getConstructor().getBuiltIns().getNullableAnyType());
            }
        }
        KotlinType substitutedType;
        CustomTypeVariable typeVariable = TypeCapabilitiesKt.getCustomTypeVariable(type);
        if (replacement.isStarProjection()) {
            return replacement;
        } else if (typeVariable != null) {
            substitutedType = typeVariable.substitutionResult(replacement.getType());
        } else {
            // this is a simple type T or T?: if it's T, we should just take replacement, if T? - we make replacement nullable
            substitutedType = TypeUtils.makeNullableIfNeeded(replacement.getType(), type.isMarkedNullable());
        }
        // substitutionType.annotations = replacement.annotations ++ type.annotations
        if (!type.getAnnotations().isEmpty()) {
            Annotations typeAnnotations = filterOutUnsafeVariance(substitution.filterAnnotations(type.getAnnotations()));
            substitutedType = TypeUtilsKt.replaceAnnotations(substitutedType, new CompositeAnnotations(substitutedType.getAnnotations(), typeAnnotations));
        }
        Variance resultingProjectionKind = varianceConflict == VarianceConflictType.NO_CONFLICT ? combine(originalProjectionKind, replacement.getProjectionKind()) : originalProjectionKind;
        return new TypeProjectionImpl(resultingProjectionKind, substitutedType);
    }
    // The type is not within the substitution range, i.e. Foo, Bar<T> etc.
    return substituteCompoundType(originalProjection, recursionDepth);
}

Example 3 with CompositeAnnotations

use of org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations in project kotlin by JetBrains.

the class DescriptorResolver method resolvePropertyDescriptor.

@NotNull
public PropertyDescriptor resolvePropertyDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull LexicalScope scopeForDeclarationResolution, @NotNull LexicalScope scopeForInitializerResolution, @NotNull KtProperty property, @NotNull final BindingTrace trace, @NotNull DataFlowInfo dataFlowInfo) {
    KtModifierList modifierList = property.getModifierList();
    boolean isVar = property.isVar();
    boolean hasBody = hasBody(property);
    Visibility visibility = resolveVisibilityFromModifiers(property, getDefaultVisibility(property, containingDeclaration));
    Modality modality = containingDeclaration instanceof ClassDescriptor ? resolveMemberModalityFromModifiers(property, getDefaultModality(containingDeclaration, visibility, hasBody), trace.getBindingContext(), containingDeclaration) : Modality.FINAL;
    final AnnotationSplitter.PropertyWrapper wrapper = new AnnotationSplitter.PropertyWrapper(property);
    Annotations allAnnotations = annotationResolver.resolveAnnotationsWithoutArguments(scopeForDeclarationResolution, modifierList, trace);
    AnnotationSplitter annotationSplitter = new AnnotationSplitter(storageManager, allAnnotations, new Function0<Set<AnnotationUseSiteTarget>>() {

        @Override
        public Set<AnnotationUseSiteTarget> invoke() {
            return AnnotationSplitter.getTargetSet(false, trace.getBindingContext(), wrapper);
        }
    });
    Annotations propertyAnnotations = new CompositeAnnotations(CollectionsKt.listOf(annotationSplitter.getAnnotationsForTargets(PROPERTY, FIELD, PROPERTY_DELEGATE_FIELD), annotationSplitter.getOtherAnnotations()));
    PropertyDescriptorImpl propertyDescriptor = PropertyDescriptorImpl.create(containingDeclaration, propertyAnnotations, modality, visibility, isVar, KtPsiUtil.safeName(property.getName()), CallableMemberDescriptor.Kind.DECLARATION, KotlinSourceElementKt.toSourceElement(property), modifierList != null && modifierList.hasModifier(KtTokens.LATEINIT_KEYWORD), modifierList != null && modifierList.hasModifier(KtTokens.CONST_KEYWORD), modifierList != null && modifierList.hasModifier(KtTokens.HEADER_KEYWORD) || containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).isHeader(), modifierList != null && modifierList.hasModifier(KtTokens.IMPL_KEYWORD), modifierList != null && modifierList.hasModifier(KtTokens.EXTERNAL_KEYWORD), property.hasDelegate());
    wrapper.setDescriptor(propertyDescriptor);
    List<TypeParameterDescriptorImpl> typeParameterDescriptors;
    LexicalScope scopeForDeclarationResolutionWithTypeParameters;
    LexicalScope scopeForInitializerResolutionWithTypeParameters;
    KotlinType receiverType = null;
    {
        List<KtTypeParameter> typeParameters = property.getTypeParameters();
        if (typeParameters.isEmpty()) {
            scopeForDeclarationResolutionWithTypeParameters = scopeForDeclarationResolution;
            scopeForInitializerResolutionWithTypeParameters = scopeForInitializerResolution;
            typeParameterDescriptors = Collections.emptyList();
        } else {
            LexicalWritableScope writableScopeForDeclarationResolution = new LexicalWritableScope(scopeForDeclarationResolution, containingDeclaration, false, new TraceBasedLocalRedeclarationChecker(trace, overloadChecker), LexicalScopeKind.PROPERTY_HEADER);
            LexicalWritableScope writableScopeForInitializerResolution = new LexicalWritableScope(scopeForInitializerResolution, containingDeclaration, false, LocalRedeclarationChecker.DO_NOTHING.INSTANCE, LexicalScopeKind.PROPERTY_HEADER);
            typeParameterDescriptors = resolveTypeParametersForDescriptor(propertyDescriptor, scopeForDeclarationResolution, typeParameters, trace);
            for (TypeParameterDescriptor descriptor : typeParameterDescriptors) {
                writableScopeForDeclarationResolution.addClassifierDescriptor(descriptor);
                writableScopeForInitializerResolution.addClassifierDescriptor(descriptor);
            }
            writableScopeForDeclarationResolution.freeze();
            writableScopeForInitializerResolution.freeze();
            resolveGenericBounds(property, propertyDescriptor, writableScopeForDeclarationResolution, typeParameterDescriptors, trace);
            scopeForDeclarationResolutionWithTypeParameters = writableScopeForDeclarationResolution;
            scopeForInitializerResolutionWithTypeParameters = writableScopeForInitializerResolution;
        }
        KtTypeReference receiverTypeRef = property.getReceiverTypeReference();
        if (receiverTypeRef != null) {
            receiverType = typeResolver.resolveType(scopeForDeclarationResolutionWithTypeParameters, receiverTypeRef, trace, true);
        }
    }
    ReceiverParameterDescriptor receiverDescriptor = DescriptorFactory.createExtensionReceiverParameterForCallable(propertyDescriptor, receiverType);
    LexicalScope scopeForInitializer = ScopeUtils.makeScopeForPropertyInitializer(scopeForInitializerResolutionWithTypeParameters, propertyDescriptor);
    KotlinType typeIfKnown = variableTypeAndInitializerResolver.resolveTypeNullable(propertyDescriptor, scopeForInitializer, property, dataFlowInfo, /* local = */
    trace, false);
    PropertyGetterDescriptorImpl getter = resolvePropertyGetterDescriptor(scopeForDeclarationResolutionWithTypeParameters, property, propertyDescriptor, annotationSplitter, trace, typeIfKnown);
    KotlinType type = typeIfKnown != null ? typeIfKnown : getter.getReturnType();
    assert type != null : "At least getter type must be initialized via resolvePropertyGetterDescriptor";
    variableTypeAndInitializerResolver.setConstantForVariableIfNeeded(propertyDescriptor, scopeForInitializer, property, dataFlowInfo, type, trace);
    propertyDescriptor.setType(type, typeParameterDescriptors, getDispatchReceiverParameterIfNeeded(containingDeclaration), receiverDescriptor);
    PropertySetterDescriptor setter = resolvePropertySetterDescriptor(scopeForDeclarationResolutionWithTypeParameters, property, propertyDescriptor, annotationSplitter, trace);
    propertyDescriptor.initialize(getter, setter);
    trace.record(BindingContext.VARIABLE, property, propertyDescriptor);
    return propertyDescriptor;
}

Example 4 with CompositeAnnotations

use of org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations in project kotlin by JetBrains.

the class DescriptorResolver method resolvePropertySetterDescriptor.

@Nullable
private PropertySetterDescriptor resolvePropertySetterDescriptor(@NotNull LexicalScope scopeWithTypeParameters, @NotNull KtProperty property, @NotNull PropertyDescriptor propertyDescriptor, @NotNull AnnotationSplitter annotationSplitter, @NotNull BindingTrace trace) {
    KtPropertyAccessor setter = property.getSetter();
    PropertySetterDescriptorImpl setterDescriptor = null;
    if (setter != null) {
        Annotations annotations = new CompositeAnnotations(CollectionsKt.listOf(annotationSplitter.getAnnotationsForTarget(PROPERTY_SETTER), annotationResolver.resolveAnnotationsWithoutArguments(scopeWithTypeParameters, setter.getModifierList(), trace)));
        KtParameter parameter = setter.getParameter();
        setterDescriptor = new PropertySetterDescriptorImpl(propertyDescriptor, annotations, resolveMemberModalityFromModifiers(setter, propertyDescriptor.getModality(), trace.getBindingContext(), propertyDescriptor.getContainingDeclaration()), resolveVisibilityFromModifiers(setter, propertyDescriptor.getVisibility()), /* isDefault = */
        false, setter.hasModifier(EXTERNAL_KEYWORD), property.hasModifier(KtTokens.INLINE_KEYWORD) || setter.hasModifier(KtTokens.INLINE_KEYWORD), CallableMemberDescriptor.Kind.DECLARATION, null, KotlinSourceElementKt.toSourceElement(setter));
        KtTypeReference returnTypeReference = setter.getReturnTypeReference();
        if (returnTypeReference != null) {
            KotlinType returnType = typeResolver.resolveType(scopeWithTypeParameters, returnTypeReference, trace, true);
            if (!KotlinBuiltIns.isUnit(returnType)) {
                trace.report(WRONG_SETTER_RETURN_TYPE.on(returnTypeReference));
            }
        }
        if (parameter != null) {
            // This check is redundant: the parser does not allow a default value, but we'll keep it just in case
            if (parameter.hasDefaultValue()) {
                trace.report(SETTER_PARAMETER_WITH_DEFAULT_VALUE.on(parameter.getDefaultValue()));
            }
            KotlinType type;
            KtTypeReference typeReference = parameter.getTypeReference();
            if (typeReference == null) {
                // TODO : this maybe unknown at this point
                type = propertyDescriptor.getType();
            } else {
                type = typeResolver.resolveType(scopeWithTypeParameters, typeReference, trace, true);
                KotlinType inType = propertyDescriptor.getType();
                if (!TypeUtils.equalTypes(type, inType)) {
                    trace.report(WRONG_SETTER_PARAMETER_TYPE.on(typeReference, inType, type));
                }
            }
            ValueParameterDescriptorImpl valueParameterDescriptor = resolveValueParameterDescriptor(scopeWithTypeParameters, setterDescriptor, parameter, 0, type, trace);
            setterDescriptor.initialize(valueParameterDescriptor);
        } else {
            setterDescriptor.initializeDefault();
        }
        trace.record(BindingContext.PROPERTY_ACCESSOR, setter, setterDescriptor);
    } else if (property.isVar()) {
        Annotations setterAnnotations = annotationSplitter.getAnnotationsForTarget(PROPERTY_SETTER);
        setterDescriptor = DescriptorFactory.createSetter(propertyDescriptor, setterAnnotations, !property.hasDelegate(), /* isExternal = */
        false, property.hasModifier(KtTokens.INLINE_KEYWORD), propertyDescriptor.getSource());
    }
    if (!property.isVar()) {
        if (setter != null) {
            //                trace.getErrorHandler().genericError(setter.asElement().getNode(), "A 'val'-property cannot have a setter");
            trace.report(VAL_WITH_SETTER.on(setter));
        }
    }
    return setterDescriptor;
}

Example 5 with CompositeAnnotations

use of org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations in project kotlin by JetBrains.

the class DescriptorResolver method resolvePrimaryConstructorParameterToAProperty.

@NotNull
public PropertyDescriptor resolvePrimaryConstructorParameterToAProperty(@NotNull ClassDescriptor classDescriptor, @NotNull ValueParameterDescriptor valueParameter, @NotNull LexicalScope scope, @NotNull KtParameter parameter, final BindingTrace trace) {
    KotlinType type = resolveParameterType(scope, parameter, trace);
    Name name = parameter.getNameAsSafeName();
    boolean isMutable = parameter.isMutable();
    KtModifierList modifierList = parameter.getModifierList();
    if (modifierList != null) {
        if (modifierList.hasModifier(KtTokens.ABSTRACT_KEYWORD)) {
            trace.report(ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS.on(parameter));
        }
    }
    final AnnotationSplitter.PropertyWrapper propertyWrapper = new AnnotationSplitter.PropertyWrapper(parameter);
    Annotations allAnnotations = annotationResolver.resolveAnnotationsWithoutArguments(scope, parameter.getModifierList(), trace);
    AnnotationSplitter annotationSplitter = new AnnotationSplitter(storageManager, allAnnotations, new Function0<Set<AnnotationUseSiteTarget>>() {

        @Override
        public Set<AnnotationUseSiteTarget> invoke() {
            return AnnotationSplitter.getTargetSet(true, trace.getBindingContext(), propertyWrapper);
        }
    });
    Annotations propertyAnnotations = new CompositeAnnotations(annotationSplitter.getAnnotationsForTargets(PROPERTY, FIELD), annotationSplitter.getOtherAnnotations());
    PropertyDescriptorImpl propertyDescriptor = PropertyDescriptorImpl.create(classDescriptor, propertyAnnotations, resolveMemberModalityFromModifiers(parameter, Modality.FINAL, trace.getBindingContext(), classDescriptor), resolveVisibilityFromModifiers(parameter, getDefaultVisibility(parameter, classDescriptor)), isMutable, name, CallableMemberDescriptor.Kind.DECLARATION, KotlinSourceElementKt.toSourceElement(parameter), false, false, classDescriptor.isHeader(), modifierList != null && modifierList.hasModifier(KtTokens.IMPL_KEYWORD), false, false);
    propertyWrapper.setDescriptor(propertyDescriptor);
    propertyDescriptor.setType(type, Collections.<TypeParameterDescriptor>emptyList(), getDispatchReceiverParameterIfNeeded(classDescriptor), (ReceiverParameterDescriptor) null);
    Annotations setterAnnotations = annotationSplitter.getAnnotationsForTarget(PROPERTY_SETTER);
    Annotations getterAnnotations = new CompositeAnnotations(CollectionsKt.listOf(annotationSplitter.getAnnotationsForTarget(PROPERTY_GETTER)));
    PropertyGetterDescriptorImpl getter = DescriptorFactory.createDefaultGetter(propertyDescriptor, getterAnnotations);
    PropertySetterDescriptor setter = propertyDescriptor.isVar() ? DescriptorFactory.createDefaultSetter(propertyDescriptor, setterAnnotations) : null;
    propertyDescriptor.initialize(getter, setter);
    getter.initialize(propertyDescriptor.getType());
    trace.record(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter, propertyDescriptor);
    trace.record(BindingContext.VALUE_PARAMETER_AS_PROPERTY, valueParameter, propertyDescriptor);
    return propertyDescriptor;
}