Examples with ResolvedCall org.jetbrains.kotlin.resolve.calls.model.ResolvedCall used on opensource projects

Example 6 with ResolvedCall

use of org.jetbrains.kotlin.resolve.calls.model.ResolvedCall in project kotlin by JetBrains.

the class DebugInfoUtil method markDebugAnnotations.

public static void markDebugAnnotations(@NotNull PsiElement root, @NotNull final BindingContext bindingContext, @NotNull final DebugInfoReporter debugInfoReporter) {
    final Map<KtReferenceExpression, DiagnosticFactory<?>> markedWithErrorElements = Maps.newHashMap();
    for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
        DiagnosticFactory<?> factory = diagnostic.getFactory();
        if (Errors.UNRESOLVED_REFERENCE_DIAGNOSTICS.contains(diagnostic.getFactory())) {
            markedWithErrorElements.put((KtReferenceExpression) diagnostic.getPsiElement(), factory);
        } else if (factory == Errors.SUPER_IS_NOT_AN_EXPRESSION || factory == Errors.SUPER_NOT_AVAILABLE) {
            KtSuperExpression superExpression = (KtSuperExpression) diagnostic.getPsiElement();
            markedWithErrorElements.put(superExpression.getInstanceReference(), factory);
        } else if (factory == Errors.EXPRESSION_EXPECTED_PACKAGE_FOUND) {
            markedWithErrorElements.put((KtSimpleNameExpression) diagnostic.getPsiElement(), factory);
        } else if (factory == Errors.UNSUPPORTED) {
            for (KtReferenceExpression reference : PsiTreeUtil.findChildrenOfType(diagnostic.getPsiElement(), KtReferenceExpression.class)) {
                markedWithErrorElements.put(reference, factory);
            }
        }
    }
    root.acceptChildren(new KtTreeVisitorVoid() {

        @Override
        public void visitForExpression(@NotNull KtForExpression expression) {
            KtExpression range = expression.getLoopRange();
            reportIfDynamicCall(range, range, LOOP_RANGE_ITERATOR_RESOLVED_CALL);
            reportIfDynamicCall(range, range, LOOP_RANGE_HAS_NEXT_RESOLVED_CALL);
            reportIfDynamicCall(range, range, LOOP_RANGE_NEXT_RESOLVED_CALL);
            super.visitForExpression(expression);
        }

        @Override
        public void visitDestructuringDeclaration(@NotNull KtDestructuringDeclaration destructuringDeclaration) {
            for (KtDestructuringDeclarationEntry entry : destructuringDeclaration.getEntries()) {
                reportIfDynamicCall(entry, entry, COMPONENT_RESOLVED_CALL);
            }
            super.visitDestructuringDeclaration(destructuringDeclaration);
        }

        @Override
        public void visitProperty(@NotNull KtProperty property) {
            VariableDescriptor descriptor = bindingContext.get(VARIABLE, property);
            if (descriptor instanceof PropertyDescriptor && property.getDelegate() != null) {
                PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
                reportIfDynamicCall(property.getDelegate(), propertyDescriptor, PROVIDE_DELEGATE_RESOLVED_CALL);
                reportIfDynamicCall(property.getDelegate(), propertyDescriptor.getGetter(), DELEGATED_PROPERTY_RESOLVED_CALL);
                reportIfDynamicCall(property.getDelegate(), propertyDescriptor.getSetter(), DELEGATED_PROPERTY_RESOLVED_CALL);
            }
            super.visitProperty(property);
        }

        @Override
        public void visitThisExpression(@NotNull KtThisExpression expression) {
            ResolvedCall<? extends CallableDescriptor> resolvedCall = CallUtilKt.getResolvedCall(expression, bindingContext);
            if (resolvedCall != null) {
                reportIfDynamic(expression, resolvedCall.getResultingDescriptor(), debugInfoReporter);
            }
            super.visitThisExpression(expression);
        }

        @Override
        public void visitReferenceExpression(@NotNull KtReferenceExpression expression) {
            super.visitReferenceExpression(expression);
            if (!BindingContextUtils.isExpressionWithValidReference(expression, bindingContext)) {
                return;
            }
            IElementType referencedNameElementType = null;
            if (expression instanceof KtSimpleNameExpression) {
                KtSimpleNameExpression nameExpression = (KtSimpleNameExpression) expression;
                IElementType elementType = expression.getNode().getElementType();
                if (elementType == KtNodeTypes.OPERATION_REFERENCE) {
                    referencedNameElementType = nameExpression.getReferencedNameElementType();
                    if (EXCLUDED.contains(referencedNameElementType)) {
                        return;
                    }
                }
                if (elementType == KtNodeTypes.LABEL || nameExpression.getReferencedNameElementType() == KtTokens.THIS_KEYWORD) {
                    return;
                }
            }
            debugInfoReporter.preProcessReference(expression);
            String target = null;
            DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, expression);
            if (declarationDescriptor != null) {
                target = declarationDescriptor.toString();
                reportIfDynamic(expression, declarationDescriptor, debugInfoReporter);
            }
            if (target == null) {
                PsiElement labelTarget = bindingContext.get(LABEL_TARGET, expression);
                if (labelTarget != null) {
                    target = labelTarget.getText();
                }
            }
            if (target == null) {
                Collection<? extends DeclarationDescriptor> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, expression);
                if (declarationDescriptors != null) {
                    target = "[" + declarationDescriptors.size() + " descriptors]";
                }
            }
            if (target == null) {
                Collection<? extends PsiElement> labelTargets = bindingContext.get(AMBIGUOUS_LABEL_TARGET, expression);
                if (labelTargets != null) {
                    target = "[" + labelTargets.size() + " elements]";
                }
            }
            if (MAY_BE_UNRESOLVED.contains(referencedNameElementType)) {
                return;
            }
            boolean resolved = target != null;
            boolean markedWithError = markedWithErrorElements.containsKey(expression);
            if (expression instanceof KtArrayAccessExpression && markedWithErrorElements.containsKey(((KtArrayAccessExpression) expression).getArrayExpression())) {
                // if 'foo' in 'foo[i]' is unresolved it means 'foo[i]' is unresolved (otherwise 'foo[i]' is marked as 'missing unresolved')
                markedWithError = true;
            }
            KotlinType expressionType = bindingContext.getType(expression);
            DiagnosticFactory<?> factory = markedWithErrorElements.get(expression);
            if (declarationDescriptor != null && (ErrorUtils.isError(declarationDescriptor) || ErrorUtils.containsErrorType(expressionType))) {
                if (factory != Errors.EXPRESSION_EXPECTED_PACKAGE_FOUND) {
                    debugInfoReporter.reportElementWithErrorType(expression);
                }
            }
            if (resolved && markedWithError) {
                if (Errors.UNRESOLVED_REFERENCE_DIAGNOSTICS.contains(factory)) {
                    debugInfoReporter.reportUnresolvedWithTarget(expression, target);
                }
            } else if (!resolved && !markedWithError) {
                debugInfoReporter.reportMissingUnresolved(expression);
            }
        }

        private <E extends KtElement, K, D extends CallableDescriptor> boolean reportIfDynamicCall(E element, K key, WritableSlice<K, ResolvedCall<D>> slice) {
            ResolvedCall<D> resolvedCall = bindingContext.get(slice, key);
            if (resolvedCall != null) {
                return reportIfDynamic(element, resolvedCall.getResultingDescriptor(), debugInfoReporter);
            }
            return false;
        }
    });
}

