@NotNull
  @Override
  public LightClassConstructionContext getContextForClassOrObject(
      @NotNull JetClassOrObject classOrObject) {
    ResolveSessionForBodies session =
        KotlinCacheService.getInstance(classOrObject.getProject())
            .getLazyResolveSession(classOrObject);

    if (classOrObject.isLocal()) {
      BindingContext bindingContext = session.resolveToElement(classOrObject, BodyResolveMode.FULL);
      ClassDescriptor descriptor = bindingContext.get(BindingContext.CLASS, classOrObject);

      if (descriptor == null) {
        LOG.warn(
            "No class descriptor in context for class: "
                + PsiUtilPackage.getElementTextWithContext(classOrObject));
        return new LightClassConstructionContext(bindingContext, session.getModuleDescriptor());
      }

      ForceResolveUtil.forceResolveAllContents(descriptor);

      return new LightClassConstructionContext(bindingContext, session.getModuleDescriptor());
    }

    ForceResolveUtil.forceResolveAllContents(session.getClassDescriptor(classOrObject));
    return new LightClassConstructionContext(
        session.getBindingContext(), session.getModuleDescriptor());
  }
  @NotNull
  private static KotlinType getPropertyType(@NotNull KtProperty property) {
    BindingContext bindingContext = ResolutionUtils.analyze(property, BodyResolveMode.PARTIAL);

    VariableDescriptor propertyDescriptor = bindingContext.get(BindingContext.VARIABLE, property);
    assert propertyDescriptor != null
        : "Couldn't resolve property to property descriptor " + property.getText();
    return propertyDescriptor.getType();
  }
  private static Map<DeclarationDescriptor, List<String>> getActualLoadErrors(
      @NotNull BindingContext bindingContext) {
    Map<DeclarationDescriptor, List<String>> result =
        new HashMap<DeclarationDescriptor, List<String>>();

    Collection<DeclarationDescriptor> descriptors =
        bindingContext.getKeys(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS);
    for (DeclarationDescriptor descriptor : descriptors) {
      List<String> errors =
          bindingContext.get(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, descriptor);
      result.put(descriptor, errors);
    }

    return result;
  }
Beispiel #4
0
  public LambdaInfo(
      @NotNull KtExpression expression,
      @NotNull KotlinTypeMapper typeMapper,
      boolean isCrossInline,
      boolean isBoundCallableReference) {
    this.isCrossInline = isCrossInline;
    this.expression =
        expression instanceof KtLambdaExpression
            ? ((KtLambdaExpression) expression).getFunctionLiteral()
            : expression;

    this.typeMapper = typeMapper;
    this.isBoundCallableReference = isBoundCallableReference;
    BindingContext bindingContext = typeMapper.getBindingContext();
    FunctionDescriptor function = bindingContext.get(BindingContext.FUNCTION, this.expression);
    if (function == null && expression instanceof KtCallableReferenceExpression) {
      VariableDescriptor variableDescriptor =
          bindingContext.get(BindingContext.VARIABLE, this.expression);
      assert variableDescriptor instanceof VariableDescriptorWithAccessors
          : "Reference expression not resolved to variable descriptor with accessors: "
              + expression.getText();
      classDescriptor =
          CodegenBinding.anonymousClassForCallable(bindingContext, variableDescriptor);
      closureClassType = typeMapper.mapClass(classDescriptor);
      SimpleFunctionDescriptor getFunction =
          PropertyReferenceCodegen.findGetFunction(variableDescriptor);
      functionDescriptor =
          PropertyReferenceCodegen.createFakeOpenDescriptor(getFunction, classDescriptor);
      ResolvedCall<?> resolvedCall =
          CallUtilKt.getResolvedCallWithAssert(
              ((KtCallableReferenceExpression) expression).getCallableReference(), bindingContext);
      propertyReferenceInfo =
          new PropertyReferenceInfo(
              (VariableDescriptor) resolvedCall.getResultingDescriptor(), getFunction);
    } else {
      propertyReferenceInfo = null;
      functionDescriptor = function;
      assert functionDescriptor != null
          : "Function is not resolved to descriptor: " + expression.getText();
      classDescriptor = anonymousClassForCallable(bindingContext, functionDescriptor);
      closureClassType = asmTypeForAnonymousClass(bindingContext, functionDescriptor);
    }

    closure = bindingContext.get(CLOSURE, classDescriptor);
    assert closure != null : "Closure for lambda should be not null " + expression.getText();

    labels = InlineCodegen.getDeclarationLabels(expression, functionDescriptor);
  }
 private void generateCopyFunctionForDataClasses(List<JetParameter> constructorParameters) {
   FunctionDescriptor copyFunction =
       bindingContext.get(BindingContext.DATA_CLASS_COPY_FUNCTION, classDescriptor);
   if (copyFunction != null) {
     generateCopyFunction(copyFunction, constructorParameters);
   }
 }
