@NotNull
@Override
public MyResult weigh(@NotNull LookupElement item) {
final Object object = item.getObject();
if (object instanceof PsiClass) {
if (object instanceof PsiTypeParameter) return MyResult.typeParameter;
if (myTypeParameter != null
&& object.equals(
PsiUtil.resolveClassInType(
TypeConversionUtil.typeParameterErasure(myTypeParameter)))) {
return MyResult.exactlyExpected;
}
}
if (myExpectedTypes == null) return MyResult.normal;
PsiType itemType = JavaCompletionUtil.getLookupElementType(item);
if (itemType == null || !itemType.isValid()) return MyResult.normal;
if (object instanceof PsiClass) {
for (final ExpectedTypeInfo info : myExpectedTypes) {
if (TypeConversionUtil.erasure(info.getType().getDeepComponentType())
.equals(TypeConversionUtil.erasure(itemType))) {
return AbstractExpectedTypeSkipper.skips(item, myLocation)
? MyResult.expectedNoSelect
: MyResult.exactlyExpected;
}
}
}
for (final ExpectedTypeInfo expectedInfo : myExpectedTypes) {
final PsiType defaultType = expectedInfo.getDefaultType();
final PsiType expectedType = expectedInfo.getType();
if (!expectedType.isValid()) {
return MyResult.normal;
}
if (defaultType != expectedType) {
if (defaultType.equals(itemType)) {
return MyResult.exactlyDefault;
}
if (defaultType.isAssignableFrom(itemType)) {
return MyResult.ofDefaultType;
}
}
if (PsiType.VOID.equals(itemType) && PsiType.VOID.equals(expectedType)) {
return MyResult.exactlyExpected;
}
}
return MyResult.normal;
}
@Override
public boolean isValid() {
for (PsiType conjunct : myConjuncts) {
if (!conjunct.isValid()) return false;
}
return true;
}
@Override
public boolean isValid() {
for (PsiType type : mySubstitutionMap.values()) {
if (type != null && !type.isValid()) return false;
}
return true;
}
@Override
public boolean isValid() {
Collection<PsiType> substitutorValues = mySubstitutionMap.values();
for (PsiType type : substitutorValues) {
if (type != null && !type.isValid()) return false;
}
return true;
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return myType.isValid()
&& myExpression.isValid()
&& myExpression.getManager().isInProject(myExpression)
&& !TypeConversionUtil.isPrimitiveAndNotNull(myType)
&& (myType instanceof PsiArrayType || myExpression.getArgumentList() != null);
}
@NotNull
@Override
public PsiSubstitutor put(@NotNull PsiTypeParameter typeParameter, PsiType mapping) {
PsiSubstitutorImpl ret = clone();
if (mapping != null && !mapping.isValid()) {
LOG.error("Invalid type in substitutor: " + mapping + "; " + mapping.getClass());
}
ret.mySubstitutionMap.put(typeParameter, mapping);
return ret;
}
@Override
public boolean isAvailable(
@NotNull Project project,
@NotNull PsiFile file,
@NotNull PsiElement startElement,
@NotNull PsiElement endElement) {
return myType.isValid()
&& startElement.isValid()
&& startElement.getManager().isInProject(startElement);
}
@Override
public boolean isAvailable(
@NotNull Project project,
@NotNull PsiFile file,
@NotNull PsiElement startElement,
@NotNull PsiElement endElement) {
final PsiMethod myMethod = (PsiMethod) startElement;
final PsiType myReturnType = myReturnTypePointer.getType();
if (myMethod.isValid()
&& myMethod.getManager().isInProject(myMethod)
&& myReturnType != null
&& myReturnType.isValid()
&& !TypeConversionUtil.isNullType(myReturnType)) {
final PsiType returnType = myMethod.getReturnType();
if (returnType != null && returnType.isValid() && !Comparing.equal(myReturnType, returnType))
return true;
}
return false;
}
@Override
public PsiType visitWildcardType(PsiWildcardType wildcardType) {
final PsiType bound = wildcardType.getBound();
if (bound == null) {
return wildcardType;
} else {
final PsiType newBound = bound.accept(this);
if (newBound == null) {
return null;
}
assert newBound.isValid() : newBound.getClass() + "; " + bound.isValid();
if (newBound instanceof PsiWildcardType) {
final PsiType newBoundBound = ((PsiWildcardType) newBound).getBound();
return !((PsiWildcardType) newBound).isBounded()
? PsiWildcardType.createUnbounded(wildcardType.getManager())
: rebound(wildcardType, newBoundBound);
}
return newBound == PsiType.NULL ? newBound : rebound(wildcardType, newBound);
}
}
public static boolean isAvailable(
@Nullable PsiParameter myParameter, @Nullable PsiType type, @Nullable PsiClass targetClass) {
return myParameter != null
&& myParameter.isValid()
&& myParameter.getManager().isInProject(myParameter)
&& myParameter.getDeclarationScope() instanceof PsiMethod
&& ((PsiMethod) myParameter.getDeclarationScope()).getBody() != null
&& type != null
&& type.isValid()
&& targetClass != null
&& !targetClass.isInterface()
&& getParameterAssignedToField(myParameter) == null;
}
private PsiWildcardType rebound(PsiWildcardType type, PsiType newBound) {
LOG.assertTrue(type.getBound() != null);
LOG.assertTrue(newBound.isValid());
if (type.isExtends()) {
if (newBound.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) {
return PsiWildcardType.createUnbounded(type.getManager());
} else {
return PsiWildcardType.createExtends(type.getManager(), newBound);
}
} else {
return PsiWildcardType.createSuper(type.getManager(), newBound);
}
}
private static ExpectedTypeMatching getExpectedTypeMatching(
LookupElement item, ExpectedTypeInfo[] expectedInfos) {
PsiType itemType = JavaCompletionUtil.getLookupElementType(item);
if (itemType != null) {
PsiUtil.ensureValidType(itemType);
for (final ExpectedTypeInfo expectedInfo : expectedInfos) {
final PsiType defaultType = expectedInfo.getDefaultType();
final PsiType expectedType = expectedInfo.getType();
assert expectedType.isValid();
assert defaultType.isValid();
if (defaultType != expectedType && defaultType.isAssignableFrom(itemType)) {
return ExpectedTypeMatching.ofDefaultType;
}
if (expectedType.isAssignableFrom(itemType)) {
return ExpectedTypeMatching.expected;
}
}
}
if (hasNonVoid(expectedInfos)) {
if (item.getObject() instanceof PsiKeyword) {
String keyword = ((PsiKeyword) item.getObject()).getText();
if (PsiKeyword.NEW.equals(keyword) || PsiKeyword.NULL.equals(keyword)) {
return ExpectedTypeMatching.maybeExpected;
}
}
} else if (expectedInfos.length > 0) {
return ExpectedTypeMatching.unexpected;
}
return ExpectedTypeMatching.normal;
}
/**
* Returns the primitive type corresponding to a boxed class type.
*
* @param type the type to get the unboxed primitive type for.
* @return the primitive type, or null if the type does not represent a boxed primitive type.
*/
@Nullable
public static PsiPrimitiveType getUnboxedType(PsiType type) {
if (!(type instanceof PsiClassType)) return null;
LanguageLevel languageLevel = ((PsiClassType) type).getLanguageLevel();
if (!languageLevel.isAtLeast(LanguageLevel.JDK_1_5)) return null;
assert type.isValid() : type;
PsiClass psiClass = ((PsiClassType) type).resolve();
if (psiClass == null) return null;
PsiPrimitiveType unboxed = ourQNameToUnboxed.get(psiClass.getQualifiedName());
PsiAnnotation[] annotations = type.getAnnotations();
if (unboxed != null && annotations.length > 0) {
unboxed = new PsiPrimitiveType(unboxed.myName, annotations);
}
return unboxed;
}
private void putAllInternal(@NotNull PsiClass parentClass, PsiType[] mappings) {
final PsiTypeParameter[] params = parentClass.getTypeParameters();
for (int i = 0; i < params.length; i++) {
PsiTypeParameter param = params[i];
assert param != null;
if (mappings != null && mappings.length > i) {
PsiType mapping = mappings[i];
mySubstitutionMap.put(param, mapping);
if (mapping != null && !mapping.isValid()) {
LOG.error("Invalid type in substitutor: " + mapping);
}
} else {
mySubstitutionMap.put(param, null);
}
}
}
private DfaVariableValue(
@NotNull PsiModifierListOwner variable,
@Nullable PsiType varType,
boolean isNegated,
DfaValueFactory factory,
@Nullable DfaVariableValue qualifier) {
super(factory);
myVariable = variable;
myIsNegated = isNegated;
myQualifier = qualifier;
myVarType = varType;
DfaValue typeValue = myFactory.createTypeValue(varType, Nullness.UNKNOWN);
myTypeValue = typeValue instanceof DfaTypeValue ? (DfaTypeValue) typeValue : null;
if (varType != null && !varType.isValid()) {
PsiUtil.ensureValidType(
varType, "Variable: " + variable + " of class " + variable.getClass());
}
}
/** Types should be proceed by the callers themselves */
@Deprecated
public static PsiType normalizeWildcardTypeByPosition(
@NotNull PsiType type, @NotNull PsiExpression expression) {
PsiUtilCore.ensureValid(expression);
PsiUtil.ensureValidType(type);
PsiExpression topLevel = expression;
while (topLevel.getParent() instanceof PsiArrayAccessExpression
&& ((PsiArrayAccessExpression) topLevel.getParent()).getArrayExpression() == topLevel) {
topLevel = (PsiExpression) topLevel.getParent();
}
if (topLevel instanceof PsiArrayAccessExpression && !PsiUtil.isAccessedForWriting(topLevel)) {
return PsiUtil.captureToplevelWildcards(type, expression);
}
final PsiType normalized = doNormalizeWildcardByPosition(type, expression, topLevel);
LOG.assertTrue(normalized.isValid(), type);
if (normalized instanceof PsiClassType && !PsiUtil.isAccessedForWriting(topLevel)) {
return PsiUtil.captureToplevelWildcards(normalized, expression);
}
return normalized;
}
@Nullable
public <T extends PsiExpression> PsiType getType(
@NotNull T expr, @NotNull Function<T, PsiType> f) {
PsiType type = getCachedType(expr);
if (type == null) {
final RecursionGuard.StackStamp dStackStamp = PsiDiamondType.ourDiamondGuard.markStack();
final RecursionGuard.StackStamp gStackStamp = PsiResolveHelper.ourGraphGuard.markStack();
type = f.fun(expr);
if (!dStackStamp.mayCacheNow() || !gStackStamp.mayCacheNow()) {
return type;
}
if (type == null) type = TypeConversionUtil.NULL_TYPE;
Reference<PsiType> ref = new SoftReference<PsiType>(type);
myCalculatedTypes.put(expr, ref);
if (type instanceof PsiClassReferenceType) {
// convert reference-based class type to the PsiImmediateClassType, since the reference may
// become invalid
PsiClassType.ClassResolveResult result = ((PsiClassReferenceType) type).resolveGenerics();
PsiClass psiClass = result.getElement();
type =
psiClass == null
? type // for type with unresolved reference, leave it in the cache
// for clients still might be able to retrieve its getCanonicalText() from the
// reference text
: new PsiImmediateClassType(
psiClass,
result.getSubstitutor(),
((PsiClassReferenceType) type).getLanguageLevel(),
type.getAnnotations());
}
}
if (!type.isValid()) {
if (expr.isValid()) {
PsiJavaCodeReferenceElement refInside =
type instanceof PsiClassReferenceType
? ((PsiClassReferenceType) type).getReference()
: null;
@NonNls
String typeinfo =
type
+ " ("
+ type.getClass()
+ ")"
+ (refInside == null
? ""
: "; ref inside: "
+ refInside
+ " ("
+ refInside.getClass()
+ ") valid:"
+ refInside.isValid());
LOG.error(
"Type is invalid: "
+ typeinfo
+ "; expr: '"
+ expr
+ "' ("
+ expr.getClass()
+ ") is valid");
} else {
LOG.error("Expression: '" + expr + "' is invalid, must not be used for getType()");
}
}
return type == TypeConversionUtil.NULL_TYPE ? null : type;
}
private void buildText(
@NotNull PsiClass aClass,
@NotNull PsiSubstitutor substitutor,
@NotNull StringBuilder buffer,
boolean canonical,
boolean internal) {
if (aClass instanceof PsiAnonymousClass) {
ClassResolveResult baseResolveResult =
((PsiAnonymousClass) aClass).getBaseClassType().resolveGenerics();
PsiClass baseClass = baseResolveResult.getElement();
PsiSubstitutor baseSub = baseResolveResult.getSubstitutor();
if (baseClass != null) {
buildText(baseClass, baseSub, buffer, canonical, internal);
}
return;
}
if (canonical == internal) {
buffer.append(getAnnotationsTextPrefix(internal, false, true));
}
PsiClass enclosingClass = null;
if (!aClass.hasModifierProperty(PsiModifier.STATIC)) {
final PsiElement parent = aClass.getParent();
if (parent instanceof PsiClass && !(parent instanceof PsiAnonymousClass)) {
enclosingClass = (PsiClass) parent;
}
}
if (enclosingClass != null) {
buildText(enclosingClass, substitutor, buffer, canonical, false);
buffer.append('.');
buffer.append(aClass.getName());
} else {
final String name;
if (!canonical) {
name = aClass.getName();
} else {
final String qualifiedName = aClass.getQualifiedName();
if (qualifiedName == null) {
name = aClass.getName();
} else {
name = qualifiedName;
}
}
buffer.append(name);
}
PsiTypeParameter[] typeParameters = aClass.getTypeParameters();
if (typeParameters.length > 0) {
StringBuilder pineBuffer = new StringBuilder();
pineBuffer.append('<');
for (int i = 0; i < typeParameters.length; i++) {
PsiTypeParameter typeParameter = typeParameters[i];
assert typeParameter.isValid();
if (i > 0) pineBuffer.append(',');
final PsiType substitutionResult = substitutor.substitute(typeParameter);
if (substitutionResult == null) {
pineBuffer = null;
break;
}
assert substitutionResult.isValid();
if (canonical) {
if (internal) {
pineBuffer.append(substitutionResult.getInternalCanonicalText());
} else {
pineBuffer.append(substitutionResult.getCanonicalText());
}
} else {
pineBuffer.append(substitutionResult.getPresentableText());
}
}
if (pineBuffer != null) {
buffer.append(pineBuffer);
buffer.append('>');
}
}
}
public boolean isValid() {
return (myType == null || myType.isValid())
&& (myDefaultInitializer == null || myDefaultInitializer.isValid());
}
protected void performRefactoring(UsageInfo[] usages) {
try {
PsiElementFactory factory =
JavaPsiFacade.getInstance(myManager.getProject()).getElementFactory();
PsiType initializerType =
getInitializerType(myForcedType, myParameterInitializer, myLocalVariable);
setForcedType(initializerType);
// Converting myParameterInitializer
if (myParameterInitializer == null) {
LOG.assertTrue(myLocalVariable != null);
myParameterInitializer =
factory.createExpressionFromText(myLocalVariable.getName(), myLocalVariable);
} else if (myParameterInitializer instanceof PsiArrayInitializerExpression) {
final PsiExpression newExprArrayInitializer =
RefactoringUtil.createNewExpressionFromArrayInitializer(
(PsiArrayInitializerExpression) myParameterInitializer, initializerType);
myParameterInitializer =
(PsiExpression) myParameterInitializer.replace(newExprArrayInitializer);
}
myInitializerWrapper = new JavaExpressionWrapper(myParameterInitializer);
// Changing external occurences (the tricky part)
IntroduceParameterUtil.processUsages(usages, this);
if (myGenerateDelegate) {
generateDelegate(myMethodToReplaceIn);
if (myMethodToReplaceIn != myMethodToSearchFor) {
final PsiMethod method = generateDelegate(myMethodToSearchFor);
if (method.getContainingClass().isInterface()) {
final PsiCodeBlock block = method.getBody();
if (block != null) {
block.delete();
}
}
}
}
// Changing signature of initial method
// (signature of myMethodToReplaceIn will be either changed now or have already been changed)
LOG.assertTrue(initializerType.isValid());
final FieldConflictsResolver fieldConflictsResolver =
new FieldConflictsResolver(myParameterName, myMethodToReplaceIn.getBody());
IntroduceParameterUtil.changeMethodSignatureAndResolveFieldConflicts(
new UsageInfo(myMethodToReplaceIn), usages, this);
if (myMethodToSearchFor != myMethodToReplaceIn) {
IntroduceParameterUtil.changeMethodSignatureAndResolveFieldConflicts(
new UsageInfo(myMethodToSearchFor), usages, this);
}
ChangeContextUtil.clearContextInfo(myParameterInitializer);
// Replacing expression occurrences
for (UsageInfo usage : usages) {
if (usage instanceof ChangedMethodCallInfo) {
PsiElement element = usage.getElement();
processChangedMethodCall(element);
} else if (usage instanceof InternalUsageInfo) {
PsiElement element = usage.getElement();
if (element instanceof PsiExpression) {
element = RefactoringUtil.outermostParenthesizedExpression((PsiExpression) element);
}
if (element != null) {
if (element.getParent() instanceof PsiExpressionStatement) {
element.getParent().delete();
} else {
PsiExpression newExpr = factory.createExpressionFromText(myParameterName, element);
IntroduceVariableBase.replace((PsiExpression) element, newExpr, myProject);
}
}
}
}
if (myLocalVariable != null && myRemoveLocalVariable) {
myLocalVariable.normalizeDeclaration();
myLocalVariable.getParent().delete();
}
fieldConflictsResolver.fix();
} catch (IncorrectOperationException ex) {
LOG.error(ex);
}
}
@Override
protected void performRefactoring(UsageInfo[] usages) {
GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(myProject);
PsiType initializerType = mySettings.getSelectedType();
// Changing external occurrences (the tricky part)
IntroduceParameterUtil.processUsages(usages, this);
final GrMethod toReplaceIn = (GrMethod) mySettings.getToReplaceIn();
final PsiMethod toSearchFor = (PsiMethod) mySettings.getToSearchFor();
final boolean methodsToProcessAreDifferent = toReplaceIn != toSearchFor;
if (mySettings.generateDelegate()) {
GroovyIntroduceParameterUtil.generateDelegate(toReplaceIn, myParameterInitializer, myProject);
if (methodsToProcessAreDifferent) {
final GrMethod method =
GroovyIntroduceParameterUtil.generateDelegate(
toSearchFor, myParameterInitializer, myProject);
final PsiClass containingClass = method.getContainingClass();
if (containingClass != null && containingClass.isInterface()) {
final GrOpenBlock block = method.getBlock();
if (block != null) {
block.delete();
}
}
}
}
// Changing signature of initial method
// (signature of myMethodToReplaceIn will be either changed now or have already been changed)
LOG.assertTrue(initializerType == null || initializerType.isValid());
final FieldConflictsResolver fieldConflictsResolver =
new FieldConflictsResolver(mySettings.getName(), toReplaceIn.getBlock());
IntroduceParameterUtil.changeMethodSignatureAndResolveFieldConflicts(
new UsageInfo(toReplaceIn), usages, this);
if (methodsToProcessAreDifferent) {
IntroduceParameterUtil.changeMethodSignatureAndResolveFieldConflicts(
new UsageInfo(toSearchFor), usages, this);
}
// Replacing expression occurrences
for (UsageInfo usage : usages) {
if (usage instanceof ChangedMethodCallInfo) {
PsiElement element = usage.getElement();
GroovyIntroduceParameterUtil.processChangedMethodCall(element, mySettings, myProject);
} else if (usage instanceof InternalUsageInfo) {
PsiElement element = usage.getElement();
if (element == null) continue;
GrExpression newExpr = factory.createExpressionFromText(mySettings.getName());
if (element instanceof GrExpression) {
((GrExpression) element).replaceWithExpression(newExpr, true);
} else {
element.replace(newExpr);
}
}
}
final StringPartInfo stringPartInfo = mySettings.getStringPartInfo();
if (stringPartInfo != null) {
final GrExpression expr =
GrIntroduceHandlerBase.processLiteral(
mySettings.getName(), mySettings.getStringPartInfo(), mySettings.getProject());
final Editor editor = PsiUtilBase.findEditor(expr);
if (editor != null) {
editor.getSelectionModel().removeSelection();
editor.getCaretModel().moveToOffset(expr.getTextRange().getEndOffset());
}
}
final GrVariable var = mySettings.getVar();
if (var != null && mySettings.removeLocalVariable()) {
var.delete();
}
fieldConflictsResolver.fix();
}