private static boolean isInsideCall(JetExpression expression) { JetElement parent = JetPsiUtil.getParentCallIfPresent(expression); if (parent instanceof JetBinaryExpression) { JetToken token = JetPsiUtil.getOperationToken((JetOperationExpression) parent); if (token == JetTokens.EQ || token == JetTokens.ANDAND || token == JetTokens.OROR) { // assignment return false; } } return parent != null; }
/*lambda or callable reference*/ public static boolean isInliningParameter( JetExpression expression, ValueParameterDescriptor valueParameterDescriptor) { // TODO deparenthisise typed JetExpression deparenthesized = JetPsiUtil.deparenthesize(expression); return InlineUtil.isInlineLambdaParameter(valueParameterDescriptor) && isInlinableParameterExpression(deparenthesized); }
public void rememberClosure(JetExpression expression, Type type) { JetExpression lambda = JetPsiUtil.deparenthesize(expression); assert isInlinableParameterExpression(lambda) : "Couldn't find inline expression in " + expression.getText(); LambdaInfo info = new LambdaInfo(lambda, typeMapper); ParameterInfo closureInfo = invocationParamBuilder.addNextParameter(type, true, null); closureInfo.setLambda(info); expressionMap.put(closureInfo.getIndex(), info); }
@NotNull public Collection<DeclarationDescriptor> lookupDescriptorsForQualifiedExpression( @NotNull JetQualifiedExpression importedReference, @NotNull JetScope outerScope, @NotNull JetScope scopeToCheckVisibility, @NotNull BindingTrace trace, @NotNull LookupMode lookupMode, boolean storeResult) { JetExpression receiverExpression = importedReference.getReceiverExpression(); Collection<DeclarationDescriptor> declarationDescriptors; if (receiverExpression instanceof JetQualifiedExpression) { declarationDescriptors = lookupDescriptorsForQualifiedExpression( (JetQualifiedExpression) receiverExpression, outerScope, scopeToCheckVisibility, trace, lookupMode, storeResult); } else { assert receiverExpression instanceof JetSimpleNameExpression; declarationDescriptors = lookupDescriptorsForSimpleNameReference( (JetSimpleNameExpression) receiverExpression, outerScope, scopeToCheckVisibility, trace, lookupMode, true, storeResult); } JetExpression selectorExpression = importedReference.getSelectorExpression(); if (!(selectorExpression instanceof JetSimpleNameExpression)) { return Collections.emptyList(); } JetSimpleNameExpression selector = (JetSimpleNameExpression) selectorExpression; JetSimpleNameExpression lastReference = JetPsiUtil.getLastReference(receiverExpression); if (lastReference == null || !canImportMembersFrom(declarationDescriptors, lastReference, trace, lookupMode)) { return Collections.emptyList(); } return lookupSelectorDescriptors( selector, declarationDescriptors, trace, scopeToCheckVisibility, lookupMode, storeResult); }
@NotNull public Collection<DeclarationDescriptor> processImportReference( @NotNull JetImportDirective importDirective, @NotNull JetScope scope, @NotNull JetScope scopeToCheckVisibility, @Nullable Importer importer, @NotNull BindingTrace trace, @NotNull LookupMode lookupMode) { if (importDirective.isAbsoluteInRootPackage()) { trace.report(UNSUPPORTED.on(importDirective, "TypeHierarchyResolver")); // TODO return Collections.emptyList(); } JetExpression importedReference = importDirective.getImportedReference(); if (importedReference == null) { return Collections.emptyList(); } Collection<DeclarationDescriptor> descriptors; if (importedReference instanceof JetQualifiedExpression) { // store result only when we find all descriptors, not only classes on the second phase descriptors = lookupDescriptorsForQualifiedExpression( (JetQualifiedExpression) importedReference, scope, scopeToCheckVisibility, trace, lookupMode, lookupMode == LookupMode.EVERYTHING); } else { assert importedReference instanceof JetSimpleNameExpression; descriptors = lookupDescriptorsForSimpleNameReference( (JetSimpleNameExpression) importedReference, scope, scopeToCheckVisibility, trace, lookupMode, true, lookupMode == LookupMode.EVERYTHING); } JetSimpleNameExpression referenceExpression = JetPsiUtil.getLastReference(importedReference); if (importDirective.isAllUnder()) { if (!canAllUnderImportFrom(descriptors) && referenceExpression != null) { ClassDescriptor toReportOn = KotlinPackage.filterIsInstance(descriptors, ClassDescriptor.class).iterator().next(); trace.report(CANNOT_IMPORT_ON_DEMAND_FROM_SINGLETON.on(referenceExpression, toReportOn)); } if (referenceExpression == null || !canImportMembersFrom(descriptors, referenceExpression, trace, lookupMode)) { return Collections.emptyList(); } if (importer != null) { for (DeclarationDescriptor descriptor : descriptors) { importer.addAllUnderImport(descriptor); } } return Collections.emptyList(); } Name aliasName = JetPsiUtil.getAliasName(importDirective); if (aliasName == null) { return Collections.emptyList(); } if (importer != null) { for (DeclarationDescriptor descriptor : descriptors) { importer.addAliasImport(descriptor, aliasName); } } return descriptors; }
@Override public boolean processUsage(JetChangeInfo changeInfo, PsiElement element) { JetParameterList parameterList; JetPsiFactory psiFactory = JetPsiFactory(element.getProject()); if (element instanceof JetFunction) { JetFunction function = (JetFunction) element; parameterList = function.getValueParameterList(); if (changeInfo.isNameChanged()) { PsiElement identifier = function.getNameIdentifier(); if (identifier != null) { identifier.replace(psiFactory.createIdentifier(changeInfo.getNewName())); } } boolean returnTypeIsNeeded = (changeInfo.isRefactoringTarget(originalFunctionDescriptor) || !(function instanceof JetFunctionLiteral) || function.getTypeReference() != null) && !(function instanceof JetSecondaryConstructor); if (changeInfo.isReturnTypeChanged() && returnTypeIsNeeded) { function.setTypeReference(null); String returnTypeText = changeInfo.renderReturnType((JetFunctionDefinitionUsage<PsiElement>) this); // TODO use ChangeFunctionReturnTypeFix.invoke when JetTypeCodeFragment.getType() is ready if (!KotlinBuiltIns.getInstance().getUnitType().toString().equals(returnTypeText)) { ShortenPackage.addToShorteningWaitSet( function.setTypeReference(JetPsiFactory(function).createType(returnTypeText)), Options.DEFAULT); } } } else { parameterList = ((JetClass) element).getPrimaryConstructorParameterList(); } if (changeInfo.isParameterSetOrOrderChanged()) { processParameterListWithStructuralChanges(changeInfo, element, parameterList, psiFactory); } else if (parameterList != null) { int paramIndex = 0; for (JetParameter parameter : parameterList.getParameters()) { JetParameterInfo parameterInfo = changeInfo.getNewParameters()[paramIndex]; changeParameter(paramIndex, parameter, parameterInfo); paramIndex++; } ShortenPackage.addToShorteningWaitSet(parameterList, Options.DEFAULT); } if (element instanceof JetFunction && changeInfo.isReceiverTypeChanged()) { //noinspection unchecked String receiverTypeText = changeInfo.renderReceiverType((JetFunctionDefinitionUsage<PsiElement>) this); JetTypeReference receiverTypeRef = receiverTypeText != null ? psiFactory.createType(receiverTypeText) : null; JetTypeReference newReceiverTypeRef = TypeRefHelpersPackage.setReceiverTypeReference((JetFunction) element, receiverTypeRef); if (newReceiverTypeRef != null) { ShortenPackage.addToShorteningWaitSet( newReceiverTypeRef, ShortenReferences.Options.DEFAULT); } } if (changeInfo.isVisibilityChanged() && !JetPsiUtil.isLocal((JetDeclaration) element)) { changeVisibility(changeInfo, element); } return true; }