Beispiel #6
0
  public void gen(@NotNull KtNamedFunction function) {
    SimpleFunctionDescriptor functionDescriptor =
        bindingContext.get(BindingContext.FUNCTION, function);
    assert functionDescriptor != null
        : "No descriptor for function "
            + function.getText()
            + "\n"
            + "in "
            + function.getContainingFile().getVirtualFile();

    if (owner.getContextKind() != OwnerKind.DEFAULT_IMPLS || function.hasBody()) {
      generateMethod(
          JvmDeclarationOriginKt.OtherOrigin(function, functionDescriptor),
          functionDescriptor,
          new FunctionGenerationStrategy.FunctionDefault(state, functionDescriptor, function));
    }

    generateDefaultIfNeeded(
        owner.intoFunction(functionDescriptor),
        functionDescriptor,
        owner.getContextKind(),
        DefaultParameterValueLoader.DEFAULT,
        function);

    generateOverloadsWithDefaultValues(function, functionDescriptor, functionDescriptor);
  }
 private List<PropertyDescriptor> getDataProperties() {
   List<PropertyDescriptor> result = Lists.newArrayList();
   for (JetParameter parameter : getPrimaryConstructorParameters()) {
     if (parameter.hasValOrVar()) {
       result.add(bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter));
     }
   }
   return result;
 }
  private static boolean isArgumentTypeValid(
      BindingContext bindingContext, JetValueArgument argument, ValueParameterDescriptor param) {
    if (argument.getArgumentExpression() != null) {
      JetType paramType = getActualParameterType(param);
      JetType exprType = bindingContext.getType(argument.getArgumentExpression());
      return exprType == null || JetTypeChecker.DEFAULT.isSubtypeOf(exprType, paramType);
    }

    return false;
  }
  @Nullable
  private static PsiNamedElement[] getSupertypes(Expression[] params, ExpressionContext context) {
    if (params.length != 0) return null;

    Project project = context.getProject();
    PsiDocumentManager.getInstance(project).commitAllDocuments();

    PsiFile psiFile =
        PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument());
    if (!(psiFile instanceof JetFile)) return null;

    JetExpression expression =
        PsiTreeUtil.getParentOfType(
            psiFile.findElementAt(context.getStartOffset()), JetExpression.class);
    if (expression == null) return null;

    BindingContext bc = ResolutionUtils.analyze(expression, BodyResolveMode.FULL);
    JetScope scope = bc.get(BindingContext.RESOLUTION_SCOPE, expression);
    if (scope == null) return null;

    List<PsiNamedElement> result = new ArrayList<PsiNamedElement>();

    for (DeclarationDescriptor descriptor :
        scope.getDescriptors(
            DescriptorKindFilter.NON_SINGLETON_CLASSIFIERS,
            JetScope.Companion.getALL_NAME_FILTER())) {
      if (!(descriptor instanceof ClassDescriptor)) continue;
      ClassDescriptor classDescriptor = (ClassDescriptor) descriptor;
      if (!classDescriptor.getModality().isOverridable()) continue;
      ClassKind kind = classDescriptor.getKind();
      if (kind == ClassKind.INTERFACE || kind == ClassKind.CLASS) {
        PsiElement declaration = DescriptorToSourceUtils.descriptorToDeclaration(descriptor);
        if (declaration != null) {
          result.add((PsiNamedElement) declaration);
        }
      }
    }

    return result.toArray(new PsiNamedElement[result.size()]);
  }
  private void generateComponentFunctionsForDataClasses() {
    ConstructorDescriptor constructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
    // primary constructor should exist for data classes
    // but when generating light-classes still need to check we have one
    if (constructor == null) return;

    for (ValueParameterDescriptor parameter : constructor.getValueParameters()) {
      FunctionDescriptor function =
          bindingContext.get(BindingContext.DATA_CLASS_COMPONENT_FUNCTION, parameter);
      if (function != null) {
        generateComponentFunction(function, parameter);
      }
    }
  }
  public void testNoWarningsOnJavaKotlinInheritance() throws Exception {
    // This test checks that there are no PARAMETER_NAME_CHANGED_ON_OVERRIDE or
    // DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES
    // warnings when subclassing in Kotlin from Java binaries (in case when no parameter names are
    // available for Java classes)

    KotlinTestUtils.compileJavaFiles(
        Collections.singletonList(getTestDataFileWithExtension("java")),
        Arrays.asList("-d", tmpdir.getPath()));

    Project project = createEnvironment(Collections.singletonList(tmpdir)).getProject();

    AnalysisResult result =
        JvmResolveUtil.analyzeOneFileWithJavaIntegration(
            KotlinTestUtils.loadJetFile(project, getTestDataFileWithExtension("kt")));
    result.throwIfError();

    BindingContext bindingContext = result.getBindingContext();
    AnalyzerWithCompilerReport.Companion.reportDiagnostics(
        bindingContext.getDiagnostics(), PrintingMessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR);

    assertEquals(
        "There should be no diagnostics", 0, Iterables.size(bindingContext.getDiagnostics()));
  }
  private static Boolean isResolvedToDescriptor(
      JetValueArgumentList argumentList,
      FunctionDescriptor functionDescriptor,
      BindingContext bindingContext) {
    JetSimpleNameExpression callNameExpression = getCallSimpleNameExpression(argumentList);
    if (callNameExpression != null) {
      DeclarationDescriptor declarationDescriptor =
          bindingContext.get(BindingContext.REFERENCE_TARGET, callNameExpression);
      if (declarationDescriptor != null) {
        if (declarationDescriptor == functionDescriptor) {
          return true;
        }
      }
    }

    return false;
  }
