Examples with Name org.jetbrains.kotlin.name.Name used on opensource projects

Example 21 with Name

use of org.jetbrains.kotlin.name.Name in project kotlin by JetBrains.

the class CodegenAnnotatingVisitor method getName.

private String getName(ClassDescriptor classDescriptor) {
    String base = peekFromStack(nameStack);
    Name descriptorName = safeIdentifier(classDescriptor.getName());
    if (DescriptorUtils.isTopLevelDeclaration(classDescriptor)) {
        return base.isEmpty() ? descriptorName.asString() : base + '/' + descriptorName;
    } else {
        return typeMappingConfiguration.getInnerClassNameFactory().invoke(base, descriptorName.asString());
    }
}

Example 22 with Name

use of org.jetbrains.kotlin.name.Name in project kotlin by JetBrains.

the class DescriptorResolver method checkUpperBoundTypes.

public static void checkUpperBoundTypes(@NotNull BindingTrace trace, @NotNull List<UpperBoundCheckRequest> requests) {
    if (requests.isEmpty())
        return;
    Set<Name> classBoundEncountered = new HashSet<Name>();
    Set<Pair<Name, TypeConstructor>> allBounds = new HashSet<Pair<Name, TypeConstructor>>();
    for (UpperBoundCheckRequest request : requests) {
        Name typeParameterName = request.typeParameterName;
        KotlinType upperBound = request.upperBoundType;
        KtTypeReference upperBoundElement = request.upperBound;
        if (!upperBound.isError()) {
            if (!allBounds.add(new Pair<Name, TypeConstructor>(typeParameterName, upperBound.getConstructor()))) {
                trace.report(REPEATED_BOUND.on(upperBoundElement));
            } else {
                ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(upperBound);
                if (classDescriptor != null) {
                    ClassKind kind = classDescriptor.getKind();
                    if (kind == ClassKind.CLASS || kind == ClassKind.ENUM_CLASS || kind == ClassKind.OBJECT) {
                        if (!classBoundEncountered.add(typeParameterName)) {
                            trace.report(ONLY_ONE_CLASS_BOUND_ALLOWED.on(upperBoundElement));
                        }
                    }
                }
            }
        }
        checkUpperBoundType(upperBoundElement, upperBound, trace);
    }
}

Example 23 with Name

use of org.jetbrains.kotlin.name.Name in project kotlin by JetBrains.

the class DescriptorResolver method checkNamesInConstraints.

public void checkNamesInConstraints(@NotNull KtTypeParameterListOwner declaration, @NotNull DeclarationDescriptor descriptor, @NotNull LexicalScope scope, @NotNull BindingTrace trace) {
    for (KtTypeConstraint constraint : declaration.getTypeConstraints()) {
        KtSimpleNameExpression nameExpression = constraint.getSubjectTypeParameterName();
        if (nameExpression == null)
            continue;
        Name name = nameExpression.getReferencedNameAsName();
        ClassifierDescriptor classifier = ScopeUtilsKt.findClassifier(scope, name, NoLookupLocation.FOR_NON_TRACKED_SCOPE);
        if (classifier instanceof TypeParameterDescriptor && classifier.getContainingDeclaration() == descriptor)
            continue;
        if (classifier != null) {
            // To tell the user that we look only for locally defined type parameters
            trace.report(NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER.on(nameExpression, constraint, declaration));
            trace.record(BindingContext.REFERENCE_TARGET, nameExpression, classifier);
        } else {
            trace.report(UNRESOLVED_REFERENCE.on(nameExpression, nameExpression));
        }
        KtTypeReference boundTypeReference = constraint.getBoundTypeReference();
        if (boundTypeReference != null) {
            typeResolver.resolveType(scope, boundTypeReference, trace, true);
        }
    }
}

Example 24 with Name

use of org.jetbrains.kotlin.name.Name in project kotlin by JetBrains.

the class DescriptorResolver method resolveGenericBounds.

public void resolveGenericBounds(@NotNull KtTypeParameterListOwner declaration, @NotNull DeclarationDescriptor descriptor, LexicalScope scope, List<TypeParameterDescriptorImpl> parameters, BindingTrace trace) {
    List<UpperBoundCheckRequest> upperBoundCheckRequests = Lists.newArrayList();
    List<KtTypeParameter> typeParameters = declaration.getTypeParameters();
    Map<Name, TypeParameterDescriptorImpl> parameterByName = Maps.newHashMap();
    for (int i = 0; i < typeParameters.size(); i++) {
        KtTypeParameter ktTypeParameter = typeParameters.get(i);
        TypeParameterDescriptorImpl typeParameterDescriptor = parameters.get(i);
        parameterByName.put(typeParameterDescriptor.getName(), typeParameterDescriptor);
        KtTypeReference extendsBound = ktTypeParameter.getExtendsBound();
        if (extendsBound != null) {
            KotlinType type = typeResolver.resolveType(scope, extendsBound, trace, false);
            typeParameterDescriptor.addUpperBound(type);
            upperBoundCheckRequests.add(new UpperBoundCheckRequest(ktTypeParameter.getNameAsName(), extendsBound, type));
        }
    }
    for (KtTypeConstraint constraint : declaration.getTypeConstraints()) {
        KtSimpleNameExpression subjectTypeParameterName = constraint.getSubjectTypeParameterName();
        if (subjectTypeParameterName == null) {
            continue;
        }
        Name referencedName = subjectTypeParameterName.getReferencedNameAsName();
        TypeParameterDescriptorImpl typeParameterDescriptor = parameterByName.get(referencedName);
        KtTypeReference boundTypeReference = constraint.getBoundTypeReference();
        KotlinType bound = null;
        if (boundTypeReference != null) {
            bound = typeResolver.resolveType(scope, boundTypeReference, trace, false);
            upperBoundCheckRequests.add(new UpperBoundCheckRequest(referencedName, boundTypeReference, bound));
        }
        if (typeParameterDescriptor != null) {
            trace.record(BindingContext.REFERENCE_TARGET, subjectTypeParameterName, typeParameterDescriptor);
            if (bound != null) {
                typeParameterDescriptor.addUpperBound(bound);
            }
        }
    }
    for (TypeParameterDescriptorImpl parameter : parameters) {
        parameter.addDefaultUpperBound();
        parameter.setInitialized();
    }
    for (TypeParameterDescriptorImpl parameter : parameters) {
        checkConflictingUpperBounds(trace, parameter, typeParameters.get(parameter.getIndex()));
    }
    if (!(declaration instanceof KtClass)) {
        checkUpperBoundTypes(trace, upperBoundCheckRequests);
        checkNamesInConstraints(declaration, descriptor, scope, trace);
    }
}

Example 25 with Name

use of org.jetbrains.kotlin.name.Name 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;
}