path: root/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/codeInspection/assignment/GroovyAssignabilityCheckInspection.java

/*
 * Copyright 2000-2014 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.jetbrains.plugins.groovy.codeInspection.assignment;

import com.intellij.codeInsight.intention.IntentionAction;
import com.intellij.codeInspection.*;
import com.intellij.codeInspection.ui.MultipleCheckboxOptionsPanel;
import com.intellij.lang.annotation.Annotation;
import com.intellij.lang.annotation.AnnotationHolder;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Condition;
import com.intellij.openapi.util.Pair;
import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
import com.intellij.psi.*;
import com.intellij.psi.impl.PsiSubstitutorImpl;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.InheritanceUtil;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.util.Function;
import com.intellij.util.IncorrectOperationException;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.Nls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.groovy.GroovyBundle;
import org.jetbrains.plugins.groovy.annotator.GrHighlightUtil;
import org.jetbrains.plugins.groovy.codeInspection.BaseInspection;
import org.jetbrains.plugins.groovy.codeInspection.BaseInspectionVisitor;
import org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle;
import org.jetbrains.plugins.groovy.codeInspection.utils.ControlFlowUtils;
import org.jetbrains.plugins.groovy.config.GroovyConfigUtils;
import org.jetbrains.plugins.groovy.extensions.GroovyNamedArgumentProvider;
import org.jetbrains.plugins.groovy.extensions.NamedArgumentDescriptor;
import org.jetbrains.plugins.groovy.findUsages.LiteralConstructorReference;
import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
import org.jetbrains.plugins.groovy.lang.psi.GrControlFlowOwner;
import org.jetbrains.plugins.groovy.lang.psi.GroovyFileBase;
import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.GrListOrMap;
import org.jetbrains.plugins.groovy.lang.psi.api.signatures.GrClosureSignature;
import org.jetbrains.plugins.groovy.lang.psi.api.signatures.GrSignature;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrConstructorInvocation;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrField;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrVariable;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrVariableDeclaration;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrSpreadArgument;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.branch.GrReturnStatement;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.branch.GrThrowStatement;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.clauses.GrForInClause;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.*;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.literals.GrLiteral;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.literals.GrString;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.path.GrIndexProperty;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.path.GrMethodCallExpression;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameter;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameterList;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.*;
import org.jetbrains.plugins.groovy.lang.psi.api.types.GrCodeReferenceElement;
import org.jetbrains.plugins.groovy.lang.psi.api.types.GrTypeElement;
import org.jetbrains.plugins.groovy.lang.psi.dataFlow.types.TypeInferenceHelper;
import org.jetbrains.plugins.groovy.lang.psi.impl.GrClosureType;
import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager;
import org.jetbrains.plugins.groovy.lang.psi.impl.PsiImplUtil;
import org.jetbrains.plugins.groovy.lang.psi.impl.signatures.GrClosureSignatureUtil;
import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil;
import org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ClosureParameterEnhancer;
import org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ClosureParamsEnhancer;
import org.jetbrains.plugins.groovy.lang.psi.util.*;
import org.jetbrains.plugins.groovy.lang.resolve.ResolveUtil;
import org.jetbrains.plugins.groovy.spock.SpockUtils;

import javax.swing.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * @author Maxim.Medvedev
 */
public class GroovyAssignabilityCheckInspection extends BaseInspection {
  private static final Logger LOG = Logger.getInstance(GroovyAssignabilityCheckInspection.class);

  private static final String SHORT_NAME = "GroovyAssignabilityCheck";

  public boolean myHighlightAssignmentsFromVoid = true;

  @Nls
  @NotNull
  @Override
  public String getGroupDisplayName() {
    return ASSIGNMENT_ISSUES;
  }

  @Override
  public boolean isEnabledByDefault() {
    return true;
  }