Beispiel #13
0
 @NotNull
 public static List<Diagnostic> getDiagnosticsIncludingSyntaxErrors(
     @NotNull BindingContext bindingContext,
     @NotNull final PsiElement root,
     boolean markDynamicCalls,
     @Nullable List<DeclarationDescriptor> dynamicCallDescriptors) {
   List<Diagnostic> diagnostics = new ArrayList<Diagnostic>();
   diagnostics.addAll(
       Collections2.filter(
           bindingContext.getDiagnostics().all(),
           new Predicate<Diagnostic>() {
             @Override
             public boolean apply(Diagnostic diagnostic) {
               return PsiTreeUtil.isAncestor(root, diagnostic.getPsiElement(), false);
             }
           }));
   for (PsiErrorElement errorElement : AnalyzingUtils.getSyntaxErrorRanges(root)) {
     diagnostics.add(new SyntaxErrorDiagnostic(errorElement));
   }
   List<Diagnostic> debugAnnotations =
       getDebugInfoDiagnostics(root, bindingContext, markDynamicCalls, dynamicCallDescriptors);
   diagnostics.addAll(debugAnnotations);
   return diagnostics;
 }
  private static JetValueArgumentList findCall(CreateParameterInfoContext context) {
    // todo: calls to this constructors, when we will have auxiliary constructors
    PsiFile file = context.getFile();
    if (!(file instanceof JetFile)) {
      return null;
    }

    JetValueArgumentList argumentList =
        PsiTreeUtil.getParentOfType(
            file.findElementAt(context.getOffset()), JetValueArgumentList.class);
    if (argumentList == null) {
      return null;
    }

    final JetSimpleNameExpression callNameExpression = getCallSimpleNameExpression(argumentList);
    if (callNameExpression == null) {
      return null;
    }

    PsiReference[] references = callNameExpression.getReferences();
    if (references.length == 0) {
      return null;
    }

    ResolutionFacade resolutionFacade =
        ResolvePackage.getResolutionFacade(callNameExpression.getContainingJetFile());
    final BindingContext bindingContext =
        resolutionFacade.analyze(callNameExpression, BodyResolveMode.FULL);
    ModuleDescriptor moduleDescriptor = resolutionFacade.findModuleDescriptor(callNameExpression);

    JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, callNameExpression);
    final DeclarationDescriptor placeDescriptor;
    if (scope != null) {
      placeDescriptor = scope.getContainingDeclaration();
    } else {
      placeDescriptor = null;
    }
    Function1<DeclarationDescriptor, Boolean> visibilityFilter =
        new Function1<DeclarationDescriptor, Boolean>() {
          @Override
          public Boolean invoke(DeclarationDescriptor descriptor) {
            if (placeDescriptor == null) return true;
            if (!(descriptor instanceof DeclarationDescriptorWithVisibility)) return true;
            return CorePackage.isVisible(
                (DeclarationDescriptorWithVisibility) descriptor,
                placeDescriptor,
                bindingContext,
                callNameExpression);
          }
        };

    final Name refName = callNameExpression.getReferencedNameAsName();

    Function1<Name, Boolean> nameFilter =
        new Function1<Name, Boolean>() {
          @Override
          public Boolean invoke(Name name) {
            return name.equals(refName);
          }
        };
    Collection<DeclarationDescriptor> variants =
        new ReferenceVariantsHelper(
                bindingContext, moduleDescriptor, file.getProject(), visibilityFilter)
            .getReferenceVariants(
                callNameExpression,
                new DescriptorKindFilter(
                    DescriptorKindFilter.FUNCTIONS_MASK | DescriptorKindFilter.CLASSIFIERS_MASK,
                    Collections.<DescriptorKindExclude>emptyList()),
                nameFilter,
                false,
                false);

    Collection<Pair<? extends DeclarationDescriptor, ResolutionFacade>> itemsToShow =
        new ArrayList<Pair<? extends DeclarationDescriptor, ResolutionFacade>>();
    for (DeclarationDescriptor variant : variants) {
      if (variant instanceof FunctionDescriptor) {
        // todo: renamed functions?
        itemsToShow.add(Pair.create((FunctionDescriptor) variant, resolutionFacade));
      } else if (variant instanceof ClassDescriptor) {
        // todo: renamed classes?
        for (ConstructorDescriptor constructorDescriptor :
            ((ClassDescriptor) variant).getConstructors()) {
          itemsToShow.add(Pair.create(constructorDescriptor, resolutionFacade));
        }
      }
    }

    context.setItemsToShow(ArrayUtil.toObjectArray(itemsToShow));
    return argumentList;
  }
