import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
private PsiElement findExtensionMethodNavigationElement( PsiClass extClass, PsiMethod plantedMethod )
{
  PsiMethod[] found = extClass.findMethodsByName( plantedMethod.getName(), false );
  outer:
  for( PsiMethod m : found )
  {
    PsiParameter[] extParams = m.getParameterList().getParameters();
    PsiParameter[] plantedParams = plantedMethod.getParameterList().getParameters();
    if( extParams.length - 1 == plantedParams.length )
    {
      for( int i = 1; i < extParams.length; i++ )
      {
        PsiParameter extParam = extParams[i];
        PsiParameter plantedParam = plantedParams[i - 1];
        PsiType extErased = TypeConversionUtil.erasure( extParam.getType() );
        PsiType plantedErased = TypeConversionUtil.erasure( plantedParam.getType() );
        if( !extErased.toString().equals( plantedErased.toString() ) )
        {
          continue outer;
        }
      }
      return m.getNavigationElement();
    }
  }
  return null;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
private static boolean isAssignable( boolean structural, boolean covariant, PsiType to, PsiType from )
{
  if( to.equals( from ) )
  {
    return true;
  }

  if( structural )
  {
    return TypeConversionUtil.isAssignable( to, from ) ||
           arePrimitiveTypesAssignable( to, from ) ||
           isStructurallyAssignable( to, from, structural ) ||
           TypeConversionUtil.boxingConversionApplicable( to, from );
  }

  if( covariant )
  {
    TypeConversionUtil.isAssignable( to, from );
  }

  return false;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@Nullable
private static PsiType getCollectionComponentType(PsiType type, Project project) {
  if (!(type instanceof PsiClassType)) return null;
  PsiClassType classType = (PsiClassType) type;
  PsiClassType.ClassResolveResult result = classType.resolveGenerics();
  PsiClass clazz = result.getElement();
  if (clazz == null) return null;
  JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
  @SuppressWarnings({"ConstantConditions"}) PsiClass collectionClass = facade.findClass("java.util.Collection", type.getResolveScope());
  if (collectionClass == null || collectionClass.getTypeParameters().length != 1) return null;
  PsiSubstitutor substitutor = TypeConversionUtil.getClassSubstitutor(collectionClass, clazz, result.getSubstitutor());

  if (substitutor == null) return null;
  PsiType componentType = substitutor.substitute(collectionClass.getTypeParameters()[0]);
  return componentType instanceof PsiIntersectionType ? null : componentType;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
public static TypeConversionDescriptor wrapWithNewExpression(PsiType to, PsiType from, @Nullable PsiExpression expression, PsiElement context) {
  final String typeText = PsiDiamondTypeUtil.getCollapsedType(to, context);
  final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(to);
  final PsiClass atomicClass = resolveResult.getElement();
  LOG.assertTrue(atomicClass != null);
  final PsiTypeParameter[] typeParameters = atomicClass.getTypeParameters();
  if (typeParameters.length == 1) {
    final PsiType initial = resolveResult.getSubstitutor().substitute(typeParameters[0]);
    final PsiPrimitiveType unboxedInitialType = PsiPrimitiveType.getUnboxedType(initial);
    if (unboxedInitialType != null) {
      LOG.assertTrue(initial != null);
      if (from instanceof PsiPrimitiveType) {
        final PsiClassType boxedFromType = ((PsiPrimitiveType)from).getBoxedType(atomicClass);
        LOG.assertTrue(boxedFromType != null);
        if (!TypeConversionUtil.isAssignable(initial, boxedFromType)) {
          return new TypeConversionDescriptor("$val$", "new " + typeText + "((" + unboxedInitialType.getCanonicalText() + ")$val$)", expression);
        }
      }
    }
  }
  return new TypeConversionDescriptor("$val$", "new " + typeText + "($val$)", expression);
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
private static String getHandlerSignature(JavaFxEventHandlerReference ref) {
  final XmlAttributeValue element = ref.getElement();
  String canonicalText = JavaFxCommonClassNames.JAVAFX_EVENT;
  final PsiElement parent = element.getParent();
  if (parent instanceof XmlAttribute) {
    final XmlAttribute xmlAttribute = (XmlAttribute)parent;
    final Project project = element.getProject();
    final PsiField handlerField = ref.myCurrentTagClass.findFieldByName(xmlAttribute.getName(), true);
    if (handlerField != null) {
      final PsiClassType classType = JavaFxPsiUtil.getPropertyClassType(handlerField);
      if (classType != null) {
        final PsiClass eventHandlerClass = JavaPsiFacade.getInstance(project).findClass(JavaFxCommonClassNames.JAVAFX_EVENT_EVENT_HANDLER, GlobalSearchScope.allScope(project));
        final PsiTypeParameter[] typeParameters = eventHandlerClass != null ? eventHandlerClass.getTypeParameters() : null;
        if (typeParameters != null && typeParameters.length == 1) {
          final PsiTypeParameter typeParameter = typeParameters[0];
          final PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(eventHandlerClass, classType);
          final PsiType eventType = substitutor.substitute(typeParameter);
          if (eventType != null) {
            canonicalText = eventType.getCanonicalText();
          }
        }
      }
    }
  }
  return "public void " + element.getValue().substring(1) + "(" + canonicalText + " e)";
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@NonNls
@Nullable
public TypeConversionDescriptorBase findConversion(final PsiType from, final PsiType to, final PsiMember member, final PsiExpression context,
                                                   final boolean isCovariantPosition, final TypeMigrationLabeler labeler) {
  final TypeConversionDescriptorBase conversion = findConversion(from, to, member, context, labeler);
  if (conversion != null) return conversion;

  if (isCovariantPosition) {
    if (to instanceof PsiEllipsisType) {
      if (TypeConversionUtil.isAssignable(((PsiEllipsisType)to).getComponentType(), from)) return new TypeConversionDescriptorBase();
    }
    if (TypeConversionUtil.isAssignable(to, from)) return new TypeConversionDescriptorBase();
  }

  return !isCovariantPosition && TypeConversionUtil.isAssignable(from, to) ? new TypeConversionDescriptorBase() : null;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@Override
@Nullable
public ResolvedClass getTypeClass() {
  if (!TypeConversionUtil.isPrimitiveAndNotNull(myType)) {
    GlobalSearchScope resolveScope = myType.getResolveScope();
    if (resolveScope != null && resolveScope.getProject() != null) {
      ApplicationManager.getApplication().assertReadAccessAllowed();
      PsiClass aClass = JavaPsiFacade.getInstance(resolveScope.getProject()).findClass(getSignature(), resolveScope);
      if (aClass != null) {
        return new ResolvedPsiClass(aClass);
      }
    }
  }

  return null;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@Nullable
private static PsiType inferGenericArgType(@NotNull GrClosureSignature signature,
                                           @NotNull PsiType targetType,
                                           int genericIndex,
                                           int param) {
  if (targetType instanceof PsiClassType) {
    final PsiClassType.ClassResolveResult result = ((PsiClassType)targetType).resolveGenerics();
    final PsiClass psiClass = result.getElement();
    if (psiClass != null) {
      final PsiSubstitutor substitutor = result.getSubstitutor();

      final PsiType baseType = signature.getParameters()[param].getType();
      final PsiClass baseClass = PsiUtil.resolveClassInClassTypeOnly(baseType);

      if (baseClass != null && InheritanceUtil.isInheritorOrSelf(psiClass, baseClass, true)) {
        final PsiTypeParameter[] typeParameters = baseClass.getTypeParameters();
        if (genericIndex < typeParameters.length) {
          final PsiSubstitutor superClassSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(baseClass, psiClass, substitutor);
          return superClassSubstitutor.substitute(typeParameters[genericIndex]);
        }
      }
    }
  }
  return null;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
static VariablesProcessor findVariablesOfType(final PsiDeclarationStatement declaration, final PsiType type) {
  VariablesProcessor proc = new VariablesProcessor(false) {
    @Override
    protected boolean check(PsiVariable var, ResolveState state) {
      for (PsiElement element : declaration.getDeclaredElements()) {
        if (element == var) return false;
      }
      return TypeConversionUtil.isAssignable(var.getType(), type);
    }
  };
  PsiElement scope = declaration;
  while (scope != null) {
    if (scope instanceof PsiFile || 
        scope instanceof PsiMethod || 
        scope instanceof PsiLambdaExpression ||
        scope instanceof PsiClassInitializer) break;
    scope = scope.getParent();
  }
  if (scope == null) return proc;
  PsiScopesUtil.treeWalkUp(proc, declaration, scope);
  return proc;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@SuppressWarnings({"HardCodedStringLiteral"})
private static void appendJVMSignature(JVMNameBuffer buffer , PsiType type){
  if (type == null) {
    return;
  }
  final PsiType psiType = TypeConversionUtil.erasure(type);
  if (psiType instanceof PsiArrayType) {
    buffer.append(new JVMRawText("["));
    appendJVMSignature(buffer, ((PsiArrayType) psiType).getComponentType());
  }
  else if (psiType instanceof PsiClassType) {
    final JVMName jvmName = getJVMQualifiedName(psiType);
    appendJvmClassQualifiedName(buffer, jvmName);
  }
  else if (psiType instanceof PsiPrimitiveType) {
    buffer.append(getPrimitiveSignature(psiType.getCanonicalText()));
  }
  else {
    LOG.error("unknown type " + type.getCanonicalText());
  }
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
private boolean applyUnboxedRelation(DfaVariableValue dfaLeft, DfaValue dfaRight, boolean negated) {
  PsiType type = dfaLeft.getVariableType();
  if (!TypeConversionUtil.isPrimitiveWrapper(type)) {
    return true;
  }
  if (negated) {
    // from the fact "wrappers are not the same" it does not follow that "unboxed values are not equal"
    return true;
  }

  DfaBoxedValue.Factory boxedFactory = myFactory.getBoxedFactory();
  DfaValue unboxedLeft = boxedFactory.createUnboxed(dfaLeft);
  DfaValue unboxedRight = boxedFactory.createUnboxed(dfaRight);
  return applyRelation(unboxedLeft, unboxedRight, false) &&
         checkCompareWithBooleanLiteral(unboxedLeft, unboxedRight, false);
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@NotNull
public DfaConstValue createFromValue(Object value, final PsiType type, @Nullable PsiVariable constant) {
  if (value == Boolean.TRUE) return dfaTrue;
  if (value == Boolean.FALSE) return dfaFalse;

  if (TypeConversionUtil.isNumericType(type) && !TypeConversionUtil.isFloatOrDoubleType(type)) {
    value = TypeConversionUtil.computeCastTo(value, PsiType.LONG);
  }
  if (value instanceof Double || value instanceof Float) {
    double doubleValue = ((Number)value).doubleValue();
    if (doubleValue == -0.0) doubleValue = +0.0;
    value = new Double(doubleValue);
  }
  DfaConstValue instance = myValues.get(value);
  if (instance == null) {
    instance = new DfaConstValue(value, myFactory, constant);
    myValues.put(value, instance);
  }

  return instance;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
public static void register(HighlightInfo highlightInfo, PsiExpression expression, @NotNull PsiType lType) {
  if (lType != PsiType.NULL && expression instanceof PsiConditionalExpression) {
    final PsiExpression thenExpression = ((PsiConditionalExpression)expression).getThenExpression();
    final PsiExpression elseExpression = ((PsiConditionalExpression)expression).getElseExpression();
    if (thenExpression != null && elseExpression != null) {
      final PsiType thenType = thenExpression.getType();
      final PsiType elseType = elseExpression.getType();
      if (thenType != null && elseType != null) {
        final boolean thenAssignable = TypeConversionUtil.isAssignable(lType, thenType);
        final boolean elseAssignable = TypeConversionUtil.isAssignable(lType, elseType);
        if (!thenAssignable && thenExpression instanceof PsiMethodCallExpression) {
          inferTypeArgs(highlightInfo, lType, thenExpression);
        }
        if (!elseAssignable && elseExpression instanceof PsiMethodCallExpression) {
          inferTypeArgs(highlightInfo, lType, elseExpression);
        }
      }
    }
  }
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@Override
public boolean isMemberEnabled(GrMemberInfo member) {
  PsiClass currentSuperClass = getSuperClass();
  if(currentSuperClass == null) return true;
  if (myMemberInfoStorage.getDuplicatedMemberInfos(currentSuperClass).contains(member)) return false;
  if (myMemberInfoStorage.getExtending(currentSuperClass).contains(member.getMember())) return false;
  if (!currentSuperClass.isInterface()) return true;

  PsiElement element = member.getMember();
  if (element instanceof PsiClass && ((PsiClass) element).isInterface()) return true;
  if (element instanceof PsiField) {
    return ((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC);
  }
  if (element instanceof PsiMethod) {
    if (currentSuperClass.isInterface()) {
      final PsiSubstitutor superSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(currentSuperClass, myClass, PsiSubstitutor.EMPTY);
      final MethodSignature signature = ((PsiMethod)element).getSignature(superSubstitutor);
      final PsiMethod superClassMethod = MethodSignatureUtil.findMethodBySignature(currentSuperClass, signature, false);
      if (superClassMethod != null) return false;
    }
    return !((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC);
  }
  return true;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
private static boolean appendJvmSignature(@NonNull StringBuilder buffer, @Nullable PsiType type) {
  if (type == null) {
    return false;
  }
  final PsiType psiType = TypeConversionUtil.erasure(type);
  if (psiType instanceof PsiArrayType) {
    buffer.append('[');
    appendJvmSignature(buffer, ((PsiArrayType)psiType).getComponentType());
  }
  else if (psiType instanceof PsiClassType) {
    PsiClass resolved = ((PsiClassType)psiType).resolve();
    if (resolved == null) {
      return false;
    }
    if (!appendJvmTypeName(buffer, resolved)) {
      return false;
    }
  }
  else if (psiType instanceof PsiPrimitiveType) {
    buffer.append(JVMNameUtil.getPrimitiveSignature(psiType.getCanonicalText()));
  }
  else {
    return false;
  }
  return true;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@Nullable
private static PsiType getBroaderType(PsiType currentType, PsiType castType) {
  if (currentType != null) {
    if (castType != null) {
      if (TypeConversionUtil.isAssignable(castType, currentType)) {
        return castType;
      } else if (!TypeConversionUtil.isAssignable(currentType, castType)) {
        for (PsiType superType : castType.getSuperTypes()) {
          if (TypeConversionUtil.isAssignable(superType, currentType)) {
            return superType;
          }
        }
        return null;
      }
    }
  }
  else {
    return castType;
  }
  return currentType;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
private static void addInheritors(CompletionParameters parameters,
                                  final CompletionResultSet resultSet,
                                  final PsiClass referencedClass,
                                  final int parameterIndex) {
  final List<PsiClassType> typeList = Collections.singletonList((PsiClassType)TypeConversionUtil.typeParameterErasure(
    referencedClass.getTypeParameters()[parameterIndex]));
  JavaInheritorsGetter.processInheritors(parameters, typeList, resultSet.getPrefixMatcher(), new Consumer<PsiType>() {
    @Override
    public void consume(final PsiType type) {
      final PsiClass psiClass = PsiUtil.resolveClassInType(type);
      if (psiClass == null) return;

      resultSet.addElement(TailTypeDecorator.withTail(new JavaPsiClassReferenceElement(psiClass),
                                                      getTail(parameterIndex == referencedClass.getTypeParameters().length - 1)));
    }
  });
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@Override
public String getConflictMessage() {
  if (!TypeConversionUtil.isAssignable(myOriginalType, myTargetClassType)) {
    final String conflict = "No consistent substitution found for " +
                            getElement().getText() +
                            ". Expected \'" +
                            myOriginalType.getPresentableText() +
                            "\' but found \'" +
                            myTargetClassType.getPresentableText() +
                            "\'.";
    if (myConflict == null) {
      myConflict = conflict;
    } else {
      myConflict += "\n" + conflict;
    }
  }
  return myConflict;
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
  if (!myArrayAccessExpression.isValid()) return false;
  if (!TypeConversionUtil.areTypesAssignmentCompatible(PsiType.INT, myArrayAccessExpression.getIndexExpression())) {
    return false;
  }
  final PsiElement parent = myArrayAccessExpression.getParent();
  if (parent instanceof PsiAssignmentExpression) {
    final PsiExpression lExpression = ((PsiAssignmentExpression)parent).getLExpression();
    if (lExpression.equals(myArrayAccessExpression) && !(parent.getParent() instanceof PsiExpressionStatement)) {
      return false;
    }
  }

  final PsiExpression arrayExpression = myArrayAccessExpression.getArrayExpression();
  final PsiType type = arrayExpression.getType();
  final PsiType listType = createUtilListType(project);

  if (type == null || listType == null) return false;


  return listType.isAssignableFrom(type);
}
 

import com.intellij.psi.util.TypeConversionUtil; //导入依赖的package包/类
@Override
public boolean isAvailable(@NotNull Project project,
                           @NotNull PsiFile file,
                           @NotNull PsiElement startElement,
                           @NotNull PsiElement endElement) {
  final PsiMethod myMethod = (PsiMethod)startElement;

  PsiType myReturnType = myReturnTypePointer.getType();
  return myMethod.isValid()
      && myMethod.getManager().isInProject(myMethod)
      && myReturnType != null
      && myReturnType.isValid()
      && !TypeConversionUtil.isNullType(myReturnType)
      && myMethod.getReturnType() != null
      && !Comparing.equal(myReturnType, myMethod.getReturnType());
}