  @Nullable
  @Override
  public JComponent createOptionsPanel() {
    final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this);
    optionsPanel.addCheckbox(GroovyInspectionBundle.message("highlight.assignments.from.void"), "myHighlightAssignmentsFromVoid");
    return optionsPanel;
  }

  @Nls
  @NotNull
  @Override
  public String getDisplayName() {
    return "Incompatible type assignments";
  }

  @Override
  protected String buildErrorString(Object... args) {
    return (String)args[0];
  }

  @NotNull
  @Override
  protected BaseInspectionVisitor buildVisitor() {
    return new MyVisitor();
  }

  private static class MyVisitor extends BaseInspectionVisitor {
    private void checkAssignability(@NotNull PsiType expectedType, @NotNull GrExpression expression, PsiElement toHighlight) {
      if (PsiUtil.isRawClassMemberAccess(expression)) return;
      if (checkForImplicitEnumAssigning(expectedType, expression, expression)) return;
      final PsiType rType = expression.getType();
      if (rType == null) return;

      if (PsiUtil.isVoidMethodCall(expression)) {
        if (isHighlightAssignmentsFromVoid(expression)) {
          registerError(toHighlight, GroovyBundle.message("cannot.assign", PsiType.VOID.getPresentableText(),
                                                          expectedType.getPresentableText()));
        }
        return;
      }

      if (!TypesUtil.isAssignable(expectedType, rType, expression)) {
        final List<LocalQuickFix> fixes = ContainerUtil.newArrayList();
        fixes.add(new GrCastFix(expectedType, expression));

        String varName = getLValueVarName(toHighlight);
        if (varName != null) {
          fixes.add(new GrChangeVariableType(rType, varName));
        }

        final String message = GroovyBundle.message("cannot.assign", rType.getPresentableText(), expectedType.getPresentableText());
        registerError(toHighlight, message, fixes.toArray(new LocalQuickFix[fixes.size()]), ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
      }
    }

    private static boolean isHighlightAssignmentsFromVoid(PsiElement place) {
      final GroovyAssignabilityCheckInspection instance = getInspectionInstance(place.getContainingFile(), place.getProject());
      if (instance != null) {
        return instance.myHighlightAssignmentsFromVoid;
      }

      return false;
    }

    private static GroovyAssignabilityCheckInspection getInspectionInstance(PsiFile file, Project project) {
      final InspectionProfile profile = InspectionProjectProfileManager.getInstance(project).getInspectionProfile();
      return (GroovyAssignabilityCheckInspection)profile.getUnwrappedTool(SHORT_NAME, file);
    }


    @Nullable
    private static String getLValueVarName(PsiElement highlight) {
      final PsiElement parent = highlight.getParent();
      if (parent instanceof GrVariable) {
        return ((GrVariable)parent).getName();
      }
      else if (highlight instanceof GrReferenceExpression &&
               parent instanceof GrAssignmentExpression &&
               ((GrAssignmentExpression)parent).getLValue() == highlight) {
        final PsiElement resolved = ((GrReferenceExpression)highlight).resolve();
        if (resolved instanceof GrVariable && PsiUtil.isLocalVariable(resolved)) {
          return ((GrVariable)resolved).getName();
        }
      }

      return null;
    }

    private void checkAssignability(@NotNull PsiType lType,
                                    @Nullable PsiType rType,
                                    @NotNull GroovyPsiElement context,
                                    @NotNull final PsiElement elementToHighlight) {
      if (rType == null) return;
      if (!TypesUtil.isAssignable(lType, rType, context)) {
        final String message = GroovyBundle.message("cannot.assign", rType.getPresentableText(), lType.getPresentableText());
        registerError(elementToHighlight, message, LocalQuickFix.EMPTY_ARRAY, ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
      }
    }


    private boolean checkForImplicitEnumAssigning(PsiType expectedType, GrExpression expression, GroovyPsiElement element) {
      if (!(expectedType instanceof PsiClassType)) return false;

      if (!GroovyConfigUtils.getInstance().isVersionAtLeast(element, GroovyConfigUtils.GROOVY1_8)) return false;

      final PsiClass resolved = ((PsiClassType)expectedType).resolve();
      if (resolved == null || !resolved.isEnum()) return false;

      final PsiType type = expression.getType();
      if (type == null) return false;

      if (!type.equalsToText(GroovyCommonClassNames.GROOVY_LANG_GSTRING) && !type.equalsToText(CommonClassNames.JAVA_LANG_STRING)) {
        return false;
      }

      final Object result = GroovyConstantExpressionEvaluator.evaluate(expression);
      if (result == null || !(result instanceof String)) {
        registerError(element, ProblemHighlightType.WEAK_WARNING,
                      GroovyBundle.message("cannot.assign.string.to.enum.0", expectedType.getPresentableText()));
      }
      else {
        final PsiField field = resolved.findFieldByName((String)result, true);
        if (!(field instanceof PsiEnumConstant)) {
          registerError(element, GroovyBundle.message("cannot.find.enum.constant.0.in.enum.1", result, expectedType.getPresentableText()));
        }
      }
      return true;
    }

    @Override
    public void visitReturnStatement(GrReturnStatement returnStatement) {
      final GrExpression value = returnStatement.getReturnValue();
      if (value == null || isNewInstanceInitialingByTuple(value)) return;

      final PsiType returnType = PsiImplUtil.inferReturnType(returnStatement);
      if (returnType != null) {
        checkAssignability(returnType, value, returnStatement.getReturnWord());
      }
    }

    @Override
    public void visitExpression(GrExpression expression) {
      if (PsiUtil.isExpressionStatement(expression)) {
        final PsiType returnType = PsiImplUtil.inferReturnType(expression);
        final GrControlFlowOwner flowOwner = ControlFlowUtils.findControlFlowOwner(expression);
        if (flowOwner != null && returnType != null && returnType != PsiType.VOID) {
          if (ControlFlowUtils.isReturnValue(expression, flowOwner) &&
              !isNewInstanceInitialingByTuple(expression) &&
              !PsiUtil.isVoidMethodCall(expression)) {
            checkAssignability(returnType, expression, getExpressionPartToHighlight(expression));
          }
        }
      }
    }

    protected boolean shouldProcess(GrMember member) {
      return !GroovyPsiManager.getInstance(member.getProject()).isCompileStatic(member);
    }

    @Override
    public void visitAssignmentExpression(GrAssignmentExpression assignment) {
      GrExpression lValue = assignment.getLValue();
      if (lValue instanceof GrIndexProperty) return;
      if (!PsiUtil.mightBeLValue(lValue)) return;

      IElementType opToken = assignment.getOperationTokenType();
      if (opToken != GroovyTokenTypes.mASSIGN) return;

      GrExpression rValue = assignment.getRValue();
      if (rValue == null) return;

      if (lValue instanceof GrTupleExpression) {
        checkTupleAssignment(((GrTupleExpression)lValue), rValue);
      }
      else {
        checkAssignment(lValue, rValue);
      }
    }

    private void checkTupleAssignment(GrTupleExpression tupleExpression, GrExpression initializer) {
      GrExpression[] lValues = tupleExpression.getExpressions();
      if (initializer instanceof GrListOrMap) {
        GrExpression[] initializers = ((GrListOrMap)initializer).getInitializers();
        for (int i = 0; i < lValues.length; i++) {
          GrExpression lValue = lValues[i];
          if (initializers.length >= i) break;
          GrExpression rValue = initializers[i];
          checkAssignment(lValue, rValue);
        }
      }
      else {
        PsiType type = initializer.getType();
        PsiType rType = com.intellij.psi.util.PsiUtil.extractIterableTypeParameter(type, false);

        for (GrExpression lValue : lValues) {
          PsiType lType = lValue.getNominalType();
          // For assignments with spread dot
          if (PsiImplUtil.isSpreadAssignment(lValue)) {
            final PsiType argType = extractIterableArg(lType);
            if (argType != null && rType != null) {
              checkAssignability(argType, rType, tupleExpression, getExpressionPartToHighlight(lValue));
            }
            return;
          }
          if (lValue instanceof GrReferenceExpression && ((GrReferenceExpression)lValue).resolve() instanceof GrReferenceExpression) {
            //lvalue is not-declared variable
            return;
          }

          if (lType != null && rType != null) {
            checkAssignability(lType, rType, tupleExpression, getExpressionPartToHighlight(lValue));
          }
        }
      }
    }

    private void checkAssignment(GrExpression lValue, GrExpression rValue) {
      PsiType lType = lValue.getNominalType();
      PsiType rType = rValue.getType();
      if (PsiImplUtil.isSpreadAssignment(lValue)) {
        final PsiType argType = extractIterableArg(lType);
        if (argType != null && rValue != null) {
          checkAssignability(argType, rValue, getExpressionPartToHighlight(lValue));
        }
        return;
      }
      if (lValue instanceof GrReferenceExpression && ((GrReferenceExpression)lValue).resolve() instanceof GrReferenceExpression) {
        //lvalue is not-declared variable
        return;
      }

      if (isNewInstanceInitialingByTuple(rValue)) {
        // new instance initializing e.g.: X x; x = [1, 2]
        return;
      }

      if (lType != null && rType != null) {
        checkAssignability(lType, rValue, getExpressionPartToHighlight(lValue));
      }
    }

    @Nullable
    private static PsiType extractIterableArg(@Nullable PsiType type) {
      return com.intellij.psi.util.PsiUtil.extractIterableTypeParameter(type, false);
    }

    @Override
    public void visitVariable(GrVariable variable) {
      PsiType varType = variable.getType();

      PsiElement parent = variable.getParent();
      //check tuple assignment:  def (int x, int y) = foo()
      if (parent instanceof GrVariableDeclaration && ((GrVariableDeclaration)parent).isTuple()) {
        GrVariableDeclaration tuple = (GrVariableDeclaration)parent;
        GrExpression initializer = tuple.getTupleInitializer();
        if (initializer == null) return;
        if (!(initializer instanceof GrListOrMap)) {
          PsiType type = initializer.getType();
          if (type == null) return;
          PsiType valueType = com.intellij.psi.util.PsiUtil.extractIterableTypeParameter(type, false);
          checkAssignability(varType, valueType, tuple, variable.getNameIdentifierGroovy());
          return;
        }
      }
      else if (parent instanceof GrForInClause) {
        GrExpression iterated = ((GrForInClause)parent).getIteratedExpression();
        if (iterated == null) return;

        PsiType iteratedType = ClosureParameterEnhancer.findTypeForIteration(iterated, parent);
        if (iteratedType == null) return;

        checkAssignability(varType, iteratedType, iterated, variable.getNameIdentifierGroovy());
        return;
      }

      GrExpression initializer = variable.getInitializerGroovy();
      if (initializer == null) return;

      PsiType rType = initializer.getType();
      if (rType == null) return;
      if (isNewInstanceInitialingByTuple(initializer)) {
        return;
      }

      if (variable instanceof GrParameter && ((GrParameter)variable).getDeclarationScope() instanceof GrMethod) {
        final GrMethod method = (GrMethod)((GrParameter)variable).getDeclarationScope();
        final PsiTypeParameter[] parameters = method.getTypeParameters();

        Map<PsiTypeParameter, PsiType> map = ContainerUtil.newHashMap();
        for (PsiTypeParameter parameter : parameters) {
          final PsiClassType[] types = parameter.getSuperTypes();

          if (types.length == 1) {
            map.put(parameter, PsiWildcardType.createExtends(variable.getManager(), types[0]));
          }
          else {
            map.put(parameter, PsiWildcardType.createExtends(variable.getManager(), PsiIntersectionType.createIntersection(types)));
          }
        }
        PsiSubstitutor substitutor = PsiSubstitutorImpl.createSubstitutor(map);
        checkAssignability(substitutor.substitute(varType), initializer, variable.getNameIdentifierGroovy());
        return;
      }

      checkAssignability(varType, initializer, variable.getNameIdentifierGroovy());
    }

    private static boolean isNewInstanceInitialingByTuple(GrExpression initializer) {
      return initializer instanceof GrListOrMap &&
             initializer.getReference() instanceof LiteralConstructorReference &&
             ((LiteralConstructorReference)initializer.getReference()).getConstructedClassType() != null;
    }

    @Override
    public void visitNewExpression(GrNewExpression newExpression) {
      if (newExpression.getArrayCount() > 0) return;

      GrCodeReferenceElement refElement = newExpression.getReferenceElement();
      if (refElement == null) return;

      GrNewExpressionInfo info = new GrNewExpressionInfo(newExpression);
      checkConstructorCall(info);
    }

    private void checkConstructorCall(ConstructorCallInfo<?> info) {
      if (hasErrorElements(info.getArgumentList())) return;

      if (!checkCannotInferArgumentTypes(info)) return;
      final GroovyResolveResult constructorResolveResult = info.advancedResolve();
      final PsiElement constructor = constructorResolveResult.getElement();

      if (constructor != null) {
        if (!checkConstructorApplicability(constructorResolveResult, info, true)) return;
      }
      else {
        final GroovyResolveResult[] results = info.multiResolve();
        if (results.length > 0) {
          for (GroovyResolveResult result : results) {
            PsiElement resolved = result.getElement();
            if (resolved instanceof PsiMethod) {
              if (!checkConstructorApplicability(result, info, false)) return;
            }
          }
          registerError(info.getElementToHighlight(), GroovyBundle.message("constructor.call.is.ambiguous"));
        }
        else {
          final GrExpression[] expressionArguments = info.getExpressionArguments();
          final boolean hasClosureArgs = info.getClosureArguments().length > 0;
          final boolean hasNamedArgs = info.getNamedArguments().length > 0;
          if (hasClosureArgs ||
              hasNamedArgs && expressionArguments.length > 0 ||
              !hasNamedArgs && expressionArguments.length > 0 && !isOnlyOneMapParam(expressionArguments)) {
            final GroovyResolveResult[] resolveResults = info.multiResolveClass();
            if (resolveResults.length == 1) {
              final PsiElement element = resolveResults[0].getElement();
              if (element instanceof PsiClass) {
                registerError(info.getElementToHighlight(),
                              GroovyBundle.message("cannot.apply.default.constructor", ((PsiClass)element).getName()));
                return;
              }
            }
          }
        }
      }

      checkNamedArgumentsType(info);
    }

    private static boolean isOnlyOneMapParam(GrExpression[] exprs) {
      if (!(exprs.length == 1)) return false;

      final GrExpression e = exprs[0];
      return TypesUtil.isAssignableByMethodCallConversion(TypesUtil.createTypeByFQClassName(CommonClassNames.JAVA_UTIL_MAP, e), e.getType(), e);
    }

    @NotNull
    private static PsiElement getExpressionPartToHighlight(@NotNull GrExpression expr) {
      if (expr instanceof GrClosableBlock) {
        return ((GrClosableBlock)expr).getLBrace();
      }

      return expr;
    }

    @Override
    public void visitListOrMap(GrListOrMap listOrMap) {

      final PsiReference reference = listOrMap.getReference();
      if (!(reference instanceof LiteralConstructorReference)) return;

      final GroovyResolveResult[] results = ((LiteralConstructorReference)reference).multiResolve(false);
      if (results.length == 0) return;

      checkConstructorCall(new GrListOrMapInfo(listOrMap));
    }

    @Override
    public void visitThrowStatement(GrThrowStatement throwStatement) {

      final GrExpression exception = throwStatement.getException();
      if (exception != null) {
        final PsiElement throwWord = throwStatement.getFirstChild();
        checkAssignability(PsiType.getJavaLangThrowable(throwStatement.getManager(), throwStatement.getResolveScope()), exception, throwWord);
      }
    }

    private boolean checkConstructorApplicability(GroovyResolveResult constructorResolveResult,
                                                  CallInfo<?> info,
                                                  boolean checkUnknownArgs) {
      final PsiElement element = constructorResolveResult.getElement();
      LOG.assertTrue(element instanceof PsiMethod && ((PsiMethod)element).isConstructor(), element);
      final PsiMethod constructor = (PsiMethod)element;

      final GrArgumentList argList = info.getArgumentList();
      if (argList != null) {
        final GrExpression[] exprArgs = argList.getExpressionArguments();
        if (exprArgs.length == 0 && !PsiUtil.isConstructorHasRequiredParameters(constructor)) return true;
      }

      PsiType[] types = info.getArgumentTypes();
      PsiClass containingClass = constructor.getContainingClass();
      if (types != null && containingClass != null) {
        final PsiType[] newTypes = GrInnerClassConstructorUtil.addEnclosingArgIfNeeded(types, info.getCall(), containingClass);
        if (newTypes.length != types.length) {
          return checkMethodApplicability(constructorResolveResult, checkUnknownArgs, new DelegatingCallInfo(info) {
            @Nullable
            @Override
            public PsiType[] getArgumentTypes() {
              return newTypes;
            }
          });
        }
      }

      return checkMethodApplicability(constructorResolveResult, checkUnknownArgs, info);
    }

    @Override
    public void visitConstructorInvocation(GrConstructorInvocation invocation) {
      GrConstructorInvocationInfo info = new GrConstructorInvocationInfo(invocation);
      checkConstructorCall(info);
      checkNamedArgumentsType(info);
    }

    @Override
    public void visitIndexProperty(GrIndexProperty expression) {
      checkIndexProperty(new GrIndexPropertyInfo(expression));
    }

    private void checkIndexProperty(CallInfo<? extends GrIndexProperty> info) {
      if (hasErrorElements(info.getArgumentList())) return;

      if (!checkCannotInferArgumentTypes(info)) return;

      final PsiType type = info.getQualifierInstanceType();
      final PsiType[] types = info.getArgumentTypes();

      if (checkSimpleArrayAccess(info, type, types)) return;

      final GroovyResolveResult[] results = info.multiResolve();
      final GroovyResolveResult resolveResult = info.advancedResolve();

      if (resolveResult.getElement() != null) {
        PsiElement resolved = resolveResult.getElement();

        if (resolved instanceof PsiMethod && !resolveResult.isInvokedOnProperty()) {
          checkMethodApplicability(resolveResult, true, info);
        }
        else if (resolved instanceof GrField) {
          checkCallApplicability(((GrField)resolved).getTypeGroovy(), true, info);
        }
        else if (resolved instanceof PsiField) {
          checkCallApplicability(((PsiField)resolved).getType(), true, info);
        }
      }
      else if (results.length > 0) {
        for (GroovyResolveResult result : results) {
          PsiElement resolved = result.getElement();
          if (resolved instanceof PsiMethod && !result.isInvokedOnProperty()) {
            if (!checkMethodApplicability(result, false, info)) return;
          }
          else if (resolved instanceof GrField) {
            if (!checkCallApplicability(((GrField)resolved).getTypeGroovy(), false, info)) return;
          }
          else if (resolved instanceof PsiField) {
            if (!checkCallApplicability(((PsiField)resolved).getType(), false, info)) return;
          }
        }

        registerError(info.getElementToHighlight(), GroovyBundle.message("method.call.is.ambiguous"));
      }
      else {
        final String typesString = buildArgTypesList(types);
        registerError(info.getElementToHighlight(), GroovyBundle.message("cannot.find.operator.overload.method", typesString));
      }
    }

    private static boolean checkSimpleArrayAccess(CallInfo<? extends GrIndexProperty> info, PsiType type, PsiType[] types) {
      if (!(type instanceof PsiArrayType)) return false;

      assert types != null;

      if (PsiUtil.isLValue(info.getCall())) {
        if (types.length == 2 &&
            TypesUtil.isAssignable(PsiType.INT, types[0], info.getCall()) &&
            TypesUtil.isAssignable(((PsiArrayType)type).getComponentType(), types[1], info.getCall())) {
          return true;
        }
      }
      else {
        if (types.length == 1 && TypesUtil.isAssignable(PsiType.INT, types[0], info.getCall())) {
          return true;
        }
      }

      return false;
    }

    private boolean checkCannotInferArgumentTypes(CallInfo info) {
      if (info.getArgumentTypes() != null) {
        return true;
      }
      else {
        highlightUnknownArgs(info);
        return false;
      }
    }

    @Override
    public void visitMethodCallExpression(GrMethodCallExpression methodCallExpression) {
      checkMethodCall(new GrMethodCallInfo(methodCallExpression));
    }

    @Override
    public void visitApplicationStatement(GrApplicationStatement applicationStatement) {
      checkMethodCall(new GrMethodCallInfo(applicationStatement));
    }

    @Override
    public void visitBinaryExpression(GrBinaryExpression binary) {
      checkOperator(new GrBinaryExprInfo(binary));
    }

    @Override
    public void visitEnumConstant(GrEnumConstant enumConstant) {
      GrEnumConstantInfo info = new GrEnumConstantInfo(enumConstant);
      checkConstructorCall(info);
      checkNamedArgumentsType(info);
    }

    private void checkNamedArgumentsType(CallInfo<?> info) {
      GroovyPsiElement rawCall = info.getCall();
      if (!(rawCall instanceof GrCall)) return;
      GrCall call = (GrCall)rawCall;

      GrNamedArgument[] namedArguments = PsiUtil.getFirstMapNamedArguments(call);

      if (namedArguments.length == 0) return;

      Map<String, NamedArgumentDescriptor> map = GroovyNamedArgumentProvider.getNamedArgumentsFromAllProviders(call, null, false);
      if (map == null) return;

      for (GrNamedArgument namedArgument : namedArguments) {
        String labelName = namedArgument.getLabelName();

        NamedArgumentDescriptor descriptor = map.get(labelName);

        if (descriptor == null) continue;

        GrExpression namedArgumentExpression = namedArgument.getExpression();
        if (namedArgumentExpression == null) continue;

        if (isNewInstanceInitialingByTuple(namedArgumentExpression)) continue;

        if (PsiUtil.isRawClassMemberAccess(namedArgumentExpression)) continue;

        PsiType expressionType = TypesUtil.boxPrimitiveType(namedArgumentExpression.getType(), call.getManager(), call.getResolveScope());
        if (expressionType == null) continue;

        if (!descriptor.checkType(expressionType, call)) {
          registerError(namedArgumentExpression, "Type of argument '" + labelName + "' can not be '" + expressionType.getPresentableText() + "'");
        }
      }
    }

    @Override
    public void visitParameterList(final GrParameterList parameterList) {
      PsiElement parent = parameterList.getParent();
      if (parent instanceof GrClosableBlock) {

        GrParameter[] parameters = parameterList.getParameters();
        if (parameters.length > 0) {
          List<PsiType[]> signatures = ClosureParamsEnhancer.findFittingSignatures((GrClosableBlock)parent);
          final List<PsiType> paramTypes = ContainerUtil.map(parameters, new Function<GrParameter, PsiType>() {
            @Override
            public PsiType fun(GrParameter parameter) {
              return parameter.getType();
            }
          });

          if (signatures.size() > 1) {
            PsiType[] fittingSignature = ContainerUtil.find(signatures, new Condition<PsiType[]>() {
              @Override
              public boolean value(PsiType[] types) {
                for (int i = 0; i < types.length; i++) {
                  if (!typesAreEqual(types[i], paramTypes.get(i), parameterList)) {
                    return false;
                  }
                }
                return true;
              }
            });

            if (fittingSignature == null) {
              registerError(parameterList, GroovyInspectionBundle.message("no.applicable.signature.found"));
            }
          }
          else if (signatures.size() == 1) {
            PsiType[] types = signatures.get(0);
            for (int i = 0; i < types.length; i++) {
              GrTypeElement typeElement = parameters[i].getTypeElementGroovy();
              if (typeElement == null) continue;
              PsiType expected = types[i];
              PsiType actual = paramTypes.get(i);
              if (!typesAreEqual(expected, actual, parameterList)) {
                registerError(typeElement, GroovyInspectionBundle.message("expected.type.0", expected.getPresentableText()));
              }
            }
          }
        }
      }
    }

    private static boolean typesAreEqual(@NotNull PsiType expected, @NotNull PsiType actual, @NotNull PsiElement context) {
      return TypesUtil.isAssignableByMethodCallConversion(expected, actual, context) &&
             TypesUtil.isAssignableByMethodCallConversion(actual, expected, context);
    }


    /**
     * checks only children of e
     */
    private static boolean hasErrorElements(@Nullable PsiElement e) {
      if (e == null) return false;

      for (PsiElement child = e.getFirstChild(); child != null; child = child.getNextSibling()) {
        if (child instanceof PsiErrorElement) return true;
      }
      return false;
    }

    private void checkOperator(CallInfo<? extends GrBinaryExpression> info) {
      if (hasErrorElements(info.getCall())) return;

      if (isSpockTimesOperator(info.getCall())) return;

      GroovyResolveResult[] results = info.multiResolve();
      GroovyResolveResult resolveResult = info.advancedResolve();

      if (isOperatorWithSimpleTypes(info.getCall(), resolveResult)) return;

      if (!checkCannotInferArgumentTypes(info)) return;

      if (resolveResult.getElement() != null) {
        checkMethodApplicability(resolveResult, true, info);
      }
      else if (results.length > 0) {
        for (GroovyResolveResult result : results) {
          if (!checkMethodApplicability(result, false, info)) return;
        }

        registerError(info.getElementToHighlight(), GroovyBundle.message("method.call.is.ambiguous"));
      }
    }

    private static boolean isSpockTimesOperator(GrBinaryExpression call) {
      if (call.getOperationTokenType() == GroovyTokenTypes.mSTAR && PsiUtil.isExpressionStatement(call)) {
        GrExpression operand = call.getLeftOperand();
        if (operand instanceof GrLiteral && TypesUtil.isNumericType(operand.getType())) {
          PsiClass aClass = PsiUtil.getContextClass(call);
          if (InheritanceUtil.isInheritor(aClass, false, SpockUtils.SPEC_CLASS_NAME)) {
            return true;
          }
        }
      }

      return false;
    }

    private static boolean isOperatorWithSimpleTypes(GrBinaryExpression binary, GroovyResolveResult result) {
      if (result.getElement() != null && result.isApplicable()) {
        return false;
      }

      GrExpression left = binary.getLeftOperand();
      GrExpression right = binary.getRightOperand();

      PsiType ltype = left.getType();
      PsiType rtype = right != null ? right.getType() : null;

      return TypesUtil.isNumericType(ltype) && (rtype == null || TypesUtil.isNumericType(rtype));
    }

    private void checkMethodCall(CallInfo<? extends GrMethodCall> info) {
      if (hasErrorElements(info.getArgumentList())) return;

      if (info.getInvokedExpression() instanceof GrReferenceExpression) {
        final GrReferenceExpression referenceExpression = (GrReferenceExpression)info.getInvokedExpression();
        GroovyResolveResult resolveResult = info.advancedResolve();
        GroovyResolveResult[] results = info.multiResolve();

        PsiElement resolved = resolveResult.getElement();
        if (resolved == null) {
          GrExpression qualifier = referenceExpression.getQualifierExpression();
          if (qualifier == null && GrHighlightUtil.isDeclarationAssignment(referenceExpression)) return;
        }

        if (!checkCannotInferArgumentTypes(info)) return;

        final PsiType type = referenceExpression.getType();
        if (resolved != null) {
          if (resolved instanceof PsiMethod && !resolveResult.isInvokedOnProperty()) {
            checkMethodApplicability(resolveResult, true, info);
          }
          else {
            checkCallApplicability(type, true, info);
          }
        }
        else if (results.length > 0) {
          for (GroovyResolveResult result : results) {
            PsiElement current = result.getElement();
            if (current instanceof PsiMethod && !result.isInvokedOnProperty()) {
              if (!checkMethodApplicability(result, false, info)) return;
            }
            else {
              if (!checkCallApplicability(type, false, info)) return;
            }
          }

          registerError(info.getElementToHighlight(), GroovyBundle.message("method.call.is.ambiguous"));
        }
      }
      else if (info.getInvokedExpression() != null) { //it checks in visitRefExpr(...)
        final PsiType type = info.getInvokedExpression().getType();
        checkCallApplicability(type, true, info);
      }

      checkNamedArgumentsType(info);
    }

    private void highlightInapplicableMethodUsage(@NotNull GroovyResolveResult methodResolveResult,
                                                  @NotNull CallInfo info,
                                                  @NotNull PsiMethod method) {
      final PsiClass containingClass =
        method instanceof GrGdkMethod ? ((GrGdkMethod)method).getStaticMethod().getContainingClass() : method.getContainingClass();

      PsiType[] argumentTypes = info.getArgumentTypes();
      if (containingClass == null) {
        registerCannotApplyError(method.getName(), info);
        return;
      }
      final String typesString = buildArgTypesList(argumentTypes);
      final PsiElementFactory factory = JavaPsiFacade.getElementFactory(method.getProject());
      final PsiClassType containingType = factory.createType(containingClass, methodResolveResult.getSubstitutor());
      final String canonicalText = containingType.getInternalCanonicalText();
      String message = method.isConstructor() ? GroovyBundle.message("cannot.apply.constructor", method.getName(), canonicalText, typesString)
                                              : GroovyBundle.message("cannot.apply.method1", method.getName(), canonicalText, typesString);

      registerError(info.getElementToHighlight(), message,
                    genCastFixes(GrClosureSignatureUtil.createSignature(methodResolveResult), argumentTypes, info.getArgumentList()),
                    ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
    }

    private static LocalQuickFix[] genCastFixes(GrSignature signature, PsiType[] argumentTypes, @Nullable GrArgumentList argumentList) {
      if (argumentList == null) return LocalQuickFix.EMPTY_ARRAY;
      final List<GrExpression> args = getExpressionArgumentsOfCall(argumentList);

      if (args == null) {
        return LocalQuickFix.EMPTY_ARRAY;
      }

      final List<GrClosureSignature> signatures = GrClosureSignatureUtil.generateSimpleSignatures(signature);

      List<Pair<Integer, PsiType>> allErrors = new ArrayList<Pair<Integer, PsiType>>();
      for (GrClosureSignature closureSignature : signatures) {
        final GrClosureSignatureUtil.MapResultWithError<PsiType> map =
          GrClosureSignatureUtil.mapSimpleSignatureWithErrors(closureSignature, argumentTypes, Function.ID, argumentList, 1);
        if (map != null) {
          final List<Pair<Integer, PsiType>> errors = map.getErrors();
          for (Pair<Integer, PsiType> error : errors) {
            if (!(error.first == 0 && PsiImplUtil.hasNamedArguments(argumentList))) {
              allErrors.add(error);
            }
          }
        }
      }

      final ArrayList<LocalQuickFix> fixes = new ArrayList<LocalQuickFix>();
      for (Pair<Integer, PsiType> error : allErrors) {
        fixes.add(new ParameterCastFix(error.first, error.second, args.get(error.first)));
      }

      return fixes.toArray(new LocalQuickFix[fixes.size()]);
    }

    private boolean checkCallApplicability(PsiType type, boolean checkUnknownArgs, CallInfo info) {

      PsiType[] argumentTypes = info.getArgumentTypes();
      GrExpression invoked = info.getInvokedExpression();
      if (invoked == null) return true;

      if (type instanceof GrClosureType) {
        if (argumentTypes == null) return true;

        GrClosureSignatureUtil.ApplicabilityResult result = PsiUtil.isApplicableConcrete(argumentTypes, (GrClosureType)type, info.getCall());
        switch (result) {
          case inapplicable:
            registerCannotApplyError(invoked.getText(), info);
            return false;
          case canBeApplicable:
            if (checkUnknownArgs) {
              highlightUnknownArgs(info);
            }
            return !checkUnknownArgs;
          default:
            return true;
        }
      }
      else if (type != null) {
        final GroovyResolveResult[] calls = ResolveUtil.getMethodCandidates(type, "call", invoked, argumentTypes);
        for (GroovyResolveResult result : calls) {
          PsiElement resolved = result.getElement();
          if (resolved instanceof PsiMethod && !result.isInvokedOnProperty()) {
            if (!checkMethodApplicability(result, checkUnknownArgs, info)) return false;
          }
          else if (resolved instanceof PsiField) {
            if (!checkCallApplicability(((PsiField)resolved).getType(), checkUnknownArgs && calls.length == 1, info)) return false;
          }
        }
        if (calls.length == 0 && !(invoked instanceof GrString)) {
          registerCannotApplyError(invoked.getText(), info);
        }
        return true;
      }
      return true;
    }

    private void registerCannotApplyError(String invokedText, CallInfo info) {
      final String typesString = buildArgTypesList(info.getArgumentTypes());
      registerError(info.getElementToHighlight(), GroovyBundle.message("cannot.apply.method.or.closure", invokedText, typesString));
    }

    private static String buildArgTypesList(PsiType[] argTypes) {
      StringBuilder builder = new StringBuilder();
      builder.append("(");
      for (int i = 0; i < argTypes.length; i++) {
        if (i > 0) {
          builder.append(", ");
        }
        PsiType argType = argTypes[i];
        builder.append(argType != null ? argType.getInternalCanonicalText() : "?");
      }
      builder.append(")");
      return builder.toString();
    }

    private boolean checkMethodApplicability(@NotNull GroovyResolveResult methodResolveResult,
                                             boolean checkUnknownArgs,
                                             @NotNull CallInfo info) {
      final PsiElement element = methodResolveResult.getElement();
      if (!(element instanceof PsiMethod)) return true;
      if (element instanceof GrBuilderMethod) return true;

      final PsiMethod method = (PsiMethod)element;
      if ("call".equals(method.getName()) && info.getInvokedExpression() instanceof GrReferenceExpression) {
        final GrExpression qualifierExpression = ((GrReferenceExpression)info.getInvokedExpression()).getQualifierExpression();
        if (qualifierExpression != null) {
          final PsiType type = qualifierExpression.getType();
          if (type instanceof GrClosureType) {
            GrClosureSignatureUtil.ApplicabilityResult result = PsiUtil.isApplicableConcrete(info.getArgumentTypes(), (GrClosureType)type, info.getInvokedExpression());
            switch (result) {
              case inapplicable:
                highlightInapplicableMethodUsage(methodResolveResult, info, method);
                return false;
              case canBeApplicable:
                if (checkUnknownArgs) {
                  highlightUnknownArgs(info);
                }
                return !checkUnknownArgs;
              default:
                return true;
            }
          }
        }
      }

      if (method instanceof GrGdkMethod && info.getInvokedExpression() instanceof GrReferenceExpression) {
        final PsiMethod staticMethod = ((GrGdkMethod)method).getStaticMethod();
        final PsiType qualifierType = info.getQualifierInstanceType();

        GrReferenceExpression invoked = (GrReferenceExpression)info.getInvokedExpression();
        final GrExpression qualifier = PsiImplUtil.getRuntimeQualifier(invoked);

        //check methods processed by @Category(ClassWhichProcessMethod) annotation
        if (qualifierType != null &&
            !GdkMethodUtil.isCategoryMethod(staticMethod, qualifierType, qualifier, methodResolveResult.getSubstitutor()) &&
            !checkCategoryQualifier(invoked, qualifier, staticMethod, methodResolveResult.getSubstitutor())) {
          registerError(info.getHighlightElementForCategoryQualifier(), GroovyInspectionBundle
            .message("category.method.0.cannot.be.applied.to.1", method.getName(), qualifierType.getCanonicalText()));
          return false;
        }
      }

      if (info.getArgumentTypes() == null) return true;

      GrClosureSignatureUtil.ApplicabilityResult applicable = PsiUtil.isApplicableConcrete(info.getArgumentTypes(), method, methodResolveResult.getSubstitutor(), info.getCall(), false);
      switch (applicable) {
        case inapplicable:
          highlightInapplicableMethodUsage(methodResolveResult, info, method);
          return false;
        case canBeApplicable:
          if (checkUnknownArgs) {
            highlightUnknownArgs(info);
          }
          return !checkUnknownArgs;
        default:
          return true;
      }
    }

    private static boolean checkCategoryQualifier(GrReferenceExpression place,
                                                  GrExpression qualifier,
                                                  PsiMethod gdkMethod,
                                                  PsiSubstitutor substitutor) {
      PsiClass categoryAnnotationOwner = inferCategoryAnnotationOwner(place, qualifier);

      if (categoryAnnotationOwner != null) {
        PsiClassType categoryType = GdkMethodUtil.getCategoryType(categoryAnnotationOwner);
        if (categoryType != null) {
          return GdkMethodUtil.isCategoryMethod(gdkMethod, categoryType, qualifier, substitutor);
        }
      }

      return false;
    }

    private static PsiClass inferCategoryAnnotationOwner(GrReferenceExpression place, GrExpression qualifier) {
      if (qualifier == null) {
        GrMethod container = PsiTreeUtil.getParentOfType(place, GrMethod.class, true, GrMember.class);
        if (container != null && !container.hasModifierProperty(PsiModifier.STATIC)) { //only instance methods can be qualified by category class
          return container.getContainingClass();
        }
      }
      else if (PsiUtil.isThisReference(qualifier)) {
        PsiElement resolved = ((GrReferenceExpression)qualifier).resolve();
        if (resolved instanceof PsiClass) {
          return (PsiClass)resolved;
        }
      }
      return null;
    }

    private void highlightUnknownArgs(@NotNull CallInfo info) {
      registerError(info.getElementToHighlight(), GroovyBundle.message("cannot.infer.argument.types"), LocalQuickFix.EMPTY_ARRAY, ProblemHighlightType.WEAK_WARNING);
    }

    @Override
    public void visitElement(GroovyPsiElement element) {
      //do nothing
    }
  }

  @Nullable
  private static List<GrExpression> getExpressionArgumentsOfCall(@NotNull GrArgumentList argumentList) {
    final GrExpression[] argArray = argumentList.getExpressionArguments();
    final ArrayList<GrExpression> args = ContainerUtil.newArrayList();

    for (GrExpression arg : argArray) {
      if (arg instanceof GrSpreadArgument) {
        GrExpression spreaded = ((GrSpreadArgument)arg).getArgument();
        if (spreaded instanceof GrListOrMap && !((GrListOrMap)spreaded).isMap()) {
          Collections.addAll(args, ((GrListOrMap)spreaded).getInitializers());
        }
        else {
          return null;
        }
      }
      else {
        args.add(arg);
      }
    }

    final PsiElement parent = argumentList.getParent();
    if (parent instanceof GrIndexProperty && PsiUtil.isLValue((GroovyPsiElement)parent)) {
      args.add(TypeInferenceHelper.getInitializerFor((GrExpression)parent));
    }
    else if (parent instanceof GrMethodCallExpression) {
      ContainerUtil.addAll(args, ((GrMethodCallExpression)parent).getClosureArguments());
    }
    return args;
  }


  private static class AnnotatingVisitor extends MyVisitor {
    private AnnotationHolder myHolder;

    @Override
    protected boolean shouldProcess(GrMember member) {
      return true;
    }

    @Override
    protected void registerError(@NotNull final PsiElement location,
                                 @NotNull final String description,
                                 @Nullable final LocalQuickFix[] fixes,
                                 final ProblemHighlightType highlightType) {
      Annotation annotation = myHolder.createErrorAnnotation(location, description);
      if (fixes != null) {
        for (final LocalQuickFix fix : fixes) {
          annotation.registerFix(new IntentionAction() {
            @NotNull
            @Override
            public String getText() {
              return fix.getName();
            }

            @NotNull
            @Override
            public String getFamilyName() {
              return fix.getFamilyName();
            }

            @Override
            public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
              return true;
            }

            @Override
            public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
              InspectionManager manager = InspectionManager.getInstance(project);
              ProblemDescriptor descriptor = manager.createProblemDescriptor(location, description, fixes, highlightType, fixes.length == 1, false);
              fix.applyFix(project, descriptor);
            }

            @Override
            public boolean startInWriteAction() {
              return true;
            }
          });
        }
      }
    }

    @Override
    protected void registerError(@NotNull PsiElement location,
                                 ProblemHighlightType highlightType,
                                 Object... args) {
      registerError(location, (String)args[0], LocalQuickFix.EMPTY_ARRAY, highlightType);
    }
  }

  private static final ThreadLocal<AnnotatingVisitor> visitor = new ThreadLocal<AnnotatingVisitor>() {
    @Override
    protected AnnotatingVisitor initialValue() {
      return new AnnotatingVisitor();
    }
  };

  public static void checkElement(GroovyPsiElement e, AnnotationHolder holder) {
    AnnotatingVisitor annotatingVisitor = visitor.get();

    AnnotationHolder oldHolder = annotatingVisitor.myHolder;
    try {
      annotatingVisitor.myHolder = holder;
      e.accept(annotatingVisitor);
    }
    finally {
      annotatingVisitor.myHolder = oldHolder;
    }
  }

  @Override
  @Nullable
  public ProblemDescriptor[] checkFile(@NotNull PsiFile psiFile, @NotNull InspectionManager inspectionManager, boolean isOnTheFly) {
    if (!(psiFile instanceof GroovyFileBase)) {
      return super.checkFile(psiFile, inspectionManager, isOnTheFly);
    }


    final GroovyFileBase groovyFile = (GroovyFileBase)psiFile;
    final ProblemsHolder problemsHolder = new ProblemsHolder(inspectionManager, psiFile, isOnTheFly);
    final MyVisitor visitor = (MyVisitor)buildGroovyVisitor(problemsHolder, isOnTheFly);

    processElement(groovyFile, visitor);

    return problemsHolder.getResultsArray();
  }

  private static void processElement(@NotNull GroovyPsiElement element, @NotNull MyVisitor visitor) {
    if (element instanceof GrMember && !visitor.shouldProcess((GrMember)element)) {
      return;
    }

    final int count = visitor.getErrorCount();

    PsiElement child = element.getFirstChild();
    while (child != null) {
      if (child instanceof GroovyPsiElement) {
        processElement((GroovyPsiElement)child, visitor);
      }
      child = child.getNextSibling();
    }

    if (count == visitor.getErrorCount()) {
      element.accept(visitor);
    }
  }

}