Beispiel #15
0
  @SuppressWarnings("TestOnlyProblems")
  @NotNull
  private static List<Diagnostic> getDebugInfoDiagnostics(
      @NotNull PsiElement root,
      @NotNull BindingContext bindingContext,
      final boolean markDynamicCalls,
      @Nullable final List<DeclarationDescriptor> dynamicCallDescriptors) {
    final List<Diagnostic> debugAnnotations = Lists.newArrayList();
    DebugInfoUtil.markDebugAnnotations(
        root,
        bindingContext,
        new DebugInfoUtil.DebugInfoReporter() {
          @Override
          public void reportElementWithErrorType(@NotNull KtReferenceExpression expression) {
            newDiagnostic(expression, DebugInfoDiagnosticFactory.ELEMENT_WITH_ERROR_TYPE);
          }

          @Override
          public void reportMissingUnresolved(@NotNull KtReferenceExpression expression) {
            newDiagnostic(expression, DebugInfoDiagnosticFactory.MISSING_UNRESOLVED);
          }

          @Override
          public void reportUnresolvedWithTarget(
              @NotNull KtReferenceExpression expression, @NotNull String target) {
            newDiagnostic(expression, DebugInfoDiagnosticFactory.UNRESOLVED_WITH_TARGET);
          }

          @Override
          public void reportDynamicCall(
              @NotNull KtElement element, DeclarationDescriptor declarationDescriptor) {
            if (dynamicCallDescriptors != null) {
              dynamicCallDescriptors.add(declarationDescriptor);
            }

            if (markDynamicCalls) {
              newDiagnostic(element, DebugInfoDiagnosticFactory.DYNAMIC);
            }
          }

          private void newDiagnostic(KtElement element, DebugInfoDiagnosticFactory factory) {
            debugAnnotations.add(new DebugInfoDiagnostic(element, factory));
          }
        });
    // this code is used in tests and in internal action 'copy current file as diagnostic test'
    for (KtExpression expression :
        bindingContext.getSliceContents(BindingContext.SMARTCAST).keySet()) {
      if (PsiTreeUtil.isAncestor(root, expression, false)) {
        debugAnnotations.add(
            new DebugInfoDiagnostic(expression, DebugInfoDiagnosticFactory.SMARTCAST));
      }
    }
    for (KtExpression expression :
        bindingContext.getSliceContents(BindingContext.IMPLICIT_RECEIVER_SMARTCAST).keySet()) {
      if (PsiTreeUtil.isAncestor(root, expression, false)) {
        debugAnnotations.add(
            new DebugInfoDiagnostic(
                expression, DebugInfoDiagnosticFactory.IMPLICIT_RECEIVER_SMARTCAST));
      }
    }
    for (KtExpression expression :
        bindingContext.getSliceContents(BindingContext.SMARTCAST_NULL).keySet()) {
      if (PsiTreeUtil.isAncestor(root, expression, false)) {
        debugAnnotations.add(
            new DebugInfoDiagnostic(expression, DebugInfoDiagnosticFactory.CONSTANT));
      }
    }
    for (KtExpression expression :
        bindingContext.getSliceContents(BindingContext.LEAKING_THIS).keySet()) {
      if (PsiTreeUtil.isAncestor(root, expression, false)) {
        debugAnnotations.add(
            new DebugInfoDiagnostic(expression, DebugInfoDiagnosticFactory.LEAKING_THIS));
      }
    }
    for (KtWhenExpression expression :
        bindingContext.getSliceContents(BindingContext.IMPLICIT_EXHAUSTIVE_WHEN).keySet()) {
      if (PsiTreeUtil.isAncestor(root, expression, false)) {
        debugAnnotations.add(
            new DebugInfoDiagnostic(expression, DebugInfoDiagnosticFactory.IMPLICIT_EXHAUSTIVE));
      }
    }
    return debugAnnotations;
  }
  @NotNull
  @Override
  protected List<IntentionAction> doCreateActions(@NotNull Diagnostic diagnostic) {
    List<IntentionAction> actions = new LinkedList<IntentionAction>();

    BindingContext context = ResolutionUtils.analyzeFully((JetFile) diagnostic.getPsiFile());

    PsiElement diagnosticElement = diagnostic.getPsiElement();
    if (!(diagnosticElement instanceof JetExpression)) {
      LOG.error("Unexpected element: " + diagnosticElement.getText());
      return Collections.emptyList();
    }

    JetExpression expression = (JetExpression) diagnosticElement;

    JetType expectedType;
    JetType expressionType;
    if (diagnostic.getFactory() == Errors.TYPE_MISMATCH) {
      DiagnosticWithParameters2<JetExpression, JetType, JetType> diagnosticWithParameters =
          Errors.TYPE_MISMATCH.cast(diagnostic);
      expectedType = diagnosticWithParameters.getA();
      expressionType = diagnosticWithParameters.getB();
    } else if (diagnostic.getFactory() == Errors.NULL_FOR_NONNULL_TYPE) {
      DiagnosticWithParameters1<JetConstantExpression, JetType> diagnosticWithParameters =
          Errors.NULL_FOR_NONNULL_TYPE.cast(diagnostic);
      expectedType = diagnosticWithParameters.getA();
      expressionType = TypeUtilsKt.makeNullable(expectedType);
    } else if (diagnostic.getFactory() == Errors.CONSTANT_EXPECTED_TYPE_MISMATCH) {
      DiagnosticWithParameters2<JetConstantExpression, String, JetType> diagnosticWithParameters =
          Errors.CONSTANT_EXPECTED_TYPE_MISMATCH.cast(diagnostic);
      expectedType = diagnosticWithParameters.getB();
      expressionType = context.getType(expression);
      if (expressionType == null) {
        LOG.error("No type inferred: " + expression.getText());
        return Collections.emptyList();
      }
    } else {
      LOG.error("Unexpected diagnostic: " + DefaultErrorMessages.render(diagnostic));
      return Collections.emptyList();
    }

    // We don't want to cast a cast or type-asserted expression:
    if (!(expression instanceof JetBinaryExpressionWithTypeRHS)
        && !(expression.getParent() instanceof JetBinaryExpressionWithTypeRHS)) {
      actions.add(new CastExpressionFix(expression, expectedType));
    }

    // Property initializer type mismatch property type:
    JetProperty property = PsiTreeUtil.getParentOfType(expression, JetProperty.class);
    if (property != null) {
      JetPropertyAccessor getter = property.getGetter();
      JetExpression initializer = property.getInitializer();
      if (QuickFixUtil.canEvaluateTo(initializer, expression)
          || (getter != null
              && QuickFixUtil.canFunctionOrGetterReturnExpression(
                  property.getGetter(), expression))) {
        LexicalScope scope =
            CorePackage.getResolutionScope(
                property, context, ResolutionUtils.getResolutionFacade(property));
        JetType typeToInsert =
            TypeUtils.approximateWithResolvableType(expressionType, scope, false);
        actions.add(new ChangeVariableTypeFix(property, typeToInsert));
      }
    }

    PsiElement expressionParent = expression.getParent();

    // Mismatch in returned expression:

    JetCallableDeclaration function =
        expressionParent instanceof JetReturnExpression
            ? BindingContextUtilPackage.getTargetFunction(
                (JetReturnExpression) expressionParent, context)
            : PsiTreeUtil.getParentOfType(expression, JetFunction.class, true);
    if (function instanceof JetFunction
        && QuickFixUtil.canFunctionOrGetterReturnExpression(function, expression)) {
      LexicalScope scope =
          CorePackage.getResolutionScope(
              function, context, ResolutionUtils.getResolutionFacade(function));
      JetType typeToInsert = TypeUtils.approximateWithResolvableType(expressionType, scope, false);
      actions.add(new ChangeFunctionReturnTypeFix((JetFunction) function, typeToInsert));
    }

    // Fixing overloaded operators:
    if (expression instanceof JetOperationExpression) {
      ResolvedCall<?> resolvedCall = CallUtilPackage.getResolvedCall(expression, context);
      if (resolvedCall != null) {
        JetFunction declaration = getFunctionDeclaration(resolvedCall);
        if (declaration != null) {
          actions.add(new ChangeFunctionReturnTypeFix(declaration, expectedType));
        }
      }
    }

    // Change function return type when TYPE_MISMATCH is reported on call expression:
    if (expression instanceof JetCallExpression) {
      ResolvedCall<?> resolvedCall = CallUtilPackage.getResolvedCall(expression, context);
      if (resolvedCall != null) {
        JetFunction declaration = getFunctionDeclaration(resolvedCall);
        if (declaration != null) {
          actions.add(new ChangeFunctionReturnTypeFix(declaration, expectedType));
        }
      }
    }

    ResolvedCall<? extends CallableDescriptor> resolvedCall =
        CallUtilPackage.getParentResolvedCall(expression, context, true);
    if (resolvedCall != null) {
      // to fix 'type mismatch' on 'if' branches
      // todo: the same with 'when'
      JetExpression parentIf = QuickFixUtil.getParentIfForBranch(expression);
      JetExpression argumentExpression = (parentIf != null) ? parentIf : expression;
      ValueArgument valueArgument =
          CallUtilPackage.getValueArgumentForExpression(resolvedCall.getCall(), argumentExpression);
      if (valueArgument != null) {
        JetParameter correspondingParameter =
            QuickFixUtil.getParameterDeclarationForValueArgument(resolvedCall, valueArgument);
        JetType valueArgumentType =
            diagnostic.getFactory() == Errors.NULL_FOR_NONNULL_TYPE
                ? expressionType
                : context.getType(valueArgument.getArgumentExpression());
        if (correspondingParameter != null && valueArgumentType != null) {
          JetCallableDeclaration callable =
              PsiTreeUtil.getParentOfType(
                  correspondingParameter, JetCallableDeclaration.class, true);
          LexicalScope scope =
              callable != null
                  ? CorePackage.getResolutionScope(
                      callable, context, ResolutionUtils.getResolutionFacade(callable))
                  : null;
          JetType typeToInsert =
              TypeUtils.approximateWithResolvableType(valueArgumentType, scope, true);
          actions.add(new ChangeParameterTypeFix(correspondingParameter, typeToInsert));
        }
      }
    }
    return actions;
  }