@Override public void visitCaseSection(GrCaseSection caseSection) { for (GrCaseLabel label : caseSection.getCaseLabels()) { GrExpression value = label.getValue(); if (value != null) { value.accept(this); } } final GrStatement[] statements = caseSection.getStatements(); // infer 'may be return' position int i; for (i = statements.length - 1; i >= 0 && statements[i] instanceof GrBreakStatement; i--) {} for (int j = 0; j < statements.length; j++) { GrStatement statement = statements[j]; statement.accept(this); if (j == i) handlePossibleReturn(statement); } if (myHead != null) { addPendingEdge(caseSection, myHead); } }
@Override public void visitUnaryExpression(GrUnaryExpression expression) { final GrExpression operand = expression.getOperand(); if (operand == null) return; if (expression.getOperationTokenType() != mLNOT) { operand.accept(this); visitCall(expression); return; } ConditionInstruction cond = new ConditionInstruction(expression); addNodeAndCheckPending(cond); registerCondition(cond); operand.accept(this); visitCall(expression); myConditions.removeFirstOccurrence(cond); List<GotoInstruction> negations = collectAndRemoveAllPendingNegations(expression); InstructionImpl head = myHead; addNodeAndCheckPending(new PositiveGotoInstruction(expression, cond)); handlePossibleReturn(expression); addPendingEdge(expression, myHead); if (negations.isEmpty()) { myHead = head; } else { myHead = reduceAllNegationsIntoInstruction(expression, negations); } }
public GrExpression fixInitializer(GrExpression initializer) { if (myField == null) return initializer; final GrReferenceExpression[] replacedRef = {null}; initializer.accept( new GroovyRecursiveElementVisitor() { @Override public void visitReferenceExpression(GrReferenceExpression expression) { final GrExpression qualifierExpression = expression.getQualifier(); if (qualifierExpression != null) { qualifierExpression.accept(this); } else { final PsiElement result = expression.resolve(); if (expression.getManager().areElementsEquivalent(result, myField)) { try { replacedRef[0] = qualifyReference(expression, myField, myQualifyingClass); } catch (IncorrectOperationException e) { LOG.error(e); } } } } }); if (!initializer.isValid()) return replacedRef[0]; return initializer; }
public void visitAssertStatement(GrAssertStatement assertStatement) { final InstructionImpl assertInstruction = startNode(assertStatement); final GrExpression assertion = assertStatement.getAssertion(); if (assertion != null) { assertion.accept(this); InstructionImpl positiveHead = myHead; List<GotoInstruction> negations = collectAndRemoveAllPendingNegations(assertStatement); if (!negations.isEmpty()) { interruptFlow(); reduceAllNegationsIntoInstruction(assertStatement, negations); } GrExpression errorMessage = assertStatement.getErrorMessage(); if (errorMessage != null) { errorMessage.accept(this); } addNode(new ThrowingInstruction(assertStatement)); final PsiType type = TypesUtil.createTypeByFQClassName( CommonClassNames.JAVA_LANG_ASSERTION_ERROR, assertStatement); ExceptionInfo info = findCatch(type); if (info != null) { info.myThrowers.add(myHead); } else { addPendingEdge(null, myHead); } myHead = positiveHead; } finishNode(assertInstruction); }
public static GrStatement replaceStatement( GrStatementOwner declarationOwner, ExtractInfoHelper helper) { GrStatement realStatement; if (declarationOwner != null && !isSingleExpression(helper.getStatements())) { // Replace set of statements final GrStatement[] newStatement = createResultStatement(helper); // add call statement final GrStatement[] statements = helper.getStatements(); LOG.assertTrue(statements.length > 0); realStatement = null; for (GrStatement statement : newStatement) { realStatement = declarationOwner.addStatementBefore(statement, statements[0]); GrReferenceAdjuster.shortenReferences(realStatement); } LOG.assertTrue(realStatement != null); // remove old statements removeOldStatements(declarationOwner, helper); PsiImplUtil.removeNewLineAfter(realStatement); } else { // Expression call replace GrExpression methodCall = createMethodCall(helper); GrExpression oldExpr = (GrExpression) helper.getStatements()[0]; realStatement = oldExpr.replaceWithExpression(methodCall, true); GrReferenceAdjuster.shortenReferences(realStatement); } return realStatement; }
@Nullable private static PsiType getTypeFromMapAccess(@NotNull GrReferenceExpressionImpl ref) { // map access GrExpression qualifier = ref.getQualifierExpression(); if (qualifier != null) { PsiType qType = qualifier.getNominalType(); if (qType instanceof PsiClassType) { PsiClassType.ClassResolveResult qResult = ((PsiClassType) qType).resolveGenerics(); PsiClass clazz = qResult.getElement(); if (clazz != null) { PsiClass mapClass = JavaPsiFacade.getInstance(ref.getProject()) .findClass(CommonClassNames.JAVA_UTIL_MAP, ref.getResolveScope()); if (mapClass != null && mapClass.getTypeParameters().length == 2) { PsiSubstitutor substitutor = TypeConversionUtil.getClassSubstitutor(mapClass, clazz, qResult.getSubstitutor()); if (substitutor != null) { return TypeConversionUtil.erasure( substitutor.substitute(mapClass.getTypeParameters()[1])); } } } } } return null; }
private void fixReferencesToStatic(GroovyPsiElement classMember, Set<PsiMember> movedMembers) throws IncorrectOperationException { final StaticReferencesCollector collector = new StaticReferencesCollector(movedMembers); classMember.accept(collector); ArrayList<GrReferenceElement> refs = collector.getReferences(); ArrayList<PsiElement> members = collector.getReferees(); ArrayList<PsiClass> classes = collector.getRefereeClasses(); GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(myProject); for (int i = 0; i < refs.size(); i++) { GrReferenceElement ref = refs.get(i); PsiElement namedElement = members.get(i); PsiClass aClass = classes.get(i); if (namedElement instanceof PsiNamedElement) { GrReferenceExpression newRef = (GrReferenceExpression) factory.createExpressionFromText( "a." + ((PsiNamedElement) namedElement).getName(), null); GrExpression qualifier = newRef.getQualifierExpression(); assert qualifier != null; qualifier = (GrExpression) qualifier.replace( factory.createReferenceExpressionFromText(aClass.getQualifiedName())); qualifier.putCopyableUserData(PRESERVE_QUALIFIER, ref.isQualified()); PsiElement replaced = ref.replace(newRef); JavaCodeStyleManager.getInstance(myProject).shortenClassReferences(replaced); } } }
@Override public GroovyResolveResult[] resolve( GrAssignmentExpressionImpl assignmentExpression, boolean incompleteCode) { final IElementType opType = assignmentExpression.getOperationToken(); if (opType == null || opType == GroovyTokenTypes.mASSIGN) return GroovyResolveResult.EMPTY_ARRAY; final GrExpression lValue = assignmentExpression.getLValue(); final PsiType lType; if (!(lValue instanceof GrIndexProperty)) { lType = lValue.getType(); } else { /* now we have something like map[i] += 2. It equals to map.putAt(i, map.getAt(i).plus(2)) by default map[i] resolves to putAt, but we need getAt(). so this hack is for it =) */ lType = ((GrExpression) lValue.copy()).getType(); } if (lType == null) return GroovyResolveResult.EMPTY_ARRAY; final GrExpression rightOperand = assignmentExpression.getRValue(); PsiType rType = rightOperand == null ? null : rightOperand.getType(); final IElementType operatorToken = TokenSets.ASSIGNMENTS_TO_OPERATORS.get(opType); return TypesUtil.getOverloadedOperatorCandidates( lType, operatorToken, assignmentExpression, new PsiType[] {rType}); }
@Nullable private static PsiType doNormalizeWildcardByPosition( final PsiType type, final GrExpression expression, final GrExpression toplevel) { if (type instanceof PsiCapturedWildcardType) { return doNormalizeWildcardByPosition( ((PsiCapturedWildcardType) type).getWildcard(), expression, toplevel); } if (type instanceof PsiWildcardType) { final PsiWildcardType wildcardType = (PsiWildcardType) type; if (PsiUtil.isAccessedForWriting(toplevel)) { return wildcardType.isSuper() ? wildcardType.getBound() : PsiCapturedWildcardType.create(wildcardType, expression); } else { if (wildcardType.isExtends()) { return wildcardType.getBound(); } else { return PsiType.getJavaLangObject(expression.getManager(), expression.getResolveScope()); } } } else if (type instanceof PsiArrayType) { final PsiType componentType = ((PsiArrayType) type).getComponentType(); final PsiType normalizedComponentType = doNormalizeWildcardByPosition(componentType, expression, toplevel); if (normalizedComponentType != componentType) { assert normalizedComponentType != null; return normalizedComponentType.createArrayType(); } } return type; }
@Nullable private static PsiType getInferredTypes( GrReferenceExpressionImpl refExpr, @Nullable PsiElement resolved) { final GrExpression qualifier = refExpr.getQualifier(); if (qualifier == null && !(resolved instanceof PsiClass)) { return TypeInferenceHelper.getCurrentContext().getVariableType(refExpr); } else if (qualifier != null) { // map access PsiType qType = qualifier.getType(); if (qType instanceof PsiClassType && !(qType instanceof GrMapType)) { PsiClassType.ClassResolveResult qResult = ((PsiClassType) qType).resolveGenerics(); PsiClass clazz = qResult.getElement(); if (clazz != null) { PsiClass mapClass = JavaPsiFacade.getInstance(refExpr.getProject()) .findClass(CommonClassNames.JAVA_UTIL_MAP, refExpr.getResolveScope()); if (mapClass != null && mapClass.getTypeParameters().length == 2) { PsiSubstitutor substitutor = TypeConversionUtil.getClassSubstitutor(mapClass, clazz, qResult.getSubstitutor()); if (substitutor != null) { return TypeConversionUtil.erasure( substitutor.substitute(mapClass.getTypeParameters()[1])); } } } } } return null; }
@Nullable @Override public PsiType fun(GrUnaryExpressionImpl unary) { final GroovyResolveResult resolveResult = PsiImplUtil.extractUniqueResult(unary.multiResolve(false)); if (isIncDecNumber(resolveResult)) { return unary.getOperand().getType(); } final PsiType substituted = ResolveUtil.extractReturnTypeFromCandidate(resolveResult, unary, PsiType.EMPTY_ARRAY); if (substituted != null) { return substituted; } GrExpression operand = unary.getOperand(); if (operand == null) return null; final PsiType type = operand.getType(); if (TypesUtil.isNumericType(type)) { return type; } return null; }
@Override public void visitBinaryExpression(GrBinaryExpression expression) { super.visitBinaryExpression(expression); if (expression.getOperationTokenType() != GroovyTokenTypes.kIN) return; GrExpression leftOperand = expression.getLeftOperand(); GrExpression rightOperand = expression.getRightOperand(); if (leftOperand == null || rightOperand == null) return; PsiType ltype = leftOperand.getType(); PsiType rtype = rightOperand.getType(); if (ltype == null || rtype == null) return; PsiType component; if (rtype instanceof PsiArrayType) { component = ((PsiArrayType) rtype).getComponentType(); } else if (InheritanceUtil.isInheritor(rtype, CommonClassNames.JAVA_UTIL_COLLECTION)) { component = PsiUtil.substituteTypeParameter(rtype, CommonClassNames.JAVA_UTIL_COLLECTION, 0, false); } else { checkSimpleClasses(ltype, rtype, expression); return; } if (component == null) return; if (TypesUtil.isAssignable( ltype, component, expression.getManager(), expression.getResolveScope(), false)) return; registerError(expression, ltype, rtype); }
@Override public void visitBinaryExpression(GrBinaryExpression expression) { final IElementType type = expression.getOperationTokenType(); final GrExpression left = expression.getLeftOperand(); final GrExpression right = expression.getRightOperand(); if (type == mREGEX_FIND || type == mREGEX_MATCH) { final PsiClassType string = TypesUtil.createType(CommonClassNames.JAVA_LANG_STRING, expression); myResult = createSimpleSubTypeResult(string); return; } final GrExpression other = myExpression == left ? right : left; final PsiType otherType = other != null ? other.getType() : null; if (otherType == null) return; if (type == mPLUS && otherType.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { final PsiClassType obj = TypesUtil.getJavaLangObject(expression); myResult = createSimpleSubTypeResult(obj); return; } myResult = createSimpleSubTypeResult(otherType); }
@Override public void visitMethodCallExpression(GrMethodCallExpression grMethodCallExpression) { super.visitMethodCallExpression(grMethodCallExpression); final GrArgumentList args = grMethodCallExpression.getArgumentList(); if (args.getExpressionArguments().length != 1) { return; } if (PsiImplUtil.hasNamedArguments(args)) { return; } final GrExpression methodExpression = grMethodCallExpression.getInvokedExpression(); if (!(methodExpression instanceof GrReferenceExpression)) { return; } final GrReferenceExpression referenceExpression = (GrReferenceExpression) methodExpression; final String name = referenceExpression.getReferenceName(); if (!"get".equals(name)) { return; } final GrExpression qualifier = referenceExpression.getQualifierExpression(); if (qualifier == null || PsiUtil.isThisOrSuperRef(qualifier)) { return; } if (referenceExpression.getDotTokenType() == GroovyTokenTypes.mOPTIONAL_DOT) return; final PsiType type = qualifier.getType(); if (!InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_MAP)) { return; } registerMethodCallError(grMethodCallExpression); }
@Nullable public static PsiType getNumericResultType(GrBinaryExpression binaryExpression) { PsiType lType = binaryExpression.getLeftOperand().getType(); final GrExpression rop = binaryExpression.getRightOperand(); PsiType rType = rop == null ? null : rop.getType(); if (lType == null || rType == null) return null; return getLeastUpperBoundForNumericType(lType, rType); }
@Override protected void processIntention(@NotNull PsiElement element, Project project, Editor editor) throws IncorrectOperationException { PsiElement parent = element.getParent(); if (!"if".equals(element.getText()) || !(parent instanceof GrIfStatement)) { throw new IncorrectOperationException("Not invoked on an if"); } GrIfStatement parentIf = (GrIfStatement) parent; GroovyPsiElementFactory groovyPsiElementFactory = GroovyPsiElementFactory.getInstance(project); GrExpression condition = parentIf.getCondition(); if (condition == null) { throw new IncorrectOperationException("Invoked on an if with empty condition"); } GrExpression negatedCondition = null; if (condition instanceof GrUnaryExpression) { GrUnaryExpression unaryCondition = (GrUnaryExpression) condition; if ("!".equals(unaryCondition.getOperationToken().getText())) { negatedCondition = stripParenthesis(unaryCondition.getOperand()); } } if (negatedCondition == null) { // Now check whether this is a simple expression condition = stripParenthesis(condition); String negatedExpressionText; if (condition instanceof GrCallExpression || condition instanceof GrReferenceExpression) { negatedExpressionText = "!" + condition.getText(); } else { negatedExpressionText = "!(" + condition.getText() + ")"; } negatedCondition = groovyPsiElementFactory.createExpressionFromText(negatedExpressionText, parentIf); } GrStatement thenBranch = parentIf.getThenBranch(); final boolean thenIsNotEmpty = isNotEmpty(thenBranch); String newIfText = "if (" + negatedCondition.getText() + ") {}"; if (thenIsNotEmpty) { newIfText += " else {}"; } GrIfStatement newIf = (GrIfStatement) groovyPsiElementFactory.createStatementFromText(newIfText, parentIf.getContext()); generateElseBranchTextAndRemoveTailStatements(parentIf, newIf); if (thenIsNotEmpty) { final GrStatement elseBranch = newIf.getElseBranch(); assert elseBranch != null; elseBranch.replaceWithStatement(thenBranch); } parentIf.replace(newIf); }
@Override protected void processIntention(@NotNull PsiElement element, Project project, Editor editor) throws IncorrectOperationException { final GrMethodCallExpression expression = (GrMethodCallExpression) element; final GrClosableBlock block = expression.getClosureArguments()[0]; final GrParameterList parameterList = block.getParameterList(); final GrParameter[] parameters = parameterList.getParameters(); String var; if (parameters.length == 1) { var = parameters[0].getText(); var = StringUtil.replace(var, GrModifier.DEF, ""); } else { var = "it"; } final GrExpression invokedExpression = expression.getInvokedExpression(); GrExpression qualifier = ((GrReferenceExpression) invokedExpression).getQualifierExpression(); final GroovyPsiElementFactory elementFactory = GroovyPsiElementFactory.getInstance(element.getProject()); if (qualifier == null) { qualifier = elementFactory.createExpressionFromText("this"); } StringBuilder builder = new StringBuilder(); builder.append("for (").append(var).append(" in ").append(qualifier.getText()).append(") {\n"); String text = block.getText(); final PsiElement blockArrow = block.getArrow(); int index; if (blockArrow != null) { index = blockArrow.getStartOffsetInParent() + blockArrow.getTextLength(); } else { index = 1; } while (index < text.length() && Character.isWhitespace(text.charAt(index))) index++; text = text.substring(index, text.length() - 1); builder.append(text); builder.append("}"); final GrStatement statement = elementFactory.createStatementFromText(builder.toString()); GrForStatement forStatement = (GrForStatement) expression.replaceWithStatement(statement); final GrForClause clause = forStatement.getClause(); GrVariable variable = clause.getDeclaredVariable(); forStatement = updateReturnStatements(forStatement); if (variable == null) return; if (ApplicationManager.getApplication().isUnitTestMode()) return; final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project); final Document doc = documentManager.getDocument(element.getContainingFile()); if (doc == null) return; documentManager.doPostponedOperationsAndUnblockDocument(doc); editor.getCaretModel().moveToOffset(variable.getTextOffset()); new VariableInplaceRenamer(variable, editor).performInplaceRename(); }
public static PsiExpression getOrCreatePisExpression(GrExpression expr) { if (expr == null) return null; final SoftReference<PsiExpression> ref = expr.getUserData(PSI_EXPRESSION); final PsiExpression element = ref == null ? null : ref.get(); if (element != null) return element; final GrSyntheticExpression newExpr = new GrSyntheticExpression(expr); expr.putUserData(PSI_EXPRESSION, new SoftReference<PsiExpression>(newExpr)); return newExpr; }
private static PsiType doFun(GrReferenceExpression refExpr) { if (ResolveUtil.isClassReference(refExpr)) { GrExpression qualifier = refExpr.getQualifier(); LOG.assertTrue(qualifier != null); return TypesUtil.createJavaLangClassType( qualifier.getType(), refExpr.getProject(), refExpr.getResolveScope()); } if (PsiUtil.isCompileStatic(refExpr)) { final GroovyResolveResult resolveResult = refExpr.advancedResolve(); final PsiElement resolvedF = resolveResult.getElement(); final PsiType type; if (resolvedF instanceof GrField) { type = ((GrField) resolvedF).getType(); } else if (resolvedF instanceof GrAccessorMethod) { type = ((GrAccessorMethod) resolvedF).getProperty().getType(); } else { type = null; } if (type != null) { return resolveResult.getSubstitutor().substitute(type); } } final PsiElement resolved = refExpr.resolve(); final PsiType nominal = refExpr.getNominalType(); Boolean reassigned = GrReassignedLocalVarsChecker.isReassignedVar(refExpr); if (reassigned != null && reassigned.booleanValue()) { return GrReassignedLocalVarsChecker.getReassignedVarType(refExpr, true); } final PsiType inferred = getInferredTypes(refExpr, resolved); if (inferred == null) { if (nominal == null) { // inside nested closure we could still try to infer from variable initializer. Not sound, // but makes sense if (resolved instanceof GrVariable) { LOG.assertTrue(resolved.isValid()); return ((GrVariable) resolved).getTypeGroovy(); } } return nominal; } if (nominal == null) return inferred; if (!TypeConversionUtil.isAssignable(TypeConversionUtil.erasure(nominal), inferred, false)) { if (resolved instanceof GrVariable && ((GrVariable) resolved).getTypeElementGroovy() != null) { return nominal; } } return inferred; }
public void visitIfStatement(GrIfStatement ifStatement) { if (myExpression.equals(ifStatement.getCondition())) { myResult = new TypeConstraint[] { new SubtypeConstraint(TypesUtil.getJavaLangObject(ifStatement), PsiType.BOOLEAN) }; } else if (myExpression.equals(ifStatement.getThenBranch()) || myExpression.equals(ifStatement.getElseBranch())) { checkExitPoint(); } }
private static String calculateReplacementExpression(GrConditionalExpression exp) { final GrExpression thenExpression = exp.getThenBranch(); final GrExpression elseExpression = exp.getElseBranch(); final GrExpression condition = exp.getCondition(); if (isFalse(thenExpression) && isTrue(elseExpression)) { return BoolUtils.getNegatedExpressionText(condition); } else { return condition.getText(); } }
@Override public void visitCaseLabel(GrCaseLabel caseLabel) { final PsiElement parent = caseLabel.getParent().getParent(); assert parent instanceof GrSwitchStatement : parent + " of class " + parent.getClass(); final GrExpression condition = ((GrSwitchStatement) parent).getCondition(); if (condition == null) return; final PsiType type = condition.getType(); if (type == null) return; myResult = new TypeConstraint[] {SubtypeConstraint.create(type)}; }
public static GrTypeComboBox createTypeComboBoxFromExpression(GrExpression expression) { PsiType type = expression.getType(); if (GroovyRefactoringUtil.isDiamondNewOperator(expression)) { LOG.assertTrue(expression instanceof GrNewExpression); PsiType expected = PsiImplUtil.inferExpectedTypeForDiamond(expression); return createTypeComboboxFromBounds( type, expected, expression.getManager(), expression.getResolveScope()); } else { return createTypeComboBoxWithDefType(type); } }
private void getVariantsFromQualifier(@NotNull GrExpression qualifier) { Project project = qualifier.getProject(); PsiType qualifierType = qualifier.getType(); final ResolveState state = ResolveState.initial(); if (qualifierType == null || qualifierType == PsiType.VOID) { if (qualifier instanceof GrReferenceExpression) { PsiElement resolved = ((GrReferenceExpression) qualifier).resolve(); if (resolved instanceof PsiPackage || resolved instanceof PsiVariable) { resolved.processDeclarations(myProcessor, state, null, myRefExpr); return; } } getVariantsFromQualifierType(TypesUtil.getJavaLangObject(qualifier), project); } else if (qualifierType instanceof PsiIntersectionType) { for (PsiType conjunct : ((PsiIntersectionType) qualifierType).getConjuncts()) { getVariantsFromQualifierType(conjunct, project); } } else if (qualifierType instanceof GrTraitType) { GrTypeDefinition definition = ((GrTraitType) qualifierType).getMockTypeDefinition(); if (definition != null) { PsiClassType classType = JavaPsiFacade.getElementFactory(project).createType(definition); getVariantsFromQualifierType(classType, project); } else { getVariantsFromQualifierType(((GrTraitType) qualifierType).getExprType(), project); for (PsiClassType traitType : ((GrTraitType) qualifierType).getTraitTypes()) { getVariantsFromQualifierType(traitType, project); } } } else { getVariantsFromQualifierType(qualifierType, project); if (qualifier instanceof GrReferenceExpression && !PsiUtil.isSuperReference(qualifier) && !PsiUtil.isInstanceThisRef(qualifier)) { PsiElement resolved = ((GrReferenceExpression) qualifier).resolve(); if (resolved instanceof PsiClass) { // //omitted .class GlobalSearchScope scope = myRefExpr.getResolveScope(); PsiClass javaLangClass = PsiUtil.getJavaLangClass(resolved, scope); if (javaLangClass != null) { PsiSubstitutor substitutor = PsiSubstitutor.EMPTY; PsiTypeParameter[] typeParameters = javaLangClass.getTypeParameters(); if (typeParameters.length == 1) { substitutor = substitutor.put(typeParameters[0], qualifierType); } PsiType javaLangClassType = JavaPsiFacade.getElementFactory(myRefExpr.getProject()) .createType(javaLangClass, substitutor); ResolveUtil.processAllDeclarations(javaLangClassType, myProcessor, state, myRefExpr); } } } } }
@Override protected void processIntention(@NotNull PsiElement element, Project project, Editor editor) throws IncorrectOperationException { if (!(element instanceof GrConditionalExpression)) { throw new IncorrectOperationException("Not invoked on a conditional"); } GroovyPsiElementFactory groovyPsiElementFactory = GroovyPsiElementFactory.getInstance(project); GrConditionalExpression condExp = (GrConditionalExpression) element; GrExpression thenBranch = condExp.getThenBranch(); GrExpression elseBranch = condExp.getElseBranch(); Object thenVal = GroovyConstantExpressionEvaluator.evaluate(thenBranch); if (Boolean.TRUE.equals(thenVal) && elseBranch != null) { // aaa ? true : bbb -> aaa || bbb GrExpression conditionExp = condExp.getCondition(); String conditionExpText = getStringToPutIntoOrExpression(conditionExp); String elseExpText = getStringToPutIntoOrExpression(elseBranch); String newExp = conditionExpText + "||" + elseExpText; int caretOffset = conditionExpText.length() + 2; // after "||" GrExpression expressionFromText = groovyPsiElementFactory.createExpressionFromText(newExp, condExp.getContext()); expressionFromText = (GrExpression) condExp.replace(expressionFromText); editor .getCaretModel() .moveToOffset(expressionFromText.getTextOffset() + caretOffset); // just past "||" return; } Object elseVal = GroovyConstantExpressionEvaluator.evaluate(elseBranch); if (Boolean.FALSE.equals(elseVal) && thenBranch != null) { // aaa ? bbb : false -> aaa && bbb GrExpression conditionExp = condExp.getCondition(); String conditionExpText = getStringToPutIntoAndExpression(conditionExp); String thenExpText = getStringToPutIntoAndExpression(thenBranch); String newExp = conditionExpText + "&&" + thenExpText; int caretOffset = conditionExpText.length() + 2; // after "&&" GrExpression expressionFromText = groovyPsiElementFactory.createExpressionFromText(newExp, condExp.getContext()); expressionFromText = (GrExpression) condExp.replace(expressionFromText); editor .getCaretModel() .moveToOffset(expressionFromText.getTextOffset() + caretOffset); // just past "&&" } }
@NotNull @Override public GroovyResolveResult[] resolve( @NotNull GrUnaryExpressionImpl unary, boolean incompleteCode) { final GrExpression operand = unary.getOperand(); if (operand == null) return GroovyResolveResult.EMPTY_ARRAY; final PsiType type = operand.getType(); if (type == null) return GroovyResolveResult.EMPTY_ARRAY; return TypesUtil.getOverloadedUnaryOperatorCandidates( type, unary.getOperationTokenType(), operand, PsiType.EMPTY_ARRAY); }
private void addForLoopBreakingEdge(GrForStatement forStatement, @Nullable GrForClause clause) { if (clause instanceof GrTraditionalForClause) { final GrExpression condition = ((GrTraditionalForClause) clause).getCondition(); if (condition != null) { condition.accept(this); if (!alwaysTrue(condition)) { addPendingEdge(forStatement, myHead); // break cycle } } } else { addPendingEdge(forStatement, myHead); // break cycle } }
public void visitReturnStatement(GrReturnStatement returnStatement) { boolean isNodeNeeded = myHead == null || myHead.getElement() != returnStatement; final GrExpression value = returnStatement.getReturnValue(); if (value != null) value.accept(this); if (isNodeNeeded) { InstructionImpl returnInstruction = startNode(returnStatement); addPendingEdge(null, myHead); finishNode(returnInstruction); } else { addPendingEdge(null, myHead); } interruptFlow(); }
public void fixSupers() throws IncorrectOperationException { final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(myProject); GrReferenceExpression thisExpression = (GrReferenceExpression) factory.createExpressionFromText("this", null); for (GrExpression expression : mySupersToDelete) { if (expression.getParent() instanceof GrReferenceExpression) { ((GrReferenceExpression) expression.getParent()).setQualifier(null); } } for (GrReferenceExpression superExpression : mySupersToChangeToThis) { superExpression.replace(thisExpression); } }
@Override public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { final PsiElement referenceName = descriptor.getPsiElement(); final GrReferenceExpression invokedExpression = (GrReferenceExpression) referenceName.getParent(); final GrMethodCallExpression callExpression = (GrMethodCallExpression) invokedExpression.getParent(); final GrArgumentList args = callExpression.getArgumentList(); final GrExpression arg = args.getExpressionArguments()[0]; replaceExpression( callExpression, invokedExpression.getQualifierExpression().getText() + '[' + arg.getText() + ']'); }