public void resolveFunctionBody(
@NotNull DataFlowInfo outerDataFlowInfo,
@NotNull BindingTrace trace,
@NotNull JetDeclarationWithBody function,
@NotNull FunctionDescriptor functionDescriptor,
@NotNull LexicalScope declaringScope) {
computeDeferredType(functionDescriptor.getReturnType());
resolveFunctionBody(
outerDataFlowInfo,
trace,
function,
functionDescriptor,
declaringScope,
null,
CallChecker.DoNothing.INSTANCE$);
assert functionDescriptor.getReturnType() != null;
}
public InlineChecker(@NotNull FunctionDescriptor descriptor) {
assert InlineUtil.isInline(descriptor)
: "This extension should be created only for inline functions: " + descriptor;
this.descriptor = descriptor;
this.isEffectivelyPublicApiFunction = DescriptorUtilsKt.isEffectivelyPublicApi(descriptor);
this.isEffectivelyPrivateApiFunction = DescriptorUtilsKt.isEffectivelyPrivateApi(descriptor);
for (ValueParameterDescriptor param : descriptor.getValueParameters()) {
if (isInlinableParameter(param)) {
inlinableParameters.add(param);
}
}
}
@NotNull
private static KotlinType getFunctionExpectedReturnType(
@NotNull FunctionDescriptor descriptor,
@NotNull KtElement function,
@NotNull ExpressionTypingContext context) {
KotlinType expectedType;
if (function instanceof KtSecondaryConstructor) {
expectedType = DescriptorUtilsKt.getBuiltIns(descriptor).getUnitType();
} else if (function instanceof KtFunction) {
KtFunction ktFunction = (KtFunction) function;
expectedType = context.trace.get(EXPECTED_RETURN_TYPE, ktFunction);
if ((expectedType == null)
&& (ktFunction.getTypeReference() != null || ktFunction.hasBlockBody())) {
expectedType = descriptor.getReturnType();
}
} else {
expectedType = descriptor.getReturnType();
}
return expectedType != null ? expectedType : TypeUtils.NO_EXPECTED_TYPE;
}
@Override
public void updateUI(
Pair<? extends FunctionDescriptor, ResolutionFacade> itemToShow,
@NotNull ParameterInfoUIContext context) {
// todo: when we will have ability to pass Array as vararg, implement such feature here too?
if (context == null
|| context.getParameterOwner() == null
|| !context.getParameterOwner().isValid()) {
context.setUIComponentEnabled(false);
return;
}
PsiElement parameterOwner = context.getParameterOwner();
if (!(parameterOwner instanceof JetValueArgumentList)) {
context.setUIComponentEnabled(false);
return;
}
JetValueArgumentList argumentList = (JetValueArgumentList) parameterOwner;
FunctionDescriptor functionDescriptor = itemToShow.first;
ResolutionFacade resolutionFacade = itemToShow.second;
List<ValueParameterDescriptor> valueParameters = functionDescriptor.getValueParameters();
List<JetValueArgument> valueArguments = argumentList.getArguments();
int currentParameterIndex = context.getCurrentParameterIndex();
int boldStartOffset = -1;
int boldEndOffset = -1;
boolean isGrey = false;
boolean isDeprecated = KotlinBuiltIns.isDeprecated(functionDescriptor);
boolean[] usedIndexes = new boolean[valueParameters.size()];
Arrays.fill(usedIndexes, false);
boolean namedMode = false;
if (!isIndexValid(valueParameters, currentParameterIndex)) {
isGrey = true;
}
StringBuilder builder = new StringBuilder();
PsiElement owner = context.getParameterOwner();
BindingContext bindingContext =
resolutionFacade.analyze((JetElement) owner, BodyResolveMode.FULL);
for (int i = 0; i < valueParameters.size(); ++i) {
if (i != 0) {
builder.append(", ");
}
boolean highlightParameter =
i == currentParameterIndex
|| (!namedMode
&& i < currentParameterIndex
&& Iterables.getLast(valueParameters).getVarargElementType() != null);
if (highlightParameter) {
boldStartOffset = builder.length();
}
if (!namedMode) {
if (valueArguments.size() > i) {
JetValueArgument argument = valueArguments.get(i);
if (argument.isNamed()) {
namedMode = true;
} else {
ValueParameterDescriptor param = valueParameters.get(i);
builder.append(renderParameter(param, false));
if (i <= currentParameterIndex
&& !isArgumentTypeValid(bindingContext, argument, param)) {
isGrey = true;
}
usedIndexes[i] = true;
}
} else {
ValueParameterDescriptor param = valueParameters.get(i);
builder.append(renderParameter(param, false));
}
}
if (namedMode) {
boolean takeAnyArgument = true;
if (valueArguments.size() > i) {
JetValueArgument argument = valueArguments.get(i);
if (argument.isNamed()) {
for (int j = 0; j < valueParameters.size(); ++j) {
JetSimpleNameExpression referenceExpression =
argument.getArgumentName().getReferenceExpression();
ValueParameterDescriptor param = valueParameters.get(j);
if (referenceExpression != null
&& !usedIndexes[j]
&& param.getName().equals(referenceExpression.getReferencedNameAsName())) {
takeAnyArgument = false;
usedIndexes[j] = true;
builder.append(renderParameter(param, true));
if (i < currentParameterIndex
&& !isArgumentTypeValid(bindingContext, argument, param)) {
isGrey = true;
}
break;
}
}
}
}
if (takeAnyArgument) {
if (i < currentParameterIndex) {
isGrey = true;
}
for (int j = 0; j < valueParameters.size(); ++j) {
ValueParameterDescriptor param = valueParameters.get(j);
if (!usedIndexes[j]) {
usedIndexes[j] = true;
builder.append(renderParameter(param, true));
break;
}
}
}
}
if (highlightParameter) {
boldEndOffset = builder.length();
}
}
if (valueParameters.size() == 0) {
builder.append(CodeInsightBundle.message("parameter.info.no.parameters"));
}
assert !builder.toString().isEmpty()
: "A message about 'no parameters' or some parameters should be present: "
+ functionDescriptor;
Color color =
isResolvedToDescriptor(argumentList, functionDescriptor, bindingContext)
? GREEN_BACKGROUND
: context.getDefaultParameterColor();
context.setupUIComponentPresentation(
builder.toString(), boldStartOffset, boldEndOffset, isGrey, isDeprecated, false, color);
}
public void resolveFunctionBody(
@NotNull DataFlowInfo outerDataFlowInfo,
@NotNull BindingTrace trace,
@NotNull JetDeclarationWithBody function,
@NotNull FunctionDescriptor functionDescriptor,
@NotNull LexicalScope scope,
@Nullable Function1<LexicalScope, DataFlowInfo> beforeBlockBody,
@NotNull CallChecker callChecker) {
LexicalScope innerScope =
FunctionDescriptorUtil.getFunctionInnerScope(scope, functionDescriptor, trace);
List<JetParameter> valueParameters = function.getValueParameters();
List<ValueParameterDescriptor> valueParameterDescriptors =
functionDescriptor.getValueParameters();
valueParameterResolver.resolveValueParameters(
valueParameters,
valueParameterDescriptors,
ExpressionTypingContext.newContext(
trace, innerScope, outerDataFlowInfo, NO_EXPECTED_TYPE, callChecker));
// Synthetic "field" creation
if (functionDescriptor instanceof PropertyAccessorDescriptor) {
PropertyAccessorDescriptor accessorDescriptor =
(PropertyAccessorDescriptor) functionDescriptor;
JetProperty property = (JetProperty) function.getParent();
final SyntheticFieldDescriptor fieldDescriptor =
new SyntheticFieldDescriptor(accessorDescriptor, property);
innerScope =
new LexicalScopeImpl(
innerScope,
functionDescriptor,
true,
functionDescriptor.getExtensionReceiverParameter(),
"Accessor inner scope with synthetic field",
RedeclarationHandler.DO_NOTHING,
new Function1<LexicalScopeImpl.InitializeHandler, Unit>() {
@Override
public Unit invoke(LexicalScopeImpl.InitializeHandler handler) {
handler.addVariableOrClassDescriptor(fieldDescriptor);
return Unit.INSTANCE$;
}
});
// Check parameter name shadowing
for (JetParameter parameter : function.getValueParameters()) {
if (SyntheticFieldDescriptor.NAME.equals(parameter.getNameAsName())) {
trace.report(Errors.ACCESSOR_PARAMETER_NAME_SHADOWING.on(parameter));
}
}
}
DataFlowInfo dataFlowInfo = null;
if (beforeBlockBody != null) {
dataFlowInfo = beforeBlockBody.invoke(innerScope);
}
if (function.hasBody()) {
expressionTypingServices.checkFunctionReturnType(
innerScope,
function,
functionDescriptor,
dataFlowInfo != null ? dataFlowInfo : outerDataFlowInfo,
null,
trace);
}
assert functionDescriptor.getReturnType() != null;
}