Datasets:
Mlxa
/
java_methods

Dataset card Data Studio Files
xet
Community
1
Unnamed: 0
int64
0
305k
body
stringlengths
7
52.9k
name
stringlengths
1
185
31,600
GroovyResolveResult (@Nullable GrExpression caller, @NotNull String methodName, GrExpression @NotNull [] exprs, GrNamedArgument @NotNull [] namedArgs, GrClosableBlock @NotNull [] closureArgs, @NotNull GroovyPsiElement psiContext) { GroovyResolveResult call = EmptyGroovyResolveResult.INSTANCE; final PsiType type; if (caller == null) { type = GroovyPsiElementFactory.getInstance(psiContext.getProject()).createExpressionFromText("this", psiContext).getType(); } else { type = caller.getType(); } if (type != null) { final PsiType[] argumentTypes = PsiUtil.getArgumentTypes(namedArgs, exprs, closureArgs, false, null); final GroovyResolveResult[] candidates = ResolveUtil.getMethodCandidates(type, methodName, psiContext, argumentTypes); call = PsiImplUtil.extractUniqueResult(candidates); } return call; }
resolveMethod
31,601
void (@Nullable GrExpression caller, @NotNull GroovyResolveResult resolveResult, @NotNull String methodName, GrExpression @NotNull [] exprs, GrNamedArgument @NotNull [] namedArgs, GrClosableBlock @NotNull [] closureArgs, @NotNull ExpressionGenerator expressionGenerator, @NotNull GroovyPsiElement psiContext) { final PsiElement resolved = resolveResult.getElement(); if (resolved instanceof PsiMethod) { final PsiSubstitutor substitutor = resolveResult.getSubstitutor(); expressionGenerator.invokeMethodOn(((PsiMethod)resolved), caller, exprs, namedArgs, closureArgs, substitutor, psiContext); return; } //other case final StringBuilder builder = expressionGenerator.getBuilder(); final ExpressionContext expressionContext = expressionGenerator.getContext(); if (caller != null) { caller.accept(expressionGenerator); builder.append('.'); } builder.append(methodName); final ArgumentListGenerator argumentListGenerator = new ArgumentListGenerator(builder, expressionContext); argumentListGenerator.generate(null, exprs, namedArgs, closureArgs, psiContext); }
invokeMethodByResolveResult
31,602
void (@NotNull StringBuilder codeBlockBuilder, @NotNull StringBuilder statementBuilder, @Nullable GrStatement statement, @Nullable ExpressionContext context) { final PsiElement parent = statement == null ? null : statement.getParent(); final boolean addParentheses; if (statement == null) { addParentheses = context != null && context.shouldInsertCurlyBrackets(); } else { addParentheses = context != null && (context.shouldInsertCurlyBrackets() || !context.myStatements.isEmpty()) && parent instanceof GrControlStatement; } if (addParentheses) { codeBlockBuilder.append("{\n"); } if (context != null) { insertStatementFromContextBefore(codeBlockBuilder, context); } codeBlockBuilder.append(statementBuilder); if (addParentheses) { codeBlockBuilder.append("}\n"); } }
writeStatement
31,603
void (StringBuilder codeBlockBuilder, ExpressionContext context) { for (String st : context.myStatements) { codeBlockBuilder.append(st).append('\n'); } }
insertStatementFromContextBefore
31,604
void (@NotNull StringBuilder builder, @NotNull ExpressionContext context, @Nullable GrStatement statement, @NotNull StatementWriter writer) { StringBuilder statementBuilder = new StringBuilder(); ExpressionContext statementContext = context.copy(); writer.writeStatement(statementBuilder, statementContext); writeStatement(builder, statementBuilder, statement, statementContext); }
writeStatement
31,605
PsiClass (@NotNull PsiElement context, @NotNull PsiClass initialClass) { Set<PsiClass> visitedClasses = new HashSet<>(); PsiClass curClass = initialClass; final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(context.getProject()).getResolveHelper(); while (curClass != null && !resolveHelper.isAccessible(curClass, context, null)) { curClass = curClass.getSuperClass(); if (visitedClasses.contains(curClass)) return null; visitedClasses.add(curClass); } return curClass; }
findAccessibleSuperClass
31,606
void (StringBuilder text, PsiTypeParameterListOwner typeParameterListOwner, final ClassNameProvider classNameProvider) { if (!typeParameterListOwner.hasTypeParameters()) return; text.append('<'); PsiTypeParameter[] parameters = typeParameterListOwner.getTypeParameters(); final PsiTypeParameterList typeParameterList = typeParameterListOwner.getTypeParameterList(); for (int i = 0; i < parameters.length; i++) { if (i > 0) text.append(", "); PsiTypeParameter parameter = parameters[i]; text.append(parameter.getName()); PsiClassType[] extendsListTypes = parameter.getExtendsListTypes(); if (extendsListTypes.length > 0) { text.append(" extends "); for (int j = 0; j < extendsListTypes.length; j++) { if (j > 0) text.append(" & "); TypeWriter.writeType(text, extendsListTypes[j], typeParameterList, classNameProvider); } } } text.append('>'); }
writeTypeParameters
31,607
void (@NotNull StringBuilder text, PsiParameter @NotNull [] parameters, @NotNull final ClassNameProvider classNameProvider, @Nullable ExpressionContext context) { Set<String> usedNames = new HashSet<>(); text.append('('); //writes myParameters int i = 0; while (i < parameters.length) { PsiParameter parameter = parameters[i]; if (parameter == null) continue; if (parameter instanceof PsiCompiledElement) { parameter = (PsiParameter)((PsiCompiledElement)parameter).getMirror(); } if (i > 0) text.append(", "); //append ',' if (!classNameProvider.forStubs()) { ModifierListGenerator.writeModifiers(text, parameter.getModifierList(), ModifierListGenerator.JAVA_MODIFIERS, true); } if (context != null) { if (context.analyzedVars.toMakeFinal(parameter) && !parameter.hasModifierProperty(PsiModifier.FINAL)) { text.append(PsiModifier.FINAL).append(' '); } TypeWriter.writeType(text, context.typeProvider.getParameterType(parameter), parameter, classNameProvider); } else { TypeWriter.writeType(text, parameter.getType(), parameter, classNameProvider); } text.append(' '); text.append(generateUniqueName(usedNames, parameter.getName())); i++; } text.append(')'); text.append(' '); }
writeParameterList
31,608
String (Set<String> usedNames, String name) { if (StringUtil.isEmptyOrSpaces(name)) { name = "p"; } while (!usedNames.add(name)) { name += "x"; } return name; }
generateUniqueName
31,609
void (StringBuilder text, PsiReferenceList throwsList, PsiClassType[] exceptions, final ClassNameProvider classNameProvider) { if (exceptions.length <= 0) return; text.append("throws "); for (int i = 0; i < exceptions.length; i++) { PsiClassType exception = exceptions[i]; if (i != 0) { text.append(','); } TypeWriter.writeType(text, exception, throwsList, classNameProvider); text.append(' '); } }
writeThrowsList
31,610
String (PsiType varType, PsiElement context) { final StringBuilder builder = new StringBuilder(); TypeWriter.writeType(builder, varType, context); return builder.toString(); }
getTypeText
31,611
void (GrVariableDeclaration variableDeclaration, StringBuilder builder, ExpressionContext expressionContext) { GrVariable[] variables = variableDeclaration.getVariables(); //Set<String> types = getVarTypes(variableDeclaration); //if (types.size() > 1) { if (variables.length > 1 && variableDeclaration.getParent() instanceof GrControlStatement) { expressionContext.setInsertCurlyBrackets(); } for (GrVariable variable : variables) { writeVariableSeparately(variable, builder, expressionContext); builder.append(";\n"); } builder.delete(builder.length()-1, builder.length()); //builder.removeFromTheEnd(1); /*return; } ModifierListGenerator.writeModifiers(builder, variableDeclaration.getModifierList()); PsiType type = getVarType(variables[0]); writeType(builder, type, variableDeclaration); builder.append(" "); for (GrVariable variable : variables) { writeVariableWithoutType(builder, expressionContext, variable); builder.append(", "); } if (variables.length > 0) { builder.delete(builder.length() - 2, builder.length()); } builder.append(";");*/ }
writeSimpleVarDeclaration
31,612
void (StringBuilder builder, ExpressionContext expressionContext, GrVariable variable, boolean wrapped, PsiType original) { builder.append(variable.getName()); final GrExpression initializer = variable.getInitializerGroovy(); if (initializer != null) { builder.append(" = "); if (wrapped) { builder.append("new ").append(GroovyCommonClassNames.GROOVY_LANG_REFERENCE); if (original != null) { builder.append('<'); TypeWriter.writeType(builder, original, variable, new GeneratorClassNameProvider()); builder.append('>'); } builder.append('('); } if (isCastNeeded(original, initializer, expressionContext)) { builder.append('('); TypeWriter.writeType(builder, original, initializer); builder.append(')'); } initializer.accept(new ExpressionGenerator(builder, expressionContext, original)); if (wrapped) { builder.append(')'); } } }
writeVariableWithoutType
31,613
boolean (PsiType target, GrExpression initializer, ExpressionContext expressionContext) { if (target == null) return false; final PsiType iType = getDeclaredType(initializer, expressionContext); if (iType == null) return false; if (TypeConversionUtil.isAssignable(target, iType)) return false; if (initializer instanceof GrLiteral) { Object value = ((GrLiteral)initializer).getValue(); if (value instanceof BigDecimal && Double.isFinite(((BigDecimal)value).doubleValue())) { return !TypeConversionUtil.isAssignable(target, PsiTypes.doubleType()); } else if (value instanceof String && ((String)value).length() == 1) { return !PsiTypes.charType().equals(PsiPrimitiveType.getOptionallyUnboxedType(target)); } } else if (initializer instanceof GrListOrMap listOrMap && target instanceof PsiArrayType) { return listOrMap.isMap(); } return true; }
isCastNeeded
31,614
void (GrVariable variable, StringBuilder builder, ExpressionContext expressionContext) { PsiType type = expressionContext.typeProvider.getVarType(variable); ModifierListGenerator.writeModifiers(builder, variable.getModifierList()); PsiType originalType = type; LocalVarAnalyzer.Result analyzedVars = expressionContext.analyzedVars; boolean wrapped = false; if (analyzedVars != null) { if (analyzedVars.toMakeFinal(variable) && !variable.hasModifierProperty(PsiModifier.FINAL)) { builder.append(PsiModifier.FINAL).append(' '); } else if (analyzedVars.toWrap(variable)) { builder.append(PsiModifier.FINAL).append(' '); type = JavaPsiFacade.getElementFactory(expressionContext.project).createTypeFromText( GroovyCommonClassNames.GROOVY_LANG_REFERENCE + "<" + getTypeText(originalType, variable) + ">", variable); wrapped = true; } } TypeWriter.writeType(builder, type, variable); builder.append(' '); writeVariableWithoutType(builder, expressionContext, variable, wrapped, originalType); }
writeVariableSeparately
31,615
String (GroovyPsiElement place, String initialName, ExpressionContext context) { int count = 0; String name = initialName; Class[] classes = {PsiMethod.class}; final Map<PsiMethod, String> setters = context.getSetters(); while (setters.containsValue(name) || ResolveUtil.resolveExistingElement( place, new MethodResolverProcessor(name, place, false, null, null, null, true), classes) != null) { name = initialName + count; count++; } return name; }
suggestMethodName
31,616
boolean (@NotNull GrExpression qualifier, @NotNull final PsiMember member, ExpressionContext context) { PsiType declared = getDeclaredType(qualifier, context); if (declared == null) return false; final CheckProcessElement checker = new CheckProcessElement(member); if (ResolveUtil.resolvesToClass(qualifier)) { PsiType type = ResolveUtil.unwrapClassType(declared); if (type != null) { ResolveUtil.processAllDeclarations(type, checker, false, qualifier); if (checker.isFound()) { return false; } } } ResolveUtil.processAllDeclarations(declared, checker, false, qualifier); return !checker.isFound(); }
isCastNeeded
31,617
boolean (@NotNull PsiElement element, @NotNull ResolveState state) { if (myManager.areElementsEquivalent(element, myMember)) { myResult = true; return false; } if (myMember instanceof PsiMethod) { PsiMethod[] methods = ((PsiMethod)myMember).findSuperMethods(); for (PsiMethod method: methods) { if (myManager.areElementsEquivalent(element, method)) { myResult = true; return false; } } } return true; }
execute
31,618
boolean () { return myResult; }
isFound
31,619
PsiType (@Nullable GrExpression expression, ExpressionContext context) { if (expression instanceof GrReferenceExpression) { final GroovyResolveResult resolveResult = ((GrReferenceExpression)expression).advancedResolve(); final PsiSubstitutor substitutor = resolveResult.getSubstitutor(); PsiElement resolved = resolveResult.getElement(); if (resolved instanceof PsiVariable) { return substitutor.substitute(context.typeProvider.getVarType((PsiVariable)resolved)); } else if (resolved instanceof PsiMethod) { return getDeclaredType((PsiMethod)resolved, substitutor, context); } } else if (expression instanceof GrMethodCall) { final GrExpression invokedExpression = ((GrMethodCall)expression).getInvokedExpression(); return getDeclaredType(invokedExpression, context); } else if (expression instanceof GrIndexProperty) { final GroovyResolveResult result = advancedResolve((GrIndexProperty)expression); if (result.getElement() instanceof PsiMethod) { return getDeclaredType((PsiMethod)result.getElement(), result.getSubstitutor(), context); } } else if (expression instanceof GrAssignmentExpression) { return getDeclaredType(((GrAssignmentExpression)expression).getRValue(), context); } else if (expression instanceof GrConditionalExpression) { return TypesUtil.getLeastUpperBoundNullable(getDeclaredType(((GrConditionalExpression)expression).getThenBranch(), context), getDeclaredType(((GrConditionalExpression)expression).getElseBranch(), context), expression.getManager()); } else if (expression instanceof GrParenthesizedExpression) { return getDeclaredType(((GrParenthesizedExpression)expression).getOperand(), context); } else if (expression == null) { return null; } return expression.getType(); }
getDeclaredType
31,620
PsiType (PsiMethod method, PsiSubstitutor substitutor, ExpressionContext context) { if (method instanceof GrGdkMethod) method = ((GrGdkMethod)method).getStaticMethod(); if (context.isClassConverted(method.getContainingClass())) { return substitutor.substitute(PsiUtil.getSmartReturnType(method)); } else { return substitutor.substitute(method.getReturnType()); } }
getDeclaredType
31,621
void (StringBuilder builder, @NotNull PsiType expected, @Nullable PsiType actual, GroovyPsiElement context, ExpressionContext expressionContext, StatementWriter writer) { if (actual != null && TypesUtil.isAssignable(expected, actual, context) || expected.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { writer.writeStatement(builder, expressionContext); } else { wrapInCast(builder, expected, context, expressionContext, writer); } }
wrapInCastIfNeeded
31,622
void (StringBuilder builder, @NotNull PsiType expected, PsiElement context, ExpressionContext expressionContext, StatementWriter writer) { builder.append("(("); //todo check operator priority IDEA-93790 TypeWriter.writeType(builder, expected, context); builder.append(")(") ; writer.writeStatement(builder, expressionContext); builder.append("))"); }
wrapInCast
31,623
PsiType (PsiElement context, PsiType type) { return type != null ? type : TypesUtil.getJavaLangObject(context); }
getNotNullType
31,624
void (@Nullable PsiClass targetClass, StringBuilder buffer, ExpressionContext context) { if (targetClass != null && !(targetClass instanceof PsiAnonymousClass)) { final GrCodeReferenceElement ref = GroovyPsiElementFactory.getInstance(context.project).createCodeReferenceElementFromClass(targetClass); writeCodeReferenceElement(buffer, ref); buffer.append('.'); } buffer.append("this"); }
writeThisReference
31,625
void (@Nullable PsiClass targetClass, StringBuilder buffer, ExpressionContext context) { if (targetClass != null && !(targetClass instanceof PsiAnonymousClass)) { final GrCodeReferenceElement ref = GroovyPsiElementFactory.getInstance(context.project).createCodeReferenceElementFromClass(targetClass); writeCodeReferenceElement(buffer, ref); buffer.append('.'); } buffer.append("super"); }
writeSuperReference
31,626
PsiElement (@NotNull PsiElement place) { PsiElement parent = place.getParent(); while (parent != null) { if (parent instanceof PsiClass) return null; if (parent instanceof GroovyFile && !(PsiUtil.isInDummyFile(parent))) return null; if (parent instanceof GrClosableBlock) return parent; parent = parent.getContext(); } return null; }
getWrappingImplicitClass
31,627
void (StringBuilder buffer, PsiMember member, boolean addLineFeed) { if (member instanceof PsiDocCommentOwner) { final PsiDocComment comment = ((PsiDocCommentOwner)member).getDocComment(); if (comment != null) { final String text = comment.getText(); buffer.append(text); if (addLineFeed) buffer.append('\n'); } } }
writeDocComment
31,628
void (@Nullable GrSignature signature, GrExpression @NotNull [] exprs, GrNamedArgument @NotNull [] namedArgs, GrClosableBlock @NotNull [] clArgs, @NotNull GroovyPsiElement context) { GrClosureSignatureUtil.ArgInfo<PsiElement>[] argInfos = signature == null ? null : GrClosureSignatureUtil.mapParametersToArguments(signature, namedArgs, exprs, clArgs, context, false, false); if (argInfos == null && signature != null) { argInfos = GrClosureSignatureUtil.mapParametersToArguments(signature, namedArgs, exprs, clArgs, context, true, true); } final PsiSubstitutor substitutor = signature == null ? PsiSubstitutor.EMPTY : signature.getSubstitutor(); if (argInfos == null || ArrayUtil.contains(null, argInfos)) { generateSimple(exprs, namedArgs, clArgs, context, substitutor); return; } final GrClosureParameter[] params = signature.getParameters(); final Project project = context.getProject(); myBuilder.append('('); boolean hasCommaAtEnd = false; for (int i = 0; i < argInfos.length; i++) { GrClosureSignatureUtil.ArgInfo<PsiElement> arg = argInfos[i]; if (arg == null) continue; final GrClosureParameter param = params[i]; boolean generated = arg.isMultiArg ? generateMultiArg(arg, param, substitutor, project, context) : generateSingeArg(arg, param); if (generated) { hasCommaAtEnd = true; myBuilder.append(", "); } } if (hasCommaAtEnd) { myBuilder.delete(myBuilder.length() - 2, myBuilder.length()); //myBuilder.removeFromTheEnd(2); } myBuilder.append(')'); }
generate
31,629
boolean (GrClosureSignatureUtil.ArgInfo<PsiElement> arg, GrClosureParameter param) { boolean argExists = !arg.args.isEmpty() && arg.args.get(0) != null; if (argExists) { final PsiElement actual = arg.args.get(0); LOG.assertTrue(actual instanceof GrExpression); final PsiType type = param.getType(); final PsiType declaredType = GenerationUtil.getDeclaredType((GrExpression)actual, myExpressionGenerator.getContext()); if (type != null && declaredType != null && !TypesUtil.isAssignableByMethodCallConversion(type, declaredType, actual )) { myBuilder.append('('); TypeWriter.writeType(myBuilder, type, actual); myBuilder.append(')'); } ((GrExpression)actual).accept(myExpressionGenerator); return true; } else { /*final GrExpression initializer = param.getInitializerGroovy(); if (initializer != null) { initializer.accept(myExpressionGenerator); } else { myBuilder.append("???"); //todo add something more consistent }*/ return false; } }
generateSingeArg
31,630
boolean (GrClosureSignatureUtil.ArgInfo<PsiElement> arg, GrClosureParameter param, PsiSubstitutor substitutor, Project project, GroovyPsiElement context) { final PsiType type = param.getType(); //todo find out if param is array in case of it has declared type if (type instanceof PsiEllipsisType) { for (PsiElement element : arg.args) { LOG.assertTrue(element instanceof GrExpression); ((GrExpression)element).accept(myExpressionGenerator); myBuilder.append(", "); } if (!arg.args.isEmpty()) { myBuilder.delete(myBuilder.length() - 2, myBuilder.length()); return true; } else { return false; } } else if (type instanceof PsiArrayType) { myBuilder.append("new "); if (arg.args.isEmpty()) { TypeWriter.writeType(myBuilder, ((PsiArrayType)type).getComponentType(), context); myBuilder.append("[0]"); } else { TypeWriter.writeTypeForNew(myBuilder, type, context); myBuilder.append("{"); for (PsiElement element : arg.args) { LOG.assertTrue(element instanceof GrExpression); ((GrExpression)element).accept(myExpressionGenerator); myBuilder.append(", "); } if (!arg.args.isEmpty()) myBuilder.delete(myBuilder.length() - 2, myBuilder.length()); //if (arg.args.size() > 0) myBuilder.removeFromTheEnd(2); myBuilder.append('}'); } } else { final GrExpression listOrMap = GroovyRefactoringUtil.generateArgFromMultiArg(substitutor, arg.args, type, project); LOG.assertTrue(listOrMap instanceof GrListOrMap); listOrMap.accept(myExpressionGenerator); } return true; }
generateMultiArg
31,631
void (GrExpression[] exprs, GrNamedArgument[] namedArgs, GrClosableBlock[] closures, GroovyPsiElement context, PsiSubstitutor substitutor) { myBuilder.append('('); if (namedArgs.length > 0) { final GrExpression listOrMap = GroovyRefactoringUtil.generateArgFromMultiArg(substitutor, Arrays.asList(namedArgs), null, context.getProject()); LOG.assertTrue(listOrMap instanceof GrListOrMap); listOrMap.accept(myExpressionGenerator); myBuilder.append(", "); } for (GrExpression expr : exprs) { expr.accept(myExpressionGenerator); myBuilder.append(", "); } for (GrClosableBlock closure : closures) { closure.accept(myExpressionGenerator); myBuilder.append(", "); } if (namedArgs.length + exprs.length + closures.length > 0) { myBuilder.delete(myBuilder.length()-2, myBuilder.length()); //myBuilder.removeFromTheEnd(2); } myBuilder.append(')'); }
generateSimple
31,632
void (StringBuilder text, GrPackageDefinition packageDefinition) { if (packageDefinition != null) { ModifierListGenerator.writeModifiers(text, packageDefinition.getAnnotationList(), ModifierListGenerator.JAVA_MODIFIERS, classItemGenerator.generateAnnotations()); text.append("package "); text.append(packageDefinition.getPackageName()); text.append(';'); text.append('\n'); text.append('\n'); } }
writePackageStatement
31,633
void (StringBuilder text, @NotNull final PsiClass typeDefinition, boolean toplevel, boolean insertPackageSmst) { final boolean isScript = typeDefinition instanceof GroovyScriptClass; final GroovyFile containingFile = (GroovyFile)typeDefinition.getContainingFile(); if (insertPackageSmst) { writePackageStatement(text, containingFile.getPackageDefinition()); } GenerationUtil.writeDocComment(text, typeDefinition, true); boolean isEnum = typeDefinition.isEnum(); boolean isAnnotationType = typeDefinition.isAnnotationType(); boolean isInterface = typeDefinition.isInterface(); ModifierListGenerator.writeClassModifiers(text, typeDefinition.getModifierList(), typeDefinition.isInterface(), typeDefinition.isEnum(), toplevel, classItemGenerator.generateAnnotations()); if (isAnnotationType) { text.append('@'); } if (isInterface) { text.append("interface"); } else if (isEnum) { text.append("enum"); } else { text.append("class"); } text.append(' ').append(typeDefinition.getName()); GenerationUtil.writeTypeParameters(text, typeDefinition, classNameProvider); text.append(' '); if (isScript) { text.append("extends ").append(GroovyCommonClassNames.GROOVY_LANG_SCRIPT).append(' '); } else if (!isEnum && !isAnnotationType) { classItemGenerator.writeExtendsList(text, typeDefinition); classItemGenerator.writeImplementsList(text, typeDefinition); } text.append("{\n"); writeMembers(text, typeDefinition); text.append('}'); }
writeTypeDefinition
31,634
void (StringBuilder text, PsiClass typeDefinition) { if (typeDefinition instanceof GrEnumTypeDefinition) { final GrEnumConstant[] enumConstants = ((GrEnumTypeDefinition)typeDefinition).getEnumConstants(); for (GrEnumConstant constant : enumConstants) { classItemGenerator.writeEnumConstant(text, constant); text.append(','); } if (enumConstants.length > 0) { //text.removeFromTheEnd(1).append(";\n"); text.delete(text.length() - 1, text.length()); } text.append(";\n"); } writeAllMethods(text, classItemGenerator.collectMethods(typeDefinition), typeDefinition); if (typeDefinition instanceof GrTypeDefinition) { for (GrMembersDeclaration declaration : ((GrTypeDefinition)typeDefinition).getMemberDeclarations()) { if (declaration instanceof GrVariableDeclaration) { classItemGenerator.writeVariableDeclarations(text, (GrVariableDeclaration)declaration); } } for (PsiClass inner : typeDefinition.getInnerClasses()) { writeTypeDefinition(text, inner, false, false); text.append('\n'); } } classItemGenerator.writePostponed(text, typeDefinition); }
writeMembers
31,635
void (StringBuilder text, Collection<PsiMethod> methods, PsiClass aClass) { for (PsiMethod method : methods) { if (!shouldBeGenerated(method, aClass)) continue; if (method.isConstructor()) { classItemGenerator.writeConstructor(text, method, aClass.isEnum()); } else { classItemGenerator.writeMethod(text, method); text.append('\n'); } } }
writeAllMethods
31,636
boolean (PsiMethod method, PsiClass containingClass) { if (containingClass instanceof GrEnumTypeDefinitionImpl && ((GrEnumTypeDefinitionImpl)containingClass).isPredefinedEnumMethod(method)) { return false; } for (PsiMethod psiMethod : method.findSuperMethods()) { if (!psiMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { final PsiType type = method.getReturnType(); final PsiType superType = psiMethod.getReturnType(); if (type != null && superType != null && !superType.isAssignableFrom(type)) { return false; } } } return true; }
shouldBeGenerated
31,637
UsageViewDescriptor (UsageInfo @NotNull [] usages) { return new UsageViewDescriptorAdapter() { @Override public PsiElement @NotNull [] getElements() { return myFiles; } @Override public String getProcessedElementsHeader() { return GroovyRefactoringBundle.message("files.to.be.converted"); } }; }
createUsageViewDescriptor
31,638
String () { return GroovyRefactoringBundle.message("files.to.be.converted"); }
getProcessedElementsHeader
31,639
void (UsageInfo @NotNull [] usages) { final GeneratorClassNameProvider classNameProvider = new GeneratorClassNameProvider(); ExpressionContext context = new ExpressionContext(myProject, myFiles); final ClassGenerator classGenerator = new ClassGenerator(classNameProvider, new ClassItemGeneratorImpl(context)); for (GroovyFile file : myFiles) { final PsiClass[] classes = file.getClasses(); StringBuilder builder = new StringBuilder(); boolean first = true; for (PsiClass aClass : classes) { classGenerator.writeTypeDefinition(builder, aClass, true, first); first = false; builder.append('\n'); } final Document document = PsiDocumentManager.getInstance(myProject).getDocument(file); LOG.assertTrue(document != null); document.setText(builder.toString()); PsiDocumentManager.getInstance(myProject).commitDocument(document); String fileName = getNewFileName(file); PsiElement newFile; try { String filePathBeforeConvert = file.getVirtualFile().getPath(); file.getVirtualFile().putUserData(RenameTrackingKt.getPathBeforeGroovyToJavaConversion(), filePathBeforeConvert); newFile = file.setName(fileName); } catch (final IncorrectOperationException e) { ApplicationManager.getApplication().invokeLater( () -> Messages.showMessageDialog(myProject, e.getMessage(), RefactoringBundle.message("error.title"), Messages.getErrorIcon())); return; } doPostProcessing(newFile); } }
performRefactoring
31,640
void (PsiElement newFile) { if (ApplicationManager.getApplication().isUnitTestMode()) return; // don't move classes to new files with corresponding class names and reformat if (!(newFile instanceof PsiJavaFile)) { LOG.info(".java is not assigned to java file type"); return; } newFile = JavaCodeStyleManager.getInstance(myProject).shortenClassReferences(newFile); newFile = CodeStyleManager.getInstance(myProject).reformat(newFile); PsiClass[] inner = ((PsiJavaFile)newFile).getClasses(); for (PsiClass psiClass : inner) { var fix = new MoveClassToSeparateFileFix(psiClass).asIntention(); if (fix.isAvailable(myProject, null, (PsiFile)newFile)) { fix.invoke(myProject, null, (PsiFile)newFile); } } }
doPostProcessing
31,641
String (GroovyFile file) { final PsiDirectory dir = file.getContainingDirectory(); LOG.assertTrue(dir != null); final PsiFile[] files = dir.getFiles(); Set<String> fileNames = new HashSet<>(); for (PsiFile psiFile : files) { fileNames.add(psiFile.getName()); } String prefix = FileUtilRt.getNameWithoutExtension(file.getName()); String fileName = prefix + ".java"; int index = 1; while (fileNames.contains(fileName)) { fileName = prefix + (index++) + ".java"; } return fileName; }
getNewFileName
31,642
String () { return GroovyRefactoringBundle.message("converting.files.to.java"); }
getCommandName
31,643
boolean (StringBuilder text, PsiModifierList modifierList) { return writeModifiers(text, modifierList, JAVA_MODIFIERS, true); }
writeModifiers
31,644
boolean (StringBuilder text, PsiModifierList modifierList, String[] modifiers) { return writeModifiers(text, modifierList, modifiers, true); }
writeModifiers
31,645
boolean (StringBuilder builder, PsiModifierList modifierList, String[] modifiers, boolean writeAnnotations) { boolean wasAddedModifiers = false; if (writeAnnotations && modifierList instanceof GrModifierList) { GrAnnotation[] annotations = ((GrModifierList)modifierList).getAnnotations(); AnnotationGenerator annotationGenerator = new AnnotationGenerator(builder, new ExpressionContext(modifierList.getProject(), GroovyFile.EMPTY_ARRAY)); wasAddedModifiers = annotations.length > 0; for (GrAnnotation annotation : annotations) { annotation.accept(annotationGenerator); builder.append(' '); } } for (String modifierType : modifiers) { if (modifierList.hasModifierProperty(modifierType)) { builder.append(modifierType); builder.append(' '); wasAddedModifiers = true; } } return wasAddedModifiers; }
writeModifiers
31,646
void (StringBuilder text, @Nullable PsiModifierList modifierList, boolean isInterface, boolean isEnum, boolean toplevel, boolean generateAnnotations) { if (modifierList == null) { text.append("public "); return; } List<String> allowedModifiers = new ArrayList<>(); allowedModifiers.add(PsiModifier.PUBLIC); if (!isEnum) allowedModifiers.add(PsiModifier.FINAL); if (!toplevel) { allowedModifiers.addAll(Arrays.asList(PsiModifier.PROTECTED, PsiModifier.PRIVATE, PsiModifier.STATIC)); } if (!isInterface && !isEnum) { allowedModifiers.add(PsiModifier.ABSTRACT); } writeModifiers(text, modifierList, ArrayUtilRt.toStringArray(allowedModifiers), generateAnnotations); }
writeClassModifiers
31,647
String (PsiClass psiClass, @Nullable PsiElement context) { if (context != null && psiClass != null) { psiClass = GenerationUtil.findAccessibleSuperClass(context, psiClass); } if (psiClass == null) { return CommonClassNames.JAVA_LANG_OBJECT; } final String name = psiClass.getQualifiedName(); if (name != null) return name; return psiClass.getName(); }
getQualifiedClassName
31,648
boolean () { return false; }
forStubs
31,649
String (String typeCanonicalText) { final String result = typesToInitialValues.get(typeCanonicalText); if (result == null) return "null"; return result; }
getDefaultValueText
31,650
String (@NotNull String groovyIdentifier) { LOG.assertTrue(!groovyIdentifier.isEmpty()); StringBuilder javaIdentifier = new StringBuilder(groovyIdentifier.length()); if (!Character.isJavaIdentifierStart(groovyIdentifier.charAt(0))) { javaIdentifier.append("_"); } for (char letter : groovyIdentifier.toCharArray()) { if (Character.isJavaIdentifierPart(letter)) { javaIdentifier.append(letter); } else { javaIdentifier.append("_"); } } return javaIdentifier.toString(); }
convertToJavaIdentifier
31,651
String (@NotNull PsiMethod method) { if (!(method instanceof GroovyPsiElement)) { return method.getText(); } final ClassItemGenerator generator = new StubGenerator(new StubClassNameProvider(Collections.emptySet())); final StringBuilder buffer = new StringBuilder(); if (method.isConstructor()) { generator.writeConstructor(buffer, method, false); } else { generator.writeMethod(buffer, method); } return buffer.toString(); }
generateMethodStub
31,652
void (@NotNull GrClosableBlock closure) { builder.append("new "); TypeWriter.writeTypeForNew(builder, closure.getType(), closure); builder.append('('); final CharSequence owner = getOwner(closure); builder.append(owner); builder.append(", "); builder.append(owner); builder.append(") {\n"); generateClosureMainMethod(closure); final ClassItemGeneratorImpl generator = new ClassItemGeneratorImpl(context); final GrMethod method = generateClosureMethod(closure); final GrReflectedMethod[] reflectedMethods = method.getReflectedMethods(); for (GrReflectedMethod reflectedMethod : reflectedMethods) { if (reflectedMethod.getSkippedParameters().length > 0) { generator.writeMethod(builder, reflectedMethod); builder.append('\n'); } } builder.append('}'); }
generate
31,653
void (@NotNull GrClosableBlock block) { builder.append("public "); final PsiType returnType = context.typeProvider.getReturnType(block); TypeWriter.writeType(builder, returnType, block); builder.append(" doCall"); final GrParameter[] parameters = block.getAllParameters(); GenerationUtil.writeParameterList(builder, parameters, new GeneratorClassNameProvider(), context); Collection<GrStatement> myExitPoints = !PsiTypes.voidType().equals(returnType) ? ControlFlowUtils.collectReturns(block) : Collections.emptySet(); boolean shouldInsertReturnNull = !(returnType instanceof PsiPrimitiveType) && MissingReturnInspection.methodMissesSomeReturns(block, MissingReturnInspection.ReturnStatus.shouldNotReturnValue); new CodeBlockGenerator(builder, context.extend(), myExitPoints).generateCodeBlock(parameters, block, shouldInsertReturnNull); builder.append('\n'); }
generateClosureMainMethod
31,654
GrMethod (@NotNull GrClosableBlock block) { final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(context.project); final GrMethod method = factory.createMethodFromText("def doCall(){}", block); GrReferenceAdjuster.shortenAllReferencesIn(method.setReturnType(context.typeProvider.getReturnType(block))); if (block.hasParametersSection()) { method.getParameterList().replace(block.getParameterList()); } else { final GrParameter[] allParameters = block.getAllParameters(); LOG.assertTrue(allParameters.length == 1); final GrParameter itParameter = allParameters[0]; final GrParameter parameter = factory.createParameter("it", itParameter.getType().getCanonicalText(), "null", block); method.getParameterList().add(parameter); } ((GroovyFileImpl)method.getContainingFile()).setContextNullable(null); return method; }
generateClosureMethod
31,655
CharSequence (@NotNull GrClosableBlock closure) { final GroovyPsiElement context = PsiTreeUtil.getParentOfType(closure, GrMember.class, GroovyFile.class); LOG.assertTrue(context != null); final PsiClass contextClass; if (context instanceof GroovyFile) { contextClass = ((GroovyFile)context).getScriptClass(); } else if (context instanceof PsiClass) { contextClass = (PsiClass)context; } else if (context instanceof GrMember) { if (((GrMember)context).hasModifierProperty(PsiModifier.STATIC)) { contextClass = null; //no context class } else { contextClass = ((GrMember)context).getContainingClass(); } } else { contextClass = null; } if (contextClass == null) return "null"; final PsiElement implicitClass = GenerationUtil.getWrappingImplicitClass(closure); if (implicitClass == null) { return "this"; } else { final StringBuilder buffer = new StringBuilder(); GenerationUtil.writeThisReference(contextClass, buffer, this.context); return buffer; } }
getOwner
31,656
StringBuilder () { return builder; }
getBuilder
31,657
ExpressionContext () { return context; }
getContext
31,658
void (@NotNull GrClosableBlock closure) { new ClosureGenerator(builder, context).generate(closure); }
visitClosure
31,659
void (@NotNull GrExpression expression) { LOG.error("this method should not be invoked"); }
visitExpression
31,660
void (@NotNull GrMethodCall call) { generateMethodCall(call); }
visitMethodCall
31,661
void (GrMethodCall methodCallExpression) { final GrExpression invoked = methodCallExpression.getInvokedExpression(); final GrExpression[] exprs = methodCallExpression.getExpressionArguments(); final GrNamedArgument[] namedArgs = methodCallExpression.getNamedArguments(); final GrClosableBlock[] clArgs = methodCallExpression.getClosureArguments(); if (invoked instanceof GrReferenceExpression) { final GroovyResolveResult resolveResult = ((GrReferenceExpression)invoked).advancedResolve(); final PsiElement resolved = resolveResult.getElement(); if (resolved instanceof PsiMethod) { final GrExpression qualifier = ((GrReferenceExpression)invoked).getQualifier();//todo replace null-qualifier with this-reference invokeMethodOn( ((PsiMethod)resolved), qualifier, exprs, namedArgs, clArgs, resolveResult.getSubstitutor(), methodCallExpression ); return; } else if (resolved == null) { final GrExpression qualifier = ((GrReferenceExpression)invoked).getQualifier(); final GrExpression[] args = generateArgsForInvokeMethod(((GrReferenceExpression)invoked).getReferenceName(), exprs, namedArgs, clArgs, methodCallExpression); GenerationUtil.invokeMethodByName(qualifier, "invokeMethod", args, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, this, methodCallExpression); return; } } GenerationUtil.invokeMethodByName(invoked, "call", exprs, namedArgs, clArgs, this, methodCallExpression); }
generateMethodCall
31,662
GrExpression[] (String name, GrExpression[] exprs, GrNamedArgument[] namedArgs, GrClosableBlock[] clArgs, GroovyPsiElement psiContext) { GrExpression[] result = new GrExpression[2]; result[0] = factory.createExpressionFromText("\"" + name + "\""); StringBuilder builder = new StringBuilder(); builder.append('['); if (namedArgs.length > 0) { builder.append('['); for (GrNamedArgument namedArg : namedArgs) { builder.append(namedArg.getText()).append(','); } builder.delete(builder.length() - 1, builder.length()); //builder.removeFromTheEnd(1); builder.append("],"); } for (GrExpression expr : exprs) { builder.append(expr.getText()).append(','); } for (GrClosableBlock clArg : clArgs) { builder.append(clArg.getText()).append(','); } if (namedArgs.length + exprs.length + clArgs.length > 0) builder.delete(builder.length() - 1, builder.length()); //if (namedArgs.length + exprs.length + clArgs.length > 0) builder.removeFromTheEnd(1); builder.append("] as Object[]"); result[1] = factory.createExpressionFromText(builder.toString(), psiContext); return result; }
generateArgsForInvokeMethod
31,663
void (@NotNull GrNewExpression newExpression) { boolean hasFieldInitialization = hasFieldInitialization(newExpression); StringBuilder builder; final PsiType type = newExpression.getType(); final String varName; if (hasFieldInitialization) { builder = new StringBuilder(); varName = GenerationUtil.suggestVarName(type, newExpression, context); TypeWriter.writeType(builder, type, newExpression); builder.append(' ').append(varName).append(" = "); } else { varName = null; builder = this.builder; } final GrTypeElement typeElement = newExpression.getTypeElement(); final GrArrayDeclaration arrayDeclaration = newExpression.getArrayDeclaration(); final GrCodeReferenceElement referenceElement = newExpression.getReferenceElement(); builder.append("new "); if (typeElement != null) { final PsiType builtIn = typeElement.getType(); LOG.assertTrue(builtIn instanceof PsiPrimitiveType); final PsiType boxed = TypesUtil.boxPrimitiveType(builtIn, newExpression.getManager(), newExpression.getResolveScope()); TypeWriter.writeTypeForNew(builder, boxed, newExpression); } else if (referenceElement != null) { GenerationUtil.writeCodeReferenceElement(builder, referenceElement); } final GrArgumentList argList = newExpression.getArgumentList(); if (argList != null) { GrSignature signature = null; final GroovyResolveResult resolveResult = newExpression.advancedResolve(); final PsiElement constructor = resolveResult.getElement(); if (constructor instanceof PsiMethod) { signature = GrClosureSignatureUtil.createSignature((PsiMethod)constructor, resolveResult.getSubstitutor()); } else if (referenceElement != null) { final GroovyResolveResult clazzResult = referenceElement.advancedResolve(); final PsiElement clazz = clazzResult.getElement(); if (clazz instanceof PsiClass && ((PsiClass)clazz).getConstructors().length == 0) { signature = GrClosureSignatureUtil.createSignature(PsiParameter.EMPTY_ARRAY, null); } } final GrNamedArgument[] namedArgs = hasFieldInitialization ? GrNamedArgument.EMPTY_ARRAY : argList.getNamedArguments(); new ArgumentListGenerator(builder, context).generate( signature, argList.getExpressionArguments(), namedArgs, GrClosableBlock.EMPTY_ARRAY, newExpression ); } final GrAnonymousClassDefinition anonymous = newExpression.getAnonymousClassDefinition(); if (anonymous != null) { writeTypeBody(builder, anonymous); } if (arrayDeclaration != null) { final GrExpression[] boundExpressions = arrayDeclaration.getBoundExpressions(); for (GrExpression boundExpression : boundExpressions) { builder.append('['); boundExpression.accept(this); builder.append(']'); } if (boundExpressions.length == 0) { builder.append("[]"); } } if (hasFieldInitialization) { builder.append(';'); context.myStatements.add(builder.toString()); final GrNamedArgument[] namedArguments = argList.getNamedArguments(); for (GrNamedArgument namedArgument : namedArguments) { final String fieldName = namedArgument.getLabelName(); if (fieldName == null) { //todo try to initialize field final GrArgumentLabel label = namedArgument.getLabel(); LOG.info("cannot initialize field " + (label == null ? "<null>" : label.getText())); } else { final GroovyResolveResult resolveResult = referenceElement.advancedResolve(); final PsiElement resolved = resolveResult.getElement(); LOG.assertTrue(resolved instanceof PsiClass); initializeField(varName, type, ((PsiClass)resolved), resolveResult.getSubstitutor(), fieldName, namedArgument.getExpression()); } } } }
visitNewExpression
31,664
void (String varName, PsiType type, PsiClass resolved, PsiSubstitutor substitutor, String fieldName, GrExpression expression) { StringBuilder builder = new StringBuilder(); final PsiMethod setter = GroovyPropertyUtils.findPropertySetter(resolved, fieldName, false, true); if (setter != null) { final GrVariableDeclaration var = factory.createVariableDeclaration(ArrayUtilRt.EMPTY_STRING_ARRAY, "", type, varName); final GrReferenceExpression caller = factory.createReferenceExpressionFromText(varName, var); invokeMethodOn(setter, caller, new GrExpression[]{expression}, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, substitutor, expression); } else { builder.append(varName).append('.').append(fieldName).append(" = "); expression.accept(new ExpressionGenerator(builder, context)); } context.myStatements.add(builder.toString()); }
initializeField
31,665
String () { return builder.toString(); }
toString
31,666
boolean (GrNewExpression newExpression) { final GrArgumentList argumentList = newExpression.getArgumentList(); if (argumentList == null) return false; if (argumentList.getNamedArguments().length == 0) return false; final GrCodeReferenceElement refElement = newExpression.getReferenceElement(); if (refElement == null) return false; final GroovyResolveResult resolveResult = newExpression.advancedResolve(); final PsiElement constructor = resolveResult.getElement(); if (constructor instanceof PsiMethod) { return ((PsiMethod)constructor).getParameterList().isEmpty(); } final PsiElement resolved = refElement.resolve(); return resolved instanceof PsiClass; }
hasFieldInitialization
31,667
void (StringBuilder builder, GrAnonymousClassDefinition anonymous) { builder.append("{\n"); final GeneratorClassNameProvider classNameProvider = new GeneratorClassNameProvider(); final ClassItemGeneratorImpl classItemGenerator = new ClassItemGeneratorImpl(context.extend()); new ClassGenerator(classNameProvider, classItemGenerator).writeMembers(builder, anonymous); builder.append('}'); }
writeTypeBody
31,668
void (@NotNull GrConditionalExpression expression) { final GrExpression condition = expression.getCondition(); final GrExpression thenBranch = expression.getThenBranch(); final GrExpression elseBranch = expression.getElseBranch(); final boolean elvis = expression instanceof GrElvisExpression; final String var; if (elvis) { var = createVarByInitializer(condition); } else { var = null; } final PsiType type = condition.getType(); if (type == null || PsiTypes.booleanType().equals(TypesUtil.unboxPrimitiveTypeWrapper(type))) { if (elvis) { builder.append(var); } else { condition.accept(this); } } else { final GroovyResolveResult[] results = ResolveUtil.getMethodCandidates(type, "asBoolean", expression, PsiType.EMPTY_ARRAY); final GroovyResolveResult result = PsiImplUtil.extractUniqueResult(results); GenerationUtil.invokeMethodByResolveResult( elvis ? factory.createReferenceExpressionFromText(var, expression) : condition, result, "asBoolean", GrExpression.EMPTY_ARRAY, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, this, expression ); } builder.append('?'); if (thenBranch != null) { if (elvis) { builder.append(var); } else { thenBranch.accept(this); } } builder.append(':'); if (elseBranch != null) { elseBranch.accept(this); } }
visitConditionalExpression
31,669
void (@NotNull final GrAssignmentExpression expression) { final GrExpression lValue = expression.getLValue(); final GrExpression rValue = expression.getRValue(); PsiElement realLValue = PsiUtil.skipParentheses(lValue, false); if (realLValue instanceof GrReferenceExpression && rValue != null) { GroovyResolveResult resolveResult = ((GrReferenceExpression)realLValue).advancedResolve(); PsiElement resolved = resolveResult.getElement(); if (resolved instanceof GrVariable && context.analyzedVars.toWrap((GrVariable)resolved)) { //write assignment to wrapped local var writeAssignmentWithRefSetter((GrExpression)realLValue, expression); return; } else if (resolved instanceof PsiMethod && resolveResult.isInvokedOnProperty()) { //write assignment via setter writeAssignmentWithSetter(((GrReferenceExpression)realLValue).getQualifier(), (PsiMethod)resolved, expression); return; } else if (resolved == null || resolved instanceof GrBindingVariable) { //write unresolved reference assignment via setter GroovyObject.setProperty(String name, Object value) final GrExpression qualifier = ((GrReferenceExpression)realLValue).getQualifier(); final PsiType type = PsiImplUtil.getQualifierType((GrReferenceExpression)realLValue); final GrExpression[] args = { factory.createExpressionFromText("\"" + ((GrReferenceExpression)realLValue).getReferenceName() + "\""), getRValue(expression) }; GroovyResolveResult[] candidates = type != null ? ResolveUtil.getMethodCandidates(type, "setProperty", expression, args[0].getType(), args[1].getType()) : GroovyResolveResult.EMPTY_ARRAY; final PsiMethod method = PsiImplUtil.extractUniqueElement(candidates); if (method != null) { writeAssignmentWithSetter(qualifier, method, args, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, PsiSubstitutor.EMPTY, expression); return; } } } else if (realLValue instanceof GrIndexProperty) { //qualifier[args] = rValue //write assignment via qualifier.putAt(Args, Value) method final GroovyResolveResult result = advancedResolve(((GrIndexProperty)realLValue), false); final PsiElement resolved = result.getElement(); if (resolved instanceof PsiMethod) { final GrExpression[] args = ((GrIndexProperty)realLValue).getArgumentList().getExpressionArguments(); writeAssignmentWithSetter(((GrIndexProperty)realLValue).getInvokedExpression(), (PsiMethod)resolved, ArrayUtil.append(args, getRValue(expression)), GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, result.getSubstitutor(), expression); return; } } final PsiType lType = GenerationUtil.getDeclaredType(lValue, context); if (!expression.isOperatorAssignment()) { //write simple assignment lValue.accept(this); builder.append(" = "); if (rValue != null) { final PsiType rType = GenerationUtil.getDeclaredType(rValue, context); GenerationUtil.wrapInCastIfNeeded(builder, GenerationUtil.getNotNullType(expression, lType), rType, expression, context, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { rValue.accept(ExpressionGenerator.this); } }); } } else { //write assignment such as +=, -=, etc final GroovyResolveResult resolveResult = PsiImplUtil.extractUniqueResult(PsiUtilKt.multiResolve(expression)); final PsiElement resolved = resolveResult.getElement(); if (resolved instanceof PsiMethod && !shouldNotReplaceOperatorWithMethod(lValue.getType(), rValue, expression.getOperationTokenType())) { lValue.accept(this); builder.append(" = "); final PsiType rType = GenerationUtil.getDeclaredType((PsiMethod)resolved, resolveResult.getSubstitutor(), context); GenerationUtil.wrapInCastIfNeeded(builder, GenerationUtil.getNotNullType(expression, lType), rType, expression, context, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { invokeMethodOn( ((PsiMethod)resolved), (GrExpression)lValue.copy(), rValue == null ? GrExpression.EMPTY_ARRAY : new GrExpression[]{rValue}, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, resolveResult.getSubstitutor(), expression ); } }); } else { writeSimpleBinaryExpression(expression.getOperationToken(), lValue, rValue); } } }
visitAssignmentExpression
31,670
void (StringBuilder builder, ExpressionContext context) { rValue.accept(ExpressionGenerator.this); }
writeStatement
31,671
void (StringBuilder builder, ExpressionContext context) { invokeMethodOn( ((PsiMethod)resolved), (GrExpression)lValue.copy(), rValue == null ? GrExpression.EMPTY_ARRAY : new GrExpression[]{rValue}, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, resolveResult.getSubstitutor(), expression ); }
writeStatement
31,672
void (GrExpression ref, GrAssignmentExpression expression) { GrExpression rValue = getRValue(expression); if (PsiUtil.isExpressionUsed(expression)) { LOG.assertTrue(context.getRefSetterName(expression) != null); builder.append(context.getRefSetterName(expression)).append('('); ref.accept(this); builder.append(", "); } else { ref.accept(this); builder.append(".set("); } if (rValue != null) { rValue.accept(this); } builder.append(')'); }
writeAssignmentWithRefSetter
31,673
GrExpression (GrAssignmentExpression expression) { GrExpression rValue = expression.getRValue(); if (rValue == null) return null; GrExpression lValue = expression.getLValue(); IElementType opToken = expression.getOperationTokenType(); if (opToken == GroovyTokenTypes.mASSIGN) return rValue; Pair<String, IElementType> pair = GenerationUtil.getBinaryOperatorType(opToken); LOG.assertTrue(pair != null); return factory.createExpressionFromText(lValue.getText() + pair.getFirst() + rValue.getText(), expression); }
getRValue
31,674
void (GrExpression qualifier, PsiMethod setter, GrAssignmentExpression assignment) { GrExpression rValue = getRValue(assignment); LOG.assertTrue(rValue != null); writeAssignmentWithSetter(qualifier, setter, new GrExpression[]{rValue}, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, PsiSubstitutor.EMPTY, assignment); }
writeAssignmentWithSetter
31,675
void (@Nullable GrExpression qualifier, @NotNull PsiMethod method, GrExpression @NotNull [] exprs, GrNamedArgument @NotNull [] namedArgs, GrClosableBlock @NotNull [] closures, @NotNull PsiSubstitutor substitutor, @NotNull GrAssignmentExpression assignment) { if (PsiUtil.isExpressionUsed(assignment)) { final GrExpression rValue = assignment.getRValue(); //inline setter method invocation in case of tail statement and simple right value if (PsiUtil.isExpressionStatement(assignment) && PsiUtil.isReturnStatement(assignment) && rValue != null && isVarAccess(rValue)) { final StringBuilder assignmentBuffer = new StringBuilder(); new ExpressionGenerator(assignmentBuffer, context).invokeMethodOn(method, qualifier, exprs, namedArgs, closures, substitutor, assignment); assignmentBuffer.append(';'); context.myStatements.add(assignmentBuffer.toString()); rValue.accept(this); } else { String setterName = context.getSetterName(method, assignment); GrExpression[] args; if (method.hasModifierProperty(PsiModifier.STATIC)) { args = exprs; } else { args = new GrExpression[exprs.length + 1]; if (qualifier == null) { qualifier = factory.createExpressionFromText("this", assignment); } args[0] = qualifier; System.arraycopy(exprs, 0, args, 1, exprs.length); } GenerationUtil.invokeMethodByName(null, setterName, args, namedArgs, closures, this, assignment); } } else { invokeMethodOn(method, qualifier, exprs, namedArgs, closures, substitutor, assignment); } }
writeAssignmentWithSetter
31,676
boolean (@Nullable GrExpression expr) { if (expr instanceof GrReferenceExpression) { final PsiElement resolved = ((GrReferenceExpression)expr).resolve(); if (resolved instanceof PsiVariable) { return true; } } return false; }
isVarAccess
31,677
void (@NotNull GrBinaryExpression expression) { final GrExpression left = expression.getLeftOperand(); GrExpression right = expression.getRightOperand(); final PsiType ltype = left.getType(); final PsiElement token = expression.getOperationToken(); final IElementType op = expression.getOperationTokenType(); if (op == GroovyTokenTypes.mREGEX_FIND) { builder.append(GroovyCommonClassNames.JAVA_UTIL_REGEX_PATTERN).append(".compile("); if (right != null) { right.accept(this); } builder.append(").matcher("); left.accept(this); builder.append(')'); return; } if (op == GroovyTokenTypes.mREGEX_MATCH) { builder.append(GroovyCommonClassNames.JAVA_UTIL_REGEX_PATTERN).append(".matches("); if (right != null) { right.accept(this); } builder.append(", "); left.accept(this); builder.append(')'); return; } if ((op == GroovyTokenTypes.mEQUAL || op == GroovyTokenTypes.mNOT_EQUAL) && (GrInspectionUtil.isNull(left) || right != null && GrInspectionUtil.isNull(right))) { writeSimpleBinaryExpression(token, left, right); return; } if (op == GroovyTokenTypes.kIN && right instanceof GrReferenceExpression && InheritanceUtil.isInheritor(right.getType(), CommonClassNames.JAVA_LANG_CLASS)) { final PsiType type = com.intellij.psi.util.PsiUtil.substituteTypeParameter(right.getType(), CommonClassNames.JAVA_LANG_CLASS, 0, true); writeInstanceof(left, type, expression); return; } if (shouldNotReplaceOperatorWithMethod(ltype, right, op)) { writeSimpleBinaryExpression(token, left, right); return; } final GroovyResolveResult resolveResult = PsiImplUtil.extractUniqueResult(PsiUtilKt.multiResolve(expression)); final PsiElement resolved = resolveResult.getElement(); if (resolved instanceof PsiMethod) { if (right == null) { right = factory.createExpressionFromText("null"); } if (op == GroovyTokenTypes.mNOT_EQUAL && "equals".equals(((PsiMethod)resolved).getName())) { builder.append('!'); } invokeMethodOn( ((PsiMethod)resolved), left, new GrExpression[]{right}, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, resolveResult.getSubstitutor(), expression ); if (op == GroovyTokenTypes.mGE) { builder.append(" >= 0"); } else if (op == GroovyTokenTypes.mGT) { builder.append(" > 0"); } else if (op == GroovyTokenTypes.mLT) { builder.append(" < 0"); } else if (op == GroovyTokenTypes.mLE) builder.append(" <= 0"); } else { writeSimpleBinaryExpression(token, left, right); } }
visitBinaryExpression
31,678
boolean (@Nullable PsiType ltype, @Nullable GrExpression right, IElementType op) { if (!GenerationSettings.replaceOperatorsWithMethodsForNumbers) { //adding something to string if ((op == GroovyTokenTypes.mPLUS || op == GroovyTokenTypes.mPLUS_ASSIGN) && ltype != null && TypesUtil.isClassType(ltype, CommonClassNames.JAVA_LANG_STRING)) { return true; } //we think it is number operation if we don't know right argument if (TypesUtil.isNumericType(ltype) && (right == null || TypesUtil.isNumericType(right.getType()))) return true; } if (op == GroovyTokenTypes.mLNOT && isBooleanType(ltype)) { return true; } return false; }
shouldNotReplaceOperatorWithMethod
31,679
boolean (PsiType type) { return PsiTypes.booleanType().equals(type) || type != null && type.equalsToText(CommonClassNames.JAVA_LANG_BOOLEAN); }
isBooleanType
31,680
void (PsiElement opToken, GrExpression left, GrExpression right) { left.accept(this); builder.append(' '); builder.append(opToken.getText()); if (right != null) { builder.append(' '); right.accept(this); } }
writeSimpleBinaryExpression
31,681
void (@NotNull GrUnaryExpression expression) { final boolean postfix = expression.isPostfix(); final GroovyResolveResult resolveResult = expression.getReference().advancedResolve(); final PsiElement resolved = resolveResult.getElement(); final GrExpression operand = expression.getOperand(); IElementType opType = expression.getOperationTokenType(); if (resolved instanceof PsiMethod) { if (opType == GroovyTokenTypes.mINC || opType == GroovyTokenTypes.mDEC) { if (!postfix || expression.getParent() instanceof GrStatementOwner || expression.getParent() instanceof GrControlStatement) { if (generatePrefixIncDec((PsiMethod)resolved, operand, expression)) return; } } if (operand != null && shouldNotReplaceOperatorWithMethod(operand.getType(), null, expression.getOperationTokenType())) { writeSimpleUnary(operand, expression, this); } else { if (opType == GroovyTokenTypes.mLNOT) { builder.append('!'); } invokeMethodOn( ((PsiMethod)resolved), operand, GrExpression.EMPTY_ARRAY, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, resolveResult.getSubstitutor(), expression ); } } else if (operand != null) { if (postfix) { operand.accept(this); builder.append(expression.getOperationToken().getText()); } else { builder.append(expression.getOperationToken().getText()); operand.accept(this); } } }
visitUnaryExpression
31,682
boolean (PsiMethod method, GrExpression operand, GrUnaryExpression unary) { if (!(operand instanceof GrReferenceExpression)) return false; final GrExpression qualifier = ((GrReferenceExpression)operand).getQualifier(); final GroovyReference rValueReference = ((GrReferenceExpression)operand).getRValueReference(); final GroovyResolveResult resolveResult = rValueReference == null ? EmptyGroovyResolveResult.INSTANCE : rValueReference.advancedResolve(); final PsiElement resolved = resolveResult.getElement(); if (resolved instanceof PsiMethod getter && GroovyPropertyUtils.isSimplePropertyGetter((PsiMethod)resolved)) { final String propertyName = GroovyPropertyUtils.getPropertyNameByGetter(getter); final PsiType type; if (qualifier == null) { type = null; } else { type = qualifier.getType(); if (type == null) return false; } final PsiMethod setter = GroovyPropertyUtils.findPropertySetter(type, propertyName, unary); if (setter == null) return false; final ExpressionGenerator generator = new ExpressionGenerator(new StringBuilder(), context); if (shouldNotReplaceOperatorWithMethod(operand.getType(), null, unary.getOperationTokenType())) { writeSimpleUnary(operand, unary, generator); } else { generator.invokeMethodOn( method, operand, GrExpression.EMPTY_ARRAY, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, resolveResult.getSubstitutor(), unary ); } final GrExpression fromText = factory.createExpressionFromText(generator.toString(), unary); invokeMethodOn( setter, qualifier, new GrExpression[]{fromText}, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, resolveResult.getSubstitutor(), unary ); } else if (resolved instanceof PsiVariable) { boolean wrap = context.analyzedVars.toWrap((PsiVariable)resolved); boolean doNeedExpression = PsiUtil.isExpressionUsed(unary); StringBuilder curBuilder; ExpressionGenerator curGenerator; if (doNeedExpression && wrap) { curBuilder = new StringBuilder(); curGenerator = new ExpressionGenerator(curBuilder, context); } else { curBuilder = builder; curGenerator = this; } if (shouldNotReplaceOperatorWithMethod(operand.getType(), null, unary.getOperationTokenType())) { if (wrap) { operand.accept(curGenerator); curBuilder.append(".set("); ((GrExpression)operand.copy()).accept(curGenerator); curBuilder.append(" + 1"); } else { writeSimpleUnary((GrExpression)operand.copy(), unary, curGenerator); } } else { operand.accept(curGenerator); curBuilder.append(wrap ? ".set(" : " = "); curGenerator.invokeMethodOn( method, (GrExpression)operand.copy(), GrExpression.EMPTY_ARRAY, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, resolveResult.getSubstitutor(), unary ); } if (wrap) { curBuilder.append(')'); if (doNeedExpression) { curBuilder.append(';'); context.myStatements.add(curBuilder.toString()); operand.accept(this); builder.append(".get()"); } } } return true; }
generatePrefixIncDec
31,683
void (GrExpression operand, GrUnaryExpression unary, ExpressionGenerator generator) { String opTokenText = unary.getOperationToken().getText(); boolean isPostfix = unary.isPostfix(); if (!isPostfix) { generator.getBuilder().append(opTokenText); } operand.accept(generator); if (isPostfix) { generator.getBuilder().append(opTokenText); } }
writeSimpleUnary
31,684
void (@NotNull GrLiteral literal) { final TypeConstraint[] constraints = GroovyExpectedTypesProvider.calculateTypeConstraints(literal); boolean isChar = false; for (TypeConstraint constraint : constraints) { if (constraint instanceof SubtypeConstraint && PsiTypes.charType().equals(TypesUtil.unboxPrimitiveTypeWrapper(constraint.getDefaultType()))) { isChar = true; } } final String text = literal.getText(); final String value = GrStringUtil.unescapeString(GrStringUtil.removeQuotes(text)); if (text.startsWith("'''") || text.startsWith("\"\"\"")) { if (HighlightingFeature.TEXT_BLOCKS.isAvailable(literal)) { builder .append("\"\"\"\n") .append(PsiLiteralUtil.escapeTextBlockCharacters(StringUtil.escapeStringCharacters(value))) .append("\"\"\""); } else { String content = StringUtil.escapeStringCharacters(value).replaceAll("\\\\n([^\"])", "\\\\n\" +\n \"$1"); builder.append('"').append(content).append('"'); } } else if (text.startsWith("'")) { if (isChar) { builder.append(text); } else { builder.append('"').append(StringUtil.escapeStringCharacters(value)).append('"'); } } else if (text.startsWith("\"")) { if (isChar) { builder.append('\'').append(StringUtil.escapeCharCharacters(value)).append('\''); } else { builder.append('"').append(StringUtil.escapeStringCharacters(value)).append('"'); } } else { builder.append(text); } }
visitLiteralExpression
31,685
void (@NotNull GrString gstring) { final String newExprText = ConvertGStringToStringIntention.convertGStringLiteralToStringLiteral(gstring); final GrExpression newExpr = factory.createExpressionFromText(newExprText, gstring); newExpr.accept(this); }
visitGStringExpression
31,686
void (@NotNull GrReferenceExpression referenceExpression) { final GrExpression qualifier = referenceExpression.getQualifier(); final GroovyResolveResult resolveResult = referenceExpression.advancedResolve(); final PsiElement resolved = resolveResult.getElement(); final String referenceName = referenceExpression.getReferenceName(); if (PsiUtil.isThisOrSuperRef(referenceExpression)) { writeThisOrSuperRef(referenceExpression, qualifier, referenceName); return; } if (ResolveUtil.isClassReference(referenceExpression)) { // just delegate to qualifier LOG.assertTrue(qualifier != null); qualifier.accept(this); return; } if (resolved instanceof PsiClass) { builder.append(((PsiClass)resolved).getQualifiedName()); if (PsiUtil.isExpressionUsed(referenceExpression)) { builder.append(".class"); } return; } //don't try to resolve local vars that are provided my this generator (they are listed in myUsedVarNames) if (resolved == null && qualifier == null && context.myUsedVarNames.contains(referenceName)) { builder.append(referenceName); return; } //all refs in script that are not resolved are saved in 'binding' of the script if (qualifier == null && (resolved == null || resolved instanceof LightElement && !(resolved instanceof ClosureSyntheticParameter)) && (referenceExpression.getParent() instanceof GrIndexProperty || !(referenceExpression.getParent() instanceof GrCall)) && PsiUtil.getContextClass(referenceExpression) instanceof GroovyScriptClass) { final GrExpression thisExpr = factory.createExpressionFromText("this", referenceExpression); thisExpr.accept(this); builder.append(".getBinding().getProperty(\"").append(referenceExpression.getReferenceName()).append("\")"); return; } final IElementType type = referenceExpression.getDotTokenType(); GrExpression qualifierToUse = qualifier; if (type == GroovyTokenTypes.mMEMBER_POINTER) { LOG.assertTrue(qualifier != null); builder.append("new ").append(GroovyCommonClassNames.ORG_CODEHAUS_GROOVY_RUNTIME_METHOD_CLOSURE).append('('); qualifier.accept(this); builder.append(", \"").append(referenceName).append("\")"); return; } if (type == GroovyTokenTypes.mOPTIONAL_DOT || qualifierHasSafeChain(referenceExpression)) { LOG.assertTrue(qualifier != null); String qualifierName = createVarByInitializer(qualifier); builder.append('(').append(qualifierName).append(" == null ? null : "); qualifierToUse = factory.createReferenceExpressionFromText(qualifierName, referenceExpression); } if (resolveResult.isInvokedOnProperty() && resolved instanceof PsiMethod) { //property-style access to accessor (e.g. qual.prop should be translated to qual.getProp()) LOG.assertTrue(GroovyPropertyUtils.isSimplePropertyGetter((PsiMethod)resolved)); invokeMethodOn( ((PsiMethod)resolved), qualifierToUse, GrExpression.EMPTY_ARRAY, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, resolveResult.getSubstitutor(), referenceExpression ); } else { if (qualifierToUse != null) { qualifierToUse.accept(this); builder.append('.'); } if (resolved instanceof PsiNamedElement && !(resolved instanceof GrBindingVariable)) { final String refName = ((PsiNamedElement)resolved).getName(); if (resolved instanceof GrVariable && context.analyzedVars.toWrap((GrVariable)resolved)) { //this var should be wrapped by groovy.lang.Reference. so we add .get() tail. builder.append(context.analyzedVars.toVarName((GrVariable)resolved)); if (!PsiUtil.isAccessedForWriting(referenceExpression)) { builder.append(".get()"); } } else { builder.append(refName); } } else { //unresolved reference if (referenceName != null) { if (PsiUtil.isAccessedForWriting(referenceExpression)) { builder.append(referenceName); } else { PsiType stringType = PsiType.getJavaLangString(referenceExpression.getManager(), referenceExpression.getResolveScope()); PsiType qualifierType = PsiImplUtil.getQualifierType(referenceExpression); GroovyResolveResult[] candidates = qualifierType != null ? ResolveUtil.getMethodCandidates(qualifierType, "getProperty", referenceExpression, stringType) : GroovyResolveResult.EMPTY_ARRAY; final PsiElement method = PsiImplUtil.extractUniqueElement(candidates); if (method != null) { builder.append("getProperty(\"").append(referenceName).append("\")"); } else { builder.append(referenceName); } } } else { final PsiElement nameElement = referenceExpression.getReferenceNameElement(); if (nameElement instanceof GrExpression) { ((GrExpression)nameElement).accept(this); } else if (nameElement != null) { builder.append(nameElement.toString()); } } } } if (type == GroovyTokenTypes.mOPTIONAL_DOT || qualifierHasSafeChain(referenceExpression)) { builder.append(')'); } }
visitReferenceExpression
31,687
boolean (GrExpression expression) { if (expression instanceof GrMethodCallExpression) { expression = ((GrMethodCallExpression)expression).getInvokedExpression(); } if (!(expression instanceof GrReferenceExpression)) { return false; } if (GroovyTokenTypes.mOPTIONAL_CHAIN_DOT.equals(((GrReferenceExpression)expression).getDotTokenType())) { return true; } return qualifierHasSafeChain(((GrReferenceExpression)expression).getQualifierExpression()); }
qualifierHasSafeChain
31,688
void (GrReferenceExpression referenceExpression, GrExpression qualifier, String referenceName) { if (!context.isInAnonymousContext() && qualifier != null) { qualifier.accept(this); builder.append('.'); builder.append(referenceName); } else if (GenerationUtil.getWrappingImplicitClass(referenceExpression) != null) { final PsiClass contextClass; if ("this".equals(referenceName)) { final PsiElement _contextClass = referenceExpression.resolve(); if (_contextClass instanceof PsiClass) { contextClass = (PsiClass)_contextClass; } else { contextClass = null; } GenerationUtil.writeThisReference(contextClass, builder, context); } else { //super ref //super ref is used without qualifier. So we should use context class as a qualifier contextClass = PsiUtil.getContextClass(referenceExpression); GenerationUtil.writeSuperReference(contextClass, builder, context); } } else { builder.append(referenceName); } }
writeThisOrSuperRef
31,689
String (@NotNull GrExpression initializer) { GrExpression inner = initializer; while (inner instanceof GrParenthesizedExpression) inner = ((GrParenthesizedExpression)inner).getOperand(); if (inner != null) initializer = inner; if (initializer instanceof GrReferenceExpression) { final GrExpression qualifier = ((GrReferenceExpression)initializer).getQualifier(); if (qualifier == null) { final PsiElement resolved = ((GrReferenceExpression)initializer).resolve(); if (resolved instanceof GrVariable && !(resolved instanceof GrField)) { //don't create new var. it is already exists return ((GrVariable)resolved).getName(); } } } final String name = GenerationUtil.suggestVarName(initializer, context); final StringBuilder builder = new StringBuilder(); builder.append("final "); TypeWriter.writeType(builder, initializer.getType(), initializer); builder.append(' ').append(name).append(" = "); initializer.accept(new ExpressionGenerator(builder, context)); builder.append(';'); context.myStatements.add(builder.toString()); return name; }
createVarByInitializer
31,690
void (@NotNull GrTypeCastExpression typeCastExpression) { final GrTypeElement typeElement = typeCastExpression.getCastTypeElement(); final GrExpression operand = typeCastExpression.getOperand(); generateCast(typeElement, operand); }
visitCastExpression
31,691
void (GrTypeElement typeElement, GrExpression operand) { builder.append('('); TypeWriter.writeType(builder, typeElement.getType(), typeElement); builder.append(')'); boolean insertParentheses = operand instanceof GrBinaryExpression && ((GrBinaryExpression)operand).getOperationTokenType() == GroovyTokenTypes.mEQUAL; if (insertParentheses) builder.append('('); if (operand != null) { operand.accept(this); } if (insertParentheses) builder.append(')'); }
generateCast
31,692
void (@NotNull GrSafeCastExpression typeCastExpression) { final GrExpression operand = (GrExpression)PsiUtil.skipParenthesesIfSensibly(typeCastExpression.getOperand(), false); final GrTypeElement typeElement = typeCastExpression.getCastTypeElement(); if (operand instanceof GrListOrMap && ((GrListOrMap)operand).isMap() && typeElement != null) { AnonymousFromMapGenerator.writeAnonymousMap((GrListOrMap)operand, typeElement, builder, context); return; } final PsiType type = typeElement.getType(); if (operand instanceof GrListOrMap && !((GrListOrMap)operand).isMap() && type instanceof PsiArrayType) { builder.append("new "); final GrExpression[] initializers = ((GrListOrMap)operand).getInitializers(); if (initializers.length == 0) { TypeWriter.writeTypeForNew(builder, ((PsiArrayType)type).getComponentType(), typeCastExpression); builder.append("[0]"); } else { TypeWriter.writeTypeForNew(builder, type, typeCastExpression); builder.append('{'); final PsiType newExpectedType = expectedType instanceof PsiArrayType ? ((PsiArrayType)expectedType).getComponentType() : null; final ExpressionGenerator childGenerator = new ExpressionGenerator(builder, context, newExpectedType); for (GrExpression initializer : initializers) { initializer.accept(childGenerator); builder.append(", "); } builder.delete(builder.length() - 2, builder.length()); builder.append('}'); } return; } final GroovyResolveResult resolveResult = PsiImplUtil.extractUniqueResult(typeCastExpression.getReference().multiResolve(false)); final PsiElement resolved = resolveResult.getElement(); if (resolved instanceof PsiMethod) { final GrExpression typeParam; try { typeParam = factory.createExpressionFromText(typeElement.getText(), typeCastExpression); } catch (IncorrectOperationException e) { generateCast(typeElement, operand); return; } invokeMethodOn( ((PsiMethod)resolved), operand, new GrExpression[]{typeParam}, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, resolveResult.getSubstitutor(), typeCastExpression ); } else { generateCast(typeElement, operand); } }
visitSafeCastExpression
31,693
void (@NotNull GrInstanceOfExpression expression) { final GrExpression operand = expression.getOperand(); final GrTypeElement typeElement = expression.getTypeElement(); writeInstanceof(operand, typeElement != null ? typeElement.getType() : null, expression); }
visitInstanceofExpression
31,694
void (@NotNull GrExpression operand, @Nullable PsiType type, @NotNull PsiElement context) { operand.accept(this); builder.append(" instanceof "); if (type != null) { TypeWriter.writeType(builder, type, context); } }
writeInstanceof
31,695
void (@NotNull GrBuiltinTypeClassExpression expression) { PsiElement firstChild = expression.getFirstChild(); LOG.assertTrue(firstChild != null); ASTNode node = firstChild.getNode(); LOG.assertTrue(node != null); final IElementType type = node.getElementType(); final String boxed = TypesUtil.getBoxedTypeName(type); builder.append(boxed); if (expression.getParent() instanceof GrIndexProperty) { builder.append("[]"); } builder.append(".class"); }
visitBuiltinTypeClassExpression
31,696
void (@NotNull GrParenthesizedExpression expression) { builder.append('('); final GrExpression operand = expression.getOperand(); if (operand != null) { operand.accept(this); } builder.append(')'); }
visitParenthesizedExpression
31,697
void (@NotNull GrPropertySelection expression) { expression.getQualifier().accept(this); builder.append('.'); builder.append(expression.getReferenceNameElement().getText()); }
visitPropertySelection
31,698
void (@NotNull GrIndexProperty expression) { final GrExpression selectedExpression = expression.getInvokedExpression(); final PsiType thisType = selectedExpression.getType(); final GrArgumentList argList = expression.getArgumentList(); if (argList.getAllArguments().length == 0) { // int[] or String[] if (selectedExpression instanceof GrBuiltinTypeClassExpression) { selectedExpression.accept(this); return; } else if (selectedExpression instanceof GrReferenceExpression) { PsiElement resolved = ((GrReferenceExpression)selectedExpression).resolve(); if (resolved instanceof PsiClass) { builder.append(((PsiClass)resolved).getQualifiedName()); builder.append("[].class"); return; } } } final PsiType[] argTypes = PsiUtil.getArgumentTypes(argList); final GrExpression[] exprArgs = argList.getExpressionArguments(); final GrNamedArgument[] namedArgs = argList.getNamedArguments(); if (!PsiImplUtil.isSimpleArrayAccess(thisType, argTypes, expression, PsiUtil.isLValue(expression))) { final GroovyResolveResult candidate = advancedResolve(expression); PsiElement element = candidate.getElement(); if (element != null || !PsiUtil.isLValue(expression)) { //see the case of l-value in assignment expression if (element instanceof GrGdkMethod && ((GrGdkMethod)element).getReceiverType().equalsToText("java.util.Map<K,V>")) { PsiClass map = JavaPsiFacade.getInstance(context.project).findClass(CommonClassNames.JAVA_UTIL_MAP, expression.getResolveScope()); if (map != null) { PsiMethod[] gets = map.findMethodsByName("get", false); invokeMethodOn(gets[0], selectedExpression, exprArgs, namedArgs, GrClosableBlock.EMPTY_ARRAY, PsiSubstitutor.EMPTY, expression); return; } } else if (element instanceof GrGdkMethod && ((GrGdkMethod)element).getReceiverType().equalsToText("java.util.List<T>")) { PsiClass list = JavaPsiFacade.getInstance(context.project).findClass(CommonClassNames.JAVA_UTIL_LIST, expression.getResolveScope()); if (list != null) { PsiMethod[] gets = list.findMethodsByName("get", false); invokeMethodOn(gets[0], selectedExpression, exprArgs, namedArgs, GrClosableBlock.EMPTY_ARRAY, PsiSubstitutor.EMPTY, expression); return; } } GenerationUtil .invokeMethodByResolveResult(selectedExpression, candidate, "getAt", exprArgs, namedArgs, GrClosableBlock.EMPTY_ARRAY, this, expression); return; } } selectedExpression.accept(this); builder.append('['); final GrExpression arg = exprArgs[0]; arg.accept(this); builder.append(']'); }
visitIndexProperty
31,699
void (@NotNull PsiMethod method, @Nullable GrExpression caller, GrExpression @NotNull [] exprs, GrNamedArgument @NotNull [] namedArgs, GrClosableBlock @NotNull [] closures, @NotNull PsiSubstitutor substitutor, @NotNull GroovyPsiElement context) { if (method instanceof GrGdkMethod) { if (CustomMethodInvocator.invokeMethodOn(this, (GrGdkMethod)method, caller, exprs, namedArgs, closures, substitutor, context)) return; GrExpression[] newArgs = new GrExpression[exprs.length + 1]; System.arraycopy(exprs, 0, newArgs, 1, exprs.length); if (method.hasModifierProperty(PsiModifier.STATIC)) { newArgs[0] = factory.createExpressionFromText("null"); } else { if (caller == null) { caller = factory.createExpressionFromText("this", context); } newArgs[0] = caller; } invokeMethodOn(((GrGdkMethod)method).getStaticMethod(), null, newArgs, namedArgs, closures, substitutor, context); return; } if (method.hasModifierProperty(PsiModifier.STATIC) && caller == null) { final PsiClass containingClass = method.getContainingClass(); if (containingClass != null && !PsiTreeUtil.isAncestor(containingClass, context, true)) { builder.append(containingClass.getQualifiedName()).append('.'); } } else { //LOG.assertTrue(caller != null, "instance method call should have caller"); if (caller != null) { final boolean castNeeded = GenerationUtil.isCastNeeded(caller, method, this.context); if (castNeeded) { writeCastForMethod(caller, method, context); } caller.accept(this); if (castNeeded) { builder.append(')'); } builder.append('.'); } } builder.append(GroovyToJavaGenerator.convertToJavaIdentifier(method.getName())); final GrSignature signature = GrClosureSignatureUtil.createSignature(method, substitutor); new ArgumentListGenerator(builder, this.context).generate(signature, exprs, namedArgs, closures, context); }
invokeMethodOn