Example 7 with ResolvedCall

use of org.jetbrains.kotlin.resolve.calls.model.ResolvedCall in project kotlin by JetBrains.

the class BodyResolver method resolveSuperTypeEntryList.

public void resolveSuperTypeEntryList(@NotNull final DataFlowInfo outerDataFlowInfo, @NotNull KtClassOrObject ktClass, @NotNull final ClassDescriptor descriptor, @Nullable final ConstructorDescriptor primaryConstructor, @NotNull LexicalScope scopeForConstructorResolution, @NotNull final LexicalScope scopeForMemberResolution) {
    final LexicalScope scopeForConstructor = primaryConstructor == null ? null : FunctionDescriptorUtil.getFunctionInnerScope(scopeForConstructorResolution, primaryConstructor, trace, overloadChecker);
    // TODO : flow
    final ExpressionTypingServices typeInferrer = expressionTypingServices;
    final Map<KtTypeReference, KotlinType> supertypes = Maps.newLinkedHashMap();
    final ResolvedCall<?>[] primaryConstructorDelegationCall = new ResolvedCall[1];
    KtVisitorVoid visitor = new KtVisitorVoid() {

        private void recordSupertype(KtTypeReference typeReference, KotlinType supertype) {
            if (supertype == null)
                return;
            supertypes.put(typeReference, supertype);
        }

        @Override
        public void visitDelegatedSuperTypeEntry(@NotNull KtDelegatedSuperTypeEntry specifier) {
            if (descriptor.getKind() == ClassKind.INTERFACE) {
                trace.report(DELEGATION_IN_INTERFACE.on(specifier));
            }
            KotlinType supertype = trace.getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference());
            recordSupertype(specifier.getTypeReference(), supertype);
            if (supertype != null) {
                DeclarationDescriptor declarationDescriptor = supertype.getConstructor().getDeclarationDescriptor();
                if (declarationDescriptor instanceof ClassDescriptor) {
                    ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor;
                    if (classDescriptor.getKind() != ClassKind.INTERFACE) {
                        trace.report(DELEGATION_NOT_TO_INTERFACE.on(specifier.getTypeReference()));
                    }
                }
            }
            KtExpression delegateExpression = specifier.getDelegateExpression();
            if (delegateExpression != null) {
                LexicalScope scope = scopeForConstructor == null ? scopeForMemberResolution : scopeForConstructor;
                KotlinType expectedType = supertype != null ? supertype : NO_EXPECTED_TYPE;
                typeInferrer.getType(scope, delegateExpression, expectedType, outerDataFlowInfo, trace);
            }
            if (primaryConstructor == null) {
                trace.report(UNSUPPORTED.on(specifier, "Delegation without primary constructor is not supported"));
            }
        }

        @Override
        public void visitSuperTypeCallEntry(@NotNull KtSuperTypeCallEntry call) {
            KtValueArgumentList valueArgumentList = call.getValueArgumentList();
            PsiElement elementToMark = valueArgumentList == null ? call : valueArgumentList;
            if (descriptor.getKind() == ClassKind.INTERFACE) {
                trace.report(SUPERTYPE_INITIALIZED_IN_INTERFACE.on(elementToMark));
            }
            KtTypeReference typeReference = call.getTypeReference();
            if (typeReference == null)
                return;
            if (primaryConstructor == null) {
                if (descriptor.getKind() != ClassKind.INTERFACE) {
                    trace.report(SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR.on(call));
                }
                recordSupertype(typeReference, trace.getBindingContext().get(BindingContext.TYPE, typeReference));
                return;
            }
            OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveFunctionCall(trace, scopeForConstructor, CallMaker.makeConstructorCallWithoutTypeArguments(call), NO_EXPECTED_TYPE, outerDataFlowInfo, false);
            if (results.isSuccess()) {
                KotlinType supertype = results.getResultingDescriptor().getReturnType();
                recordSupertype(typeReference, supertype);
                ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype);
                if (classDescriptor != null) {
                    // allow only one delegating constructor
                    if (primaryConstructorDelegationCall[0] == null) {
                        primaryConstructorDelegationCall[0] = results.getResultingCall();
                    } else {
                        primaryConstructorDelegationCall[0] = null;
                    }
                }
                // Recording type info for callee to use later in JetObjectLiteralExpression
                trace.record(PROCESSED, call.getCalleeExpression(), true);
                trace.record(EXPRESSION_TYPE_INFO, call.getCalleeExpression(), TypeInfoFactoryKt.noTypeInfo(results.getResultingCall().getDataFlowInfoForArguments().getResultInfo()));
            } else {
                recordSupertype(typeReference, trace.getBindingContext().get(BindingContext.TYPE, typeReference));
            }
        }

        @Override
        public void visitSuperTypeEntry(@NotNull KtSuperTypeEntry specifier) {
            KtTypeReference typeReference = specifier.getTypeReference();
            KotlinType supertype = trace.getBindingContext().get(BindingContext.TYPE, typeReference);
            recordSupertype(typeReference, supertype);
            if (supertype == null)
                return;
            ClassDescriptor superClass = TypeUtils.getClassDescriptor(supertype);
            if (superClass == null)
                return;
            if (superClass.getKind().isSingleton()) {
                // A "singleton in supertype" diagnostic will be reported later
                return;
            }
            if (descriptor.getKind() != ClassKind.INTERFACE && descriptor.getUnsubstitutedPrimaryConstructor() != null && superClass.getKind() != ClassKind.INTERFACE && !superClass.getConstructors().isEmpty() && !descriptor.isHeader() && !DescriptorUtils.isEffectivelyExternal(descriptor) && !ErrorUtils.isError(superClass)) {
                trace.report(SUPERTYPE_NOT_INITIALIZED.on(specifier));
            }
        }

        @Override
        public void visitKtElement(@NotNull KtElement element) {
            throw new UnsupportedOperationException(element.getText() + " : " + element);
        }
    };
    if (ktClass instanceof KtEnumEntry && DescriptorUtils.isEnumEntry(descriptor) && ktClass.getSuperTypeListEntries().isEmpty()) {
        assert scopeForConstructor != null : "Scope for enum class constructor should be non-null: " + descriptor;
        resolveConstructorCallForEnumEntryWithoutInitializer((KtEnumEntry) ktClass, descriptor, scopeForConstructor, outerDataFlowInfo);
    }
    for (KtSuperTypeListEntry delegationSpecifier : ktClass.getSuperTypeListEntries()) {
        delegationSpecifier.accept(visitor);
    }
    if (DescriptorUtils.isAnnotationClass(descriptor) && ktClass.getSuperTypeList() != null) {
        trace.report(SUPERTYPES_FOR_ANNOTATION_CLASS.on(ktClass.getSuperTypeList()));
    }
    if (primaryConstructorDelegationCall[0] != null && primaryConstructor != null) {
        recordConstructorDelegationCall(trace, primaryConstructor, primaryConstructorDelegationCall[0]);
    }
    checkSupertypeList(descriptor, supertypes, ktClass);
}

Example 8 with ResolvedCall

use of org.jetbrains.kotlin.resolve.calls.model.ResolvedCall in project kotlin by JetBrains.

the class PseudocodeUtil method isThisOrNoDispatchReceiver.

// When deal with constructed object (not this) treat it like it's fully initialized
// Otherwise (this or access with empty receiver) access instruction should be handled as usual
public static boolean isThisOrNoDispatchReceiver(@NotNull AccessValueInstruction instruction, @NotNull BindingContext bindingContext) {
    if (instruction.getReceiverValues().isEmpty()) {
        return true;
    }
    AccessTarget accessTarget = instruction.getTarget();
    if (accessTarget instanceof AccessTarget.BlackBox)
        return false;
    assert accessTarget instanceof AccessTarget.Call : "AccessTarget.Declaration has no receivers and it's not BlackBox, so it should be Call";
    ResolvedCall<?> accessResolvedCall = ((AccessTarget.Call) accessTarget).getResolvedCall();
    return ResolvedCallUtilKt.hasThisOrNoDispatchReceiver(accessResolvedCall, bindingContext);
}

Example 9 with ResolvedCall

use of org.jetbrains.kotlin.resolve.calls.model.ResolvedCall in project kotlin by JetBrains.

the class KtInvokeFunctionReference method getTargetDescriptors.

@Override
@NotNull
protected Collection<DeclarationDescriptor> getTargetDescriptors(@NotNull BindingContext context) {
    Call call = CallUtilKt.getCall(getElement(), context);
    ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(call, context);
    if (resolvedCall instanceof VariableAsFunctionResolvedCall) {
        return Collections.<DeclarationDescriptor>singleton(((VariableAsFunctionResolvedCall) resolvedCall).getFunctionCall().getCandidateDescriptor());
    }
    if (call != null && resolvedCall != null && call.getCallType() == Call.CallType.INVOKE) {
        return Collections.<DeclarationDescriptor>singleton(resolvedCall.getCandidateDescriptor());
    }
    return Collections.emptyList();
}

Example 10 with ResolvedCall

use of org.jetbrains.kotlin.resolve.calls.model.ResolvedCall in project kotlin by JetBrains.

the class BasicExpressionTypingVisitor method visitElvisExpression.

@NotNull
private KotlinTypeInfo visitElvisExpression(@NotNull KtBinaryExpression expression, @NotNull ExpressionTypingContext contextWithExpectedType) {
    ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
    KtExpression left = expression.getLeft();
    KtExpression right = expression.getRight();
    if (left == null || right == null) {
        getTypeInfoOrNullType(left, context, facade);
        return TypeInfoFactoryKt.noTypeInfo(context);
    }
    Call call = createCallForSpecialConstruction(expression, expression.getOperationReference(), Lists.newArrayList(left, right));
    ResolvedCall<FunctionDescriptor> resolvedCall = components.controlStructureTypingUtils.resolveSpecialConstructionAsCall(call, ResolveConstruct.ELVIS, Lists.newArrayList("left", "right"), Lists.newArrayList(true, false), contextWithExpectedType, null);
    KotlinTypeInfo leftTypeInfo = BindingContextUtils.getRecordedTypeInfo(left, context.trace.getBindingContext());
    if (ArgumentTypeResolver.isFunctionLiteralArgument(left, context)) {
        context.trace.report(USELESS_ELVIS_ON_LAMBDA_EXPRESSION.on(expression.getOperationReference()));
        if (leftTypeInfo == null)
            return TypeInfoFactoryKt.noTypeInfo(context);
    }
    assert leftTypeInfo != null : "Left expression was not processed: " + expression;
    KotlinType leftType = leftTypeInfo.getType();
    if (leftType != null && isKnownToBeNotNull(left, leftType, context)) {
        context.trace.report(USELESS_ELVIS.on(expression, leftType));
    } else if (KtPsiUtil.isNullConstant(right) && leftType != null && !FlexibleTypesKt.isNullabilityFlexible(leftType)) {
        context.trace.report(USELESS_ELVIS_RIGHT_IS_NULL.on(expression));
    }
    KotlinTypeInfo rightTypeInfo = BindingContextUtils.getRecordedTypeInfo(right, context.trace.getBindingContext());
    if (rightTypeInfo == null && ArgumentTypeResolver.isFunctionLiteralArgument(right, context)) {
        // the type is computed later in call completer according to the '?:' semantics as a function
        return TypeInfoFactoryKt.noTypeInfo(context);
    }
    assert rightTypeInfo != null : "Right expression was not processed: " + expression;
    boolean loopBreakContinuePossible = leftTypeInfo.getJumpOutPossible() || rightTypeInfo.getJumpOutPossible();
    KotlinType rightType = rightTypeInfo.getType();
    // Only left argument DFA is taken into account here: we cannot be sure that right argument is joined
    // (we merge it with right DFA if right argument contains no jump outside)
    DataFlowInfo dataFlowInfo = resolvedCall.getDataFlowInfoForArguments().getInfo(call.getValueArguments().get(1));
    KotlinType type = resolvedCall.getResultingDescriptor().getReturnType();
    if (type == null || rightType == null || leftType == null && KotlinBuiltIns.isNothing(rightType))
        return TypeInfoFactoryKt.noTypeInfo(dataFlowInfo);
    if (leftType != null) {
        DataFlowValue leftValue = createDataFlowValue(left, leftType, context);
        DataFlowInfo rightDataFlowInfo = resolvedCall.getDataFlowInfoForArguments().getResultInfo();
        boolean jumpInRight = KotlinBuiltIns.isNothing(rightType);
        DataFlowValue nullValue = DataFlowValue.nullValue(components.builtIns);
        // left argument is considered not-null if it's not-null also in right part or if we have jump in right part
        if (jumpInRight || !rightDataFlowInfo.getStableNullability(leftValue).canBeNull()) {
            dataFlowInfo = dataFlowInfo.disequate(leftValue, nullValue, components.languageVersionSettings);
            if (left instanceof KtBinaryExpressionWithTypeRHS) {
                dataFlowInfo = establishSubtypingForTypeRHS((KtBinaryExpressionWithTypeRHS) left, dataFlowInfo, context, components.languageVersionSettings);
            }
        }
        DataFlowValue resultValue = DataFlowValueFactory.createDataFlowValue(expression, type, context);
        dataFlowInfo = dataFlowInfo.assign(resultValue, leftValue, components.languageVersionSettings).disequate(resultValue, nullValue, components.languageVersionSettings);
        if (!jumpInRight) {
            DataFlowValue rightValue = DataFlowValueFactory.createDataFlowValue(right, rightType, context);
            rightDataFlowInfo = rightDataFlowInfo.assign(resultValue, rightValue, components.languageVersionSettings);
            dataFlowInfo = dataFlowInfo.or(rightDataFlowInfo);
        }
    }
    // but result is not nullable if the right type is not nullable
    if (!TypeUtils.isNullableType(rightType) && TypeUtils.isNullableType(type)) {
        type = TypeUtils.makeNotNullable(type);
    }
    if (context.contextDependency == DEPENDENT) {
        return TypeInfoFactoryKt.createTypeInfo(type, dataFlowInfo);
    }
    // If break or continue was possible, take condition check info as the jump info
    return TypeInfoFactoryKt.createTypeInfo(components.dataFlowAnalyzer.checkType(type, expression, contextWithExpectedType), dataFlowInfo, loopBreakContinuePossible, context.dataFlowInfo);
}