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,700
void (@NotNull GrExpression caller, @NotNull PsiMethod method, @NotNull GroovyPsiElement context) { final PsiType type = inferCastType(caller, method, context); if (type == null) return; builder.append('('); builder.append('('); TypeWriter.writeType(builder, type, context); builder.append(')'); }
writeCastForMethod
31,701
PsiType (@NotNull GrExpression caller, @NotNull PsiMethod method, @NotNull GroovyPsiElement context) { final PsiType type = caller.getType(); if (type instanceof PsiIntersectionType) { final PsiType[] conjuncts = ((PsiIntersectionType)type).getConjuncts(); for (PsiType conjunct : conjuncts) { final GenerationUtil.CheckProcessElement processor = new GenerationUtil.CheckProcessElement(method); ResolveUtil.processAllDeclarations(conjunct, processor, false, context); if (processor.isFound()) return conjunct; } } return type; }
inferCastType
31,702
void (@NotNull GrListOrMap listOrMap) { final PsiType type = listOrMap.getType(); LOG.assertTrue(type instanceof PsiClassType); if (listOrMap.isMap()) { if (listOrMap.getNamedArguments().length == 0) { builder.append("new "); TypeWriter.writeTypeForNew(builder, type, listOrMap); builder.append("()"); } else { String varName = generateMapVariableDeclaration(listOrMap, type); generateMapElementInsertions(listOrMap, varName); builder.append(varName); } } else { builder.append("new "); PsiType typeToUse = getTypeToUseByList(listOrMap, type); TypeWriter.writeTypeForNew(builder, typeToUse, listOrMap); if (typeToUse instanceof PsiArrayType) { if (listOrMap.getInitializers().length == 0) { builder.replace(builder.length() - 2, builder.length(), "[0]"); } else { builder.append('{'); genInitializers(listOrMap); builder.append('}'); } } else if (listOrMap.getInitializers().length == 0) { builder.append("()"); } else { builder.append("(java.util.Arrays.asList("); genInitializers(listOrMap); builder.append("))"); } } }
visitListOrMap
31,703
PsiType (GrListOrMap listOrMap, PsiType type) { if (isImplicitlyCastedToArray(listOrMap)) { PsiType iterable = ClosureParameterEnhancer.findTypeForIteration(listOrMap, listOrMap); if (iterable != null) { return new PsiArrayType(iterable); } } else if (expectedType instanceof PsiArrayType) { return expectedType; } if (type instanceof PsiClassType) { PsiClass resolved = ((PsiClassType)type).resolve(); if (resolved != null && CommonClassNames.JAVA_UTIL_LIST.equals(resolved.getQualifiedName())) { JavaPsiFacade facade = JavaPsiFacade.getInstance(listOrMap.getProject()); PsiClass arrayList = facade.findClass(CommonClassNames.JAVA_UTIL_ARRAY_LIST, listOrMap.getResolveScope()); if (arrayList != null) { return facade.getElementFactory().createType(arrayList, ((PsiClassType)type).getParameters()); } } } return type; }
getTypeToUseByList
31,704
boolean (GrListOrMap list) { PsiElement parent = list.getParent(); GrControlFlowOwner owner = ControlFlowUtils.findControlFlowOwner(list); if (!(owner instanceof GrOpenBlock && owner.getParent() instanceof GrMethod)) return false; if (!(parent instanceof GrReturnStatement || ControlFlowUtils.isReturnValue(list, owner))) return false; PsiType type = ((GrMethod)owner.getParent()).getReturnType(); return type instanceof PsiArrayType; }
isImplicitlyCastedToArray
31,705
void (GrListOrMap listOrMap, String varName) { for (GrNamedArgument arg : listOrMap.getNamedArguments()) { StringBuilder insertion = new StringBuilder(); insertion.append(varName).append(".put("); final String stringKey = arg.getLabelName(); if (stringKey != null) { insertion.append('"').append(stringKey).append('"'); } else { final GrArgumentLabel label = arg.getLabel(); final GrExpression expression = label == null ? null : label.getExpression(); if (expression != null) { expression.accept(new ExpressionGenerator(insertion, context)); } else { //todo should we generate an exception? } } insertion.append(", "); final GrExpression expression = arg.getExpression(); if (expression != null) { expression.accept(new ExpressionGenerator(insertion, context)); } else { //todo should we generate an exception? } insertion.append(");"); context.myStatements.add(insertion.toString()); } }
generateMapElementInsertions
31,706
String (GrListOrMap listOrMap, PsiType type) { StringBuilder declaration = new StringBuilder(); TypeWriter.writeType(declaration, type, listOrMap); final String varName = GenerationUtil.suggestVarName(type, listOrMap, this.context); declaration.append(' ').append(varName).append(" = new "); TypeWriter.writeTypeForNew(declaration, type, listOrMap); declaration.append('('); //insert count of elements in list or map declaration.append(listOrMap.getNamedArguments().length); declaration.append(");"); context.myStatements.add(declaration.toString()); return varName; }
generateMapVariableDeclaration
31,707
void (GrListOrMap list) { LOG.assertTrue(!list.isMap()); final GrExpression[] initializers = list.getInitializers(); for (GrExpression expr : initializers) { expr.accept(this); builder.append(", "); } if (initializers.length > 0) { builder.delete(builder.length() - 2, builder.length()); //builder.removeFromTheEnd(2); } }
genInitializers
31,708
void (@NotNull GrRangeExpression range) { final PsiType type = range.getType(); LOG.assertTrue(type instanceof GrRangeType); final PsiClass resolved = ((GrRangeType)type).resolve(); builder.append("new "); if (resolved == null || GroovyCommonClassNames.GROOVY_LANG_RANGE.equals(resolved.getQualifiedName())) { builder.append(GroovyCommonClassNames.GROOVY_LANG_OBJECT_RANGE); } else { builder.append(resolved.getQualifiedName()); } builder.append('('); final GrExpression left = range.getFrom(); left.accept(this); builder.append(", "); final GrExpression right = range.getTo(); if (right != null) { right.accept(this); } builder.append(')'); }
visitRangeExpression
31,709
void (@NotNull GrExpressionList expressionList) { boolean first = true; for (GrExpression expression : expressionList.getExpressions()) { if (!first) { builder.append(", "); } else { first = false; } expression.accept(this); } }
visitExpressionList
31,710
void (@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) { invokeInner(project, new PsiElement[]{file}, editor); }
invoke
31,711
void (@NotNull Project project, PsiElement @NotNull [] elements, DataContext dataContext) { Editor editor = null; if (dataContext != null) { editor = CommonDataKeys.EDITOR.getData(dataContext); } invokeInner(project, elements, editor); }
invoke
31,712
void (Project project, PsiElement[] elements, Editor editor) { Set<GroovyFile> files = new HashSet<>(); for (PsiElement element : elements) { if (!(element instanceof PsiFile)) { element = element.getContainingFile(); } if (element instanceof GroovyFile) { files.add((GroovyFile)element); } else { if (!ApplicationManager.getApplication().isUnitTestMode()) { CommonRefactoringUtil.showErrorHint( project, editor, GroovyRefactoringBundle.message("convert.to.java.can.work.only.with.groovy"), GroovyRefactoringBundle.message("convert.to.java.refactoring.name"), null ); return; } } } new ConvertToJavaProcessor(project, files.toArray(GroovyFile.EMPTY_ARRAY)).run(); }
invokeInner
31,713
void (@NotNull StringBuilder builder, @Nullable PsiType type, @NotNull PsiElement context) { //new Array[] cannot contain generics if (type instanceof PsiArrayType) { PsiType erased = TypeConversionUtil.erasure(type); if (erased != null) { type = erased; } } writeType(builder, type, context, new GeneratorClassNameProvider()); }
writeTypeForNew
31,714
void (@NotNull StringBuilder builder, @Nullable PsiType type, @NotNull PsiElement context) { writeType(builder, type, context, new GeneratorClassNameProvider()); }
writeType
31,715
void (@NotNull final StringBuilder builder, @Nullable PsiType type, @NotNull final PsiElement context, @NotNull final ClassNameProvider classNameProvider) { if (type == null || PsiTypes.nullType().equals(type)) { builder.append(CommonClassNames.JAVA_LANG_OBJECT); return; } if (type instanceof PsiPrimitiveType) { builder.append(type.getCanonicalText()); return; } final boolean acceptEllipsis = isLastParameter(context); type.accept(new TypeWriter(builder, classNameProvider, acceptEllipsis, context)); }
writeType
31,716
Object (@NotNull PsiEllipsisType ellipsisType) { final PsiType componentType = ellipsisType.getComponentType(); componentType.accept(this); if (acceptEllipsis) { builder.append("..."); } else { builder.append("[]"); } return this; }
visitEllipsisType
31,717
Object (@NotNull PsiPrimitiveType primitiveType) { if (classNameProvider.forStubs()) { builder.append(primitiveType.getCanonicalText()); return this; } final PsiType boxed = TypesUtil.boxPrimitiveType(primitiveType, context.getManager(), context.getResolveScope()); boxed.accept(this); return this; }
visitPrimitiveType
31,718
Object (@NotNull PsiArrayType arrayType) { arrayType.getComponentType().accept(this); builder.append("[]"); return this; }
visitArrayType
31,719
Object (@NotNull PsiClassType classType) { final PsiType[] parameters = classType.getParameters(); final PsiClass psiClass = classType.resolve(); if (psiClass == null) { builder.append(classType.getClassName()); } else if (psiClass instanceof GrAnonymousClassDefinition) { visitClassType(((GrAnonymousClassDefinition)psiClass).getBaseClassType()); } else { final String qname = classNameProvider.getQualifiedClassName(psiClass, context); builder.append(qname); } GenerationUtil.writeTypeParameters(builder, parameters, context, classNameProvider); return this; }
visitClassType
31,720
Object (@NotNull PsiCapturedWildcardType capturedWildcardType) { capturedWildcardType.getWildcard().accept(this); return this; }
visitCapturedWildcardType
31,721
Object (@NotNull PsiWildcardType wildcardType) { builder.append('?'); PsiType bound = wildcardType.getBound(); if (bound == null) return this; if (wildcardType.isExtends()) { builder.append(" extends "); } else { builder.append(" super "); } bound.accept(this); return this; }
visitWildcardType
31,722
Object (@NotNull PsiDisjunctionType disjunctionType) { //it is not available in groovy source code throw new UnsupportedOperationException(); }
visitDisjunctionType
31,723
Object (@NotNull PsiType type) { throw new UnsupportedOperationException(); }
visitType
31,724
boolean (@NotNull PsiElement context) { if (context instanceof PsiParameter) { final PsiElement scope = ((PsiParameter)context).getDeclarationScope(); if (scope instanceof PsiMethod) { final PsiParameter[] parameters = ((PsiMethod)scope).getParameterList().getParameters(); return parameters.length > 0 && parameters[parameters.length - 1] == context; } } return false; }
isLastParameter
31,725
void (@NotNull StringBuilder builder, @NotNull ExpressionContext context, @NotNull GrSwitchStatement switchStatement) { final GrExpression condition = switchStatement.getCondition(); final GrCaseSection[] caseSections = switchStatement.getCaseSections(); final PsiType type = condition == null ? null : TypesUtil.unboxPrimitiveTypeWrapper(condition.getType()); if (type == null || isValidTypeForSwitchSelector(type)) { generateSwitch(builder, context, condition, caseSections); } else { generateIfs(builder, context, condition, caseSections); } }
generate
31,726
boolean (@NotNull PsiType type) { if (TypeConversionUtil.getTypeRank(type) <= TypeConversionUtil.INT_RANK) { return true; } PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(type); if (aClass != null && aClass.isEnum()) { return true; } return false; }
isValidTypeForSwitchSelector
31,727
void (@NotNull StringBuilder builder, @NotNull ExpressionContext context, @NotNull GrExpression condition, GrCaseSection @NotNull [] caseSections) { final GrExpression ref; if (condition instanceof GrReferenceExpression) { ref = condition; } else { final String varName = generateConditionVar(builder, context, condition); ref = GroovyPsiElementFactory.getInstance(context.project).createExpressionFromText(varName); } final GrExpression[] args = {ref}; generateIfFromCaseSection(builder, context, caseSections, 0, List.of(), args); }
generateIfs
31,728
void (@NotNull StringBuilder builder, @NotNull ExpressionContext context, final GrCaseSection @NotNull [] caseSections, final int i, final List<GrCaseSection> currentSequentialSectionFrame, final GrExpression @NotNull [] args) { GenerationUtil.writeStatement(builder, context, null, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { if (caseSections.length == 1 && caseSections[0].isDefault()) { builder.append("if(true)"); } GrCaseSection section = caseSections[i]; if (section.getStatements().length != 0) { final boolean isCase = currentSequentialSectionFrame.size() > 1 || !section.isDefault(); if (isCase) { writeCondition(builder, context, section, currentSequentialSectionFrame, args); } writeCaseBody(builder, context, i, caseSections); if (isCase && i != caseSections.length - 1) { builder.append("\nelse "); StringBuilder elseBuilder = new StringBuilder(); final ExpressionContext elseContext = context.extend(); generateIfFromCaseSection(elseBuilder, elseContext, caseSections, i + 1, List.of(), args); GenerationUtil.insertStatementFromContextBefore(builder, elseContext); builder.append(elseBuilder); } if (!context.myStatements.isEmpty()) { context.setInsertCurlyBrackets(); } } else { var list = new ArrayList<>(currentSequentialSectionFrame); list.add(section); generateIfFromCaseSection(builder, context, caseSections, i + 1, list, args); } } }); }
generateIfFromCaseSection
31,729
void (StringBuilder builder, ExpressionContext context) { if (caseSections.length == 1 && caseSections[0].isDefault()) { builder.append("if(true)"); } GrCaseSection section = caseSections[i]; if (section.getStatements().length != 0) { final boolean isCase = currentSequentialSectionFrame.size() > 1 || !section.isDefault(); if (isCase) { writeCondition(builder, context, section, currentSequentialSectionFrame, args); } writeCaseBody(builder, context, i, caseSections); if (isCase && i != caseSections.length - 1) { builder.append("\nelse "); StringBuilder elseBuilder = new StringBuilder(); final ExpressionContext elseContext = context.extend(); generateIfFromCaseSection(elseBuilder, elseContext, caseSections, i + 1, List.of(), args); GenerationUtil.insertStatementFromContextBefore(builder, elseContext); builder.append(elseBuilder); } if (!context.myStatements.isEmpty()) { context.setInsertCurlyBrackets(); } } else { var list = new ArrayList<>(currentSequentialSectionFrame); list.add(section); generateIfFromCaseSection(builder, context, caseSections, i + 1, list, args); } }
writeStatement
31,730
void (@NotNull StringBuilder builder, @NotNull ExpressionContext context, int i, GrCaseSection @NotNull [] caseSections) { builder.append("{\n"); final ExpressionContext extended = context.extend(); CodeBlockGenerator generator = new CodeBlockGenerator(builder, extended); Outer: for (int j = i; j < caseSections.length; j++) { GrCaseSection curSection = caseSections[j]; final GrStatement[] statements = curSection.getStatements(); for (GrStatement statement : statements) { if (statement instanceof GrBreakStatement && ((GrBreakStatement)statement).getLabelIdentifier() == null) { break Outer; } statement.accept(generator); builder.append("\n"); } if (brakesFlow(curSection)) break; } builder.append('}'); }
writeCaseBody
31,731
boolean (GrCaseSection section) { final GrStatement[] statements = section.getStatements(); return statements.length > 0 && !ControlFlowUtils.statementMayCompleteNormally(ArrayUtil.getLastElement(statements)); }
brakesFlow
31,732
void (StringBuilder builder, ExpressionContext context, GrCaseSection section, List<GrCaseSection> currentSequentialSectionFrame, GrExpression[] args) { builder.append("if ("); for (GrCaseSection prevSection : currentSequentialSectionFrame) { appendCaseSection(builder, context, args, prevSection); } appendCaseSection(builder, context, args, section); builder.delete(builder.length() - 2, builder.length()); builder.append(") "); }
writeCondition
31,733
void (StringBuilder builder, ExpressionContext context, GrExpression[] args, GrCaseSection prevSection) { if (prevSection.isDefault()) { builder.append("true"); } else { GenerationUtil.invokeMethodByName( prevSection.getExpressions()[0], "isCase", args, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, new ExpressionGenerator(builder, context), prevSection ); } builder.append("||"); }
appendCaseSection
31,734
String (@NotNull StringBuilder builder, @NotNull ExpressionContext context, @NotNull GrExpression condition) { StringBuilder conditionBuilder = new StringBuilder(); final PsiType type = condition.getType(); final String varName = GenerationUtil.validateName("switchArg", condition, context); conditionBuilder.append("final "); TypeWriter.writeType(conditionBuilder, type, condition); conditionBuilder.append(' ').append(varName).append(" = "); condition.accept(new ExpressionGenerator(conditionBuilder, context)); conditionBuilder.append(";\n"); GenerationUtil.insertStatementFromContextBefore(builder, context); builder.append(conditionBuilder); return varName; }
generateConditionVar
31,735
void (@NotNull StringBuilder builder, @NotNull ExpressionContext context, @Nullable GrExpression condition, GrCaseSection @NotNull [] caseSections) { builder.append("switch ("); if (condition != null) { condition.accept(new ExpressionGenerator(builder, context)); } builder.append(") {\n"); final ExpressionContext innerContext = context.extend(); for (GrCaseSection section : caseSections) { generateCaseSection(builder, context, innerContext, section); } builder.append('}'); }
generateSwitch
31,736
void (@NotNull StringBuilder builder, @NotNull ExpressionContext context, @NotNull ExpressionContext innerContext, @NotNull GrCaseSection section) { writeLabel(builder, context, section); final GrStatement[] statements = section.getStatements(); CodeBlockGenerator generator = new CodeBlockGenerator(builder, innerContext); for (GrStatement statement : statements) { statement.accept(generator); builder.append("\n"); } }
generateCaseSection
31,737
void (@NotNull StringBuilder builder, @NotNull ExpressionContext context, @NotNull GrCaseSection section) { if (section.isDefault()) { builder.append("default"); } else { builder.append("case "); final GrExpression value = section.getExpressions()[0]; Object evaluated; try { evaluated = GroovyConstantExpressionEvaluator.evaluate(value); } catch (Throwable e) { evaluated = null; } if (evaluated != null) { builder.append(evaluated); } else if (value != null) { value.accept(new ExpressionGenerator(builder, context)); } } builder.append(":\n"); }
writeLabel
31,738
Result (GroovyPsiElement root, Result analyzedVars, ExpressionContext context) { LocalVarAnalyzer visitor = new LocalVarAnalyzer(); root.accept(visitor); Map<PsiVariable, String> varToName = analyzedVars == null ? new HashMap<>() : analyzedVars.varToName; Set<PsiVariable> toWrap = analyzedVars == null ? new HashSet<>() : analyzedVars.toWrap; Set<PsiVariable> toMakeFinal = analyzedVars == null ? new HashSet<>() : analyzedVars.toMakeFinal; for (PsiVariable v : visitor.touched) { if (visitor.rewritten.contains(v)) { toWrap.add(v); if (v instanceof PsiParameter) { varToName.put(v, GenerationUtil.suggestVarName(v.getType(), root, context)); } else { varToName.put(v, v.getName()); } } else { toMakeFinal.add(v); varToName.put(v, v.getName()); } } return analyzedVars == null ? new Result(toMakeFinal, toWrap, varToName) : analyzedVars; }
searchForVarsToWrap
31,739
Result () { return new Result(new HashSet<>(), new HashSet<>(), new HashMap<>()); }
initialResult
31,740
void (@NotNull GrClosableBlock closure) { grade++; super.visitClosure(closure); grade--; }
visitClosure
31,741
void (@NotNull GrTypeDefinition typeDefinition) { if (!(typeDefinition instanceof PsiAnonymousClass)) return; grade++; super.visitTypeDefinition(typeDefinition); grade--; }
visitTypeDefinition
31,742
void (@NotNull GrVariable variable) { super.visitVariable(variable); if (variable instanceof GrField) return; allVars.put(variable, grade); }
visitVariable
31,743
void (@NotNull GrReferenceExpression ref) { super.visitReferenceExpression(ref); PsiElement resolved = ref.resolve(); if (!allVars.containsKey(resolved)) { return; } GrVariable var = (GrVariable)resolved; if (PsiUtil.isAccessedForWriting(ref)) { rewritten.add(var); } if (allVars.getInt(var) < grade) { touched.add((PsiVariable)resolved); } }
visitReferenceExpression
31,744
StringBuilder () { return builder; }
getBuilder
31,745
ExpressionContext () { return context; }
getContext
31,746
void (GrMethod method) { final GrOpenBlock block = method.getBlock(); boolean shouldInsertReturnNull; myExitPoints.clear(); PsiType returnType = context.typeProvider.getReturnType(method); if (GroovyObjectTransformationSupport.isGroovyObjectSupportMethod(method)) { shouldInsertReturnNull = !(returnType instanceof PsiPrimitiveType); } else if (!method.isConstructor() && !PsiTypes.voidType().equals(returnType)) { myExitPoints.addAll(ControlFlowUtils.collectReturns(block)); shouldInsertReturnNull = block != null && !(returnType instanceof PsiPrimitiveType) && MissingReturnInspection.methodMissesSomeReturns(block, MissingReturnInspection.ReturnStatus.getReturnStatus( method)); } else { shouldInsertReturnNull = false; } generateCodeBlock(method.getParameters(), block, shouldInsertReturnNull); }
generateMethodBody
31,747
void (@NotNull GrMethod method) { LOG.error("don't invoke it!!!"); }
visitMethod
31,748
void (@NotNull GrOpenBlock block) { GrParameter[] parameters; if (block.getParent() instanceof GrMethod method) { parameters = method.getParameters(); } else { parameters = GrParameter.EMPTY_ARRAY; } generateCodeBlock(parameters, block, false); }
visitOpenBlock
31,749
void (GrParameter @NotNull [] parameters, @Nullable GrCodeBlock block, boolean shouldInsertReturnNull) { builder.append("{"); for (GrParameter parameter : parameters) { if (context.analyzedVars.toWrap(parameter)) { StringBuilder typeText = new StringBuilder().append(GroovyCommonClassNames.GROOVY_LANG_REFERENCE); GenerationUtil.writeTypeParameters(typeText, new PsiType[]{context.typeProvider.getParameterType(parameter)}, parameter, new GeneratorClassNameProvider()); builder.append("final ").append(typeText).append(' ').append(context.analyzedVars.toVarName(parameter)) .append(" = new ").append(typeText).append('(').append(parameter.getName()).append(");\n"); } } visitStatementOwner(block, shouldInsertReturnNull); builder.append("}\n"); }
generateCodeBlock
31,750
void (@Nullable GrStatementOwner owner, boolean shouldInsertReturnNull) { boolean hasLineFeed = false; for (PsiElement e = owner == null ? null : owner.getFirstChild(); e != null; e = e.getNextSibling()) { if (e instanceof GrStatement) { ((GrStatement)e).accept(this); hasLineFeed = false; } else if (TokenSets.COMMENT_SET.contains(e.getNode().getElementType())) { builder.append(e.getText()); } else if (org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.isLineFeed(e)) { hasLineFeed = true; if (IN_TEST) { builder.append(genSameLineFeed(e.getText())); } else { builder.append(e.getText()); } } } if (shouldInsertReturnNull) { if (!hasLineFeed) { builder.append('\n'); } builder.append("return null;\n"); } }
visitStatementOwner
31,751
String (String text) { final int count = StringUtil.countChars(text, '\n'); return StringUtil.repeatSymbol('\n', count); }
genSameLineFeed
31,752
void (@Nullable GrStatement statement, @NotNull StatementWriter writer) { GenerationUtil.writeStatement(builder, context, statement, writer); }
writeStatement
31,753
void (@NotNull GrExpression expression, @NotNull StringBuilder builder, @NotNull ExpressionContext context) { expression.accept(new ExpressionGenerator(builder, context)); }
writeExpression
31,754
void (@NotNull final GrConstructorInvocation invocation) { writeStatement(invocation, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { final GrReferenceExpression thisOrSuperKeyword = invocation.getInvokedExpression(); final GrArgumentList argumentList = invocation.getArgumentList(); final GroovyResolveResult resolveResult = invocation.advancedResolve(); if (thisOrSuperKeyword.getQualifier() == null) { builder.append(thisOrSuperKeyword.getReferenceName()); } else { writeExpression(thisOrSuperKeyword, builder, context); } new ArgumentListGenerator(builder, context).generate( GrClosureSignatureUtil.createSignature(resolveResult), argumentList.getExpressionArguments(), argumentList.getNamedArguments(), invocation.getClosureArguments(), invocation ); builder.append(';'); } }); }
visitConstructorInvocation
31,755
void (StringBuilder builder, ExpressionContext context) { final GrReferenceExpression thisOrSuperKeyword = invocation.getInvokedExpression(); final GrArgumentList argumentList = invocation.getArgumentList(); final GroovyResolveResult resolveResult = invocation.advancedResolve(); if (thisOrSuperKeyword.getQualifier() == null) { builder.append(thisOrSuperKeyword.getReferenceName()); } else { writeExpression(thisOrSuperKeyword, builder, context); } new ArgumentListGenerator(builder, context).generate( GrClosureSignatureUtil.createSignature(resolveResult), argumentList.getExpressionArguments(), argumentList.getNamedArguments(), invocation.getClosureArguments(), invocation ); builder.append(';'); }
writeStatement
31,756
void (@NotNull GrStatement statement) { LOG.error("all statements must be overloaded"); }
visitStatement
31,757
void (@NotNull GrFlowInterruptingStatement statement) { builder.append(statement.getStatementText()); final String name = statement.getLabelName(); if (name != null) { builder.append(' ').append(name); //todo check incorrect labels } builder.append(';'); }
visitFlowInterruptStatement
31,758
void (@NotNull final GrReturnStatement returnStatement) { final GrExpression returnValue = returnStatement.getReturnValue(); if (returnValue == null) { builder.append("return;\n"); return; } writeStatement(returnStatement, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { writeReturn(builder, context, returnValue); } }); }
visitReturnStatement
31,759
void (StringBuilder builder, ExpressionContext context) { writeReturn(builder, context, returnValue); }
writeStatement
31,760
void (@NotNull final GrAssertStatement assertStatement) { final GrExpression assertion = assertStatement.getAssertion(); final GrExpression message = assertStatement.getErrorMessage(); if (assertion != null) { writeStatement(assertStatement, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { builder.append("assert "); writeExpression(assertion, builder, context); if (message != null) { builder.append(" : "); writeExpression(message, builder, context); } builder.append(';'); } }); } else if (message != null) { writeStatement(assertStatement, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { builder.append("assert : "); writeExpression(message, builder, context); builder.append(';'); } }); } else { builder.append("assert;"); } }
visitAssertStatement
31,761
void (StringBuilder builder, ExpressionContext context) { builder.append("assert "); writeExpression(assertion, builder, context); if (message != null) { builder.append(" : "); writeExpression(message, builder, context); } builder.append(';'); }
writeStatement
31,762
void (StringBuilder builder, ExpressionContext context) { builder.append("assert : "); writeExpression(message, builder, context); builder.append(';'); }
writeStatement
31,763
void (@NotNull GrThrowStatement throwStatement) { final GrExpression exception = throwStatement.getException(); if (exception == null) { builder.append("throw ;"); return; } writeStatement(throwStatement, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { builder.append("throw "); writeExpression(exception, builder, context); //todo add exception to method 'throws' list builder.append(';'); } }); }
visitThrowStatement
31,764
void (StringBuilder builder, ExpressionContext context) { builder.append("throw "); writeExpression(exception, builder, context); //todo add exception to method 'throws' list builder.append(';'); }
writeStatement
31,765
void (@NotNull final GrLabeledStatement labeledStatement) { writeStatement(labeledStatement, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { final String label = labeledStatement.getName(); final GrStatement statement = labeledStatement.getStatement(); builder.append(label).append(": "); if (statement != null) { statement.accept(new CodeBlockGenerator(builder, context, myExitPoints)); } } }); }
visitLabeledStatement
31,766
void (StringBuilder builder, ExpressionContext context) { final String label = labeledStatement.getName(); final GrStatement statement = labeledStatement.getStatement(); builder.append(label).append(": "); if (statement != null) { statement.accept(new CodeBlockGenerator(builder, context, myExitPoints)); } }
writeStatement
31,767
void (@NotNull final GrExpression expression) { writeStatement(expression, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { if (myExitPoints.contains(expression) && isRealExpression(expression)) { writeReturn(builder, context, expression); } else { writeExpression(expression, builder, context); builder.append(';'); } } private static boolean isRealExpression(GrExpression expression) { final PsiType type = expression.getType(); if (PsiTypes.voidType().equals(type)) return false; //statement if (type == PsiTypes.nullType()) return !org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.isVoidMethodCall(expression); return true; } }); }
visitExpression
31,768
void (StringBuilder builder, ExpressionContext context) { if (myExitPoints.contains(expression) && isRealExpression(expression)) { writeReturn(builder, context, expression); } else { writeExpression(expression, builder, context); builder.append(';'); } }
writeStatement
31,769
boolean (GrExpression expression) { final PsiType type = expression.getType(); if (PsiTypes.voidType().equals(type)) return false; //statement if (type == PsiTypes.nullType()) return !org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.isVoidMethodCall(expression); return true; }
isRealExpression
31,770
void (StringBuilder builder, ExpressionContext context, final GrExpression expression) { builder.append("return "); final PsiType expectedReturnType = PsiImplUtil.inferReturnType(expression); final PsiType nnReturnType = expectedReturnType == null || PsiTypes.voidType().equals(expectedReturnType) ? TypesUtil.getJavaLangObject(expression) : expectedReturnType; GenerationUtil.wrapInCastIfNeeded(builder, nnReturnType, expression.getNominalType(), expression, context, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { writeExpression(expression, builder, context); } }); builder.append(';'); }
writeReturn
31,771
void (StringBuilder builder, ExpressionContext context) { writeExpression(expression, builder, context); }
writeStatement
31,772
void (@NotNull GrApplicationStatement applicationStatement) { visitExpression(applicationStatement); }
visitApplicationStatement
31,773
void (@NotNull GrTypeDefinition typeDefinition) { //todo ??????? }
visitTypeDefinition
31,774
void (@NotNull final GrIfStatement ifStatement) { writeStatement(ifStatement, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { final GrExpression condition = ifStatement.getCondition(); final GrStatement thenBranch = ifStatement.getThenBranch(); final GrStatement elseBranch = ifStatement.getElseBranch(); builder.append("if ("); if (condition != null) { final PsiType type = condition.getType(); if (PsiTypes.booleanType().equals(TypesUtil.unboxPrimitiveTypeWrapper(type))) { writeExpression(condition, builder, context); } else { GenerationUtil.invokeMethodByName( condition, "asBoolean", GrExpression.EMPTY_ARRAY, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, new ExpressionGenerator(builder, context), ifStatement); } } builder.append(')'); if (thenBranch != null) thenBranch.accept(new CodeBlockGenerator(builder, context.extend(), myExitPoints)); if (ifStatement.getElseKeyword() != null) builder.append(" else "); if (elseBranch != null) elseBranch.accept(new CodeBlockGenerator(builder, context.extend(), myExitPoints)); } }); }
visitIfStatement
31,775
void (StringBuilder builder, ExpressionContext context) { final GrExpression condition = ifStatement.getCondition(); final GrStatement thenBranch = ifStatement.getThenBranch(); final GrStatement elseBranch = ifStatement.getElseBranch(); builder.append("if ("); if (condition != null) { final PsiType type = condition.getType(); if (PsiTypes.booleanType().equals(TypesUtil.unboxPrimitiveTypeWrapper(type))) { writeExpression(condition, builder, context); } else { GenerationUtil.invokeMethodByName( condition, "asBoolean", GrExpression.EMPTY_ARRAY, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, new ExpressionGenerator(builder, context), ifStatement); } } builder.append(')'); if (thenBranch != null) thenBranch.accept(new CodeBlockGenerator(builder, context.extend(), myExitPoints)); if (ifStatement.getElseKeyword() != null) builder.append(" else "); if (elseBranch != null) elseBranch.accept(new CodeBlockGenerator(builder, context.extend(), myExitPoints)); }
writeStatement
31,776
void (@NotNull GrForStatement forStatement) { builder.append("for("); final GrForClause clause = forStatement.getClause(); ExpressionContext forContext = context.extend(); if (clause instanceof GrForInClause) { final GrExpression expression = ((GrForInClause)clause).getIteratedExpression(); final GrVariable declaredVariable = ((GrForInClause)clause).getDeclaredVariable(); LOG.assertTrue(declaredVariable != null); writeVariableWithoutSemicolonAndInitializer(builder, declaredVariable, context); builder.append(" : "); if (expression != null) { final ExpressionContext context = forContext.copy(); writeExpression(expression, builder, context); } } else if (clause instanceof GrTraditionalForClause cl) { final GrCondition initialization = cl.getInitialization(); final GrExpression condition = cl.getCondition(); final GrExpressionList update = cl.getUpdate(); if (initialization instanceof GrParameter) { StringBuilder partBuilder = new StringBuilder(); writeVariableWithoutSemicolonAndInitializer(partBuilder, (GrParameter)initialization, context); final GrExpression initializer = ((GrParameter)initialization).getInitializerGroovy(); if (initializer != null) { final ExpressionContext partContext = forContext.copy(); partBuilder.append(" = "); writeExpression(initializer, partBuilder, partContext); for (String statement : partContext.myStatements) { builder.append(statement).append(", "); } builder.append(partBuilder); } } else if (initialization != null) { genForPart(builder, initialization, new CodeBlockGenerator(new StringBuilder(), forContext.copy(), null)); } if (condition != null) { genForPart(builder, condition, new ExpressionGenerator(new StringBuilder(), forContext.copy())); } builder.append(';'); if (update != null) { genForPart(builder, update, new ExpressionGenerator(new StringBuilder(), forContext.copy())); } } builder.append(')'); final GrStatement body = forStatement.getBody(); if (body != null) { body.accept(new CodeBlockGenerator(builder, forContext, null)); } }
visitForStatement
31,777
void (StringBuilder builder, GroovyPsiElement part, final Generator visitor) { part.accept(visitor); for (String statement : visitor.getContext().myStatements) { builder.append(statement).append(", "); } builder.append(visitor.getBuilder()); }
genForPart
31,778
void (StringBuilder builder, GrVariable var, ExpressionContext context) { ModifierListGenerator.writeModifiers(builder, var.getModifierList()); TypeWriter.writeType(builder, context.typeProvider.getVarType(var), var); builder.append(' ').append(var.getName()); }
writeVariableWithoutSemicolonAndInitializer
31,779
void (@NotNull final GrWhileStatement whileStatement) { writeStatement(whileStatement, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { final GrExpression condition = whileStatement.getCondition(); final GrStatement body = whileStatement.getBody(); builder.append("while ("); if (condition != null) { writeExpression(condition, builder, context); } builder.append(" )"); if (body != null) { body.accept(new CodeBlockGenerator(builder, context.extend(), null)); } } }); }
visitWhileStatement
31,780
void (StringBuilder builder, ExpressionContext context) { final GrExpression condition = whileStatement.getCondition(); final GrStatement body = whileStatement.getBody(); builder.append("while ("); if (condition != null) { writeExpression(condition, builder, context); } builder.append(" )"); if (body != null) { body.accept(new CodeBlockGenerator(builder, context.extend(), null)); } }
writeStatement
31,781
void (@NotNull final GrSwitchStatement switchStatement) { writeStatement(switchStatement, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { SwitchStatementGenerator.generate(builder, context, switchStatement); } }); }
visitSwitchStatement
31,782
void (StringBuilder builder, ExpressionContext context) { SwitchStatementGenerator.generate(builder, context, switchStatement); }
writeStatement
31,783
void (@NotNull GrTryCatchStatement tryCatchStatement) { builder.append("try"); final GrOpenBlock tryBlock = tryCatchStatement.getTryBlock(); if (tryBlock == null) { builder.append("{}"); } else { tryBlock.accept(this); } final GrCatchClause[] catchClauses = tryCatchStatement.getCatchClauses(); final GrFinallyClause finallyClause = tryCatchStatement.getFinallyClause(); for (GrCatchClause catchClause : catchClauses) { catchClause.accept(this); } if (finallyClause != null) { finallyClause.accept(this); } }
visitTryStatement
31,784
void (@NotNull GrCatchClause catchClause) { final GrParameter parameter = catchClause.getParameter(); builder.append("catch ("); writeVariableWithoutSemicolonAndInitializer(builder, parameter, context); builder.append(") "); final GrOpenBlock body = catchClause.getBody(); if (body != null) { body.accept(this); } }
visitCatchClause
31,785
void (@NotNull GrFinallyClause finallyClause) { builder.append("finally "); final GrOpenBlock body = finallyClause.getBody(); if (body != null) { body.accept(this); } }
visitFinallyClause
31,786
void (@NotNull GrBlockStatement blockStatement) { blockStatement.getBlock().accept(this); }
visitBlockStatement
31,787
void (@NotNull final GrSynchronizedStatement statement) { writeStatement(statement, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { final GrExpression monitor = statement.getMonitor(); final GrOpenBlock body = statement.getBody(); builder.append("synchronized("); if (monitor != null ) { writeExpression(monitor, builder, context); } builder.append(')'); if (body != null) { body.accept(new CodeBlockGenerator(builder, context.extend(), myExitPoints)); } } }); }
visitSynchronizedStatement
31,788
void (StringBuilder builder, ExpressionContext context) { final GrExpression monitor = statement.getMonitor(); final GrOpenBlock body = statement.getBody(); builder.append("synchronized("); if (monitor != null ) { writeExpression(monitor, builder, context); } builder.append(')'); if (body != null) { body.accept(new CodeBlockGenerator(builder, context.extend(), myExitPoints)); } }
writeStatement
31,789
void (@NotNull final GrVariableDeclaration variableDeclaration) { writeStatement(variableDeclaration, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { if (variableDeclaration.isTuple()) { writeTupleDeclaration(variableDeclaration, builder, context); } else { GenerationUtil.writeSimpleVarDeclaration(variableDeclaration, builder, context); } } }); }
visitVariableDeclaration
31,790
void (StringBuilder builder, ExpressionContext context) { if (variableDeclaration.isTuple()) { writeTupleDeclaration(variableDeclaration, builder, context); } else { GenerationUtil.writeSimpleVarDeclaration(variableDeclaration, builder, context); } }
writeStatement
31,791
void (GrVariableDeclaration variableDeclaration, StringBuilder builder, ExpressionContext expressionContext) { GrVariable[] variables = variableDeclaration.getVariables(); final GrExpression tupleInitializer = variableDeclaration.getTupleInitializer(); if (tupleInitializer instanceof GrListOrMap) { for (GrVariable variable : variables) { GenerationUtil.writeVariableSeparately(variable, builder, expressionContext); builder.append(";\n"); } } else if (tupleInitializer != null) { GroovyResolveResult iteratorMethodResult = GenerationUtil .resolveMethod(tupleInitializer, "iterator", GrExpression.EMPTY_ARRAY, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, variableDeclaration); final PsiType iteratorType = inferIteratorType(iteratorMethodResult, tupleInitializer); final String iteratorName = genIteratorVar(variableDeclaration, builder, expressionContext, tupleInitializer, iteratorType, iteratorMethodResult); final GrModifierList modifierList = variableDeclaration.getModifierList(); PsiType iterableTypeParameter = PsiUtil.extractIterableTypeParameter(iteratorType, false); for (final GrVariable v : variables) { ModifierListGenerator.writeModifiers(builder, modifierList); final PsiType type = context.typeProvider.getVarType(v); TypeWriter.writeType(builder, type, variableDeclaration); builder.append(' ').append(v.getName()); builder.append(" = "); GenerationUtil.wrapInCastIfNeeded(builder, type, iterableTypeParameter, tupleInitializer, expressionContext, new StatementWriter() { @Override public void writeStatement(StringBuilder builder, ExpressionContext context) { builder.append(iteratorName).append(".hasNext() ? ").append(iteratorName).append(".next() : null"); } }); builder.append(";\n"); } } else { GenerationUtil.writeSimpleVarDeclaration(variableDeclaration, builder, expressionContext); } }
writeTupleDeclaration
31,792
void (StringBuilder builder, ExpressionContext context) { builder.append(iteratorName).append(".hasNext() ? ").append(iteratorName).append(".next() : null"); }
writeStatement
31,793
String (GrVariableDeclaration variableDeclaration, StringBuilder builder, ExpressionContext expressionContext, @NotNull GrExpression tupleInitializer, PsiType iteratorType, GroovyResolveResult iteratorMethodResult) { final String iteratorName = GenerationUtil.suggestVarName(iteratorType, variableDeclaration, expressionContext); builder.append("final "); TypeWriter.writeType(builder, iteratorType, variableDeclaration); builder.append(' ').append(iteratorName).append(" = "); GenerationUtil .invokeMethodByResolveResult(tupleInitializer, iteratorMethodResult, "iterator", GrExpression.EMPTY_ARRAY, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, new ExpressionGenerator(builder, expressionContext), variableDeclaration); builder.append(";\n"); return iteratorName; }
genIteratorVar
31,794
PsiType (GroovyResolveResult iteratorMethodResult, GrExpression tupleInitializer) { PsiElement method = iteratorMethodResult.getElement(); if (method instanceof PsiMethod) { return iteratorMethodResult.getSubstitutor().substitute(((PsiMethod)method).getReturnType()); } else { PsiType initializerType = tupleInitializer.getType(); PsiType iterableParam = PsiUtil.extractIterableTypeParameter(initializerType, false); JavaPsiFacade facade = JavaPsiFacade.getInstance(context.project); PsiClass iterableClass = facade.findClass(CommonClassNames.JAVA_UTIL_ITERATOR, tupleInitializer.getResolveScope()); if (iterableClass != null && iterableParam != null) { return facade.getElementFactory().createType(iterableClass, iterableParam); } else { return facade.getElementFactory().createTypeFromText(CommonClassNames.JAVA_UTIL_ITERATOR, tupleInitializer); } } }
inferIteratorType
31,795
PsiType (@NotNull PsiMethod method) { if (method instanceof GrMethod) { GrTypeElement typeElement = ((GrMethod)method).getReturnTypeElementGroovy(); if (typeElement != null) return typeElement.getType(); } final PsiType smartReturnType = PsiUtil.getSmartReturnType(method); if (smartReturnType != null && !PsiTypes.nullType().equals(smartReturnType)) return smartReturnType; if (PsiTypes.nullType().equals(smartReturnType) && PsiUtil.isVoidMethod(method)) return PsiTypes.voidType(); //todo make smarter. search for usages and infer type from them return TypesUtil.getJavaLangObject(method); }
getReturnType
31,796
PsiType (@NotNull PsiVariable variable) { if (variable instanceof PsiParameter) return getParameterType((PsiParameter)variable); return getVariableTypeInner(variable); }
getVarType
31,797
PsiType (@NotNull PsiVariable variable) { PsiType type = null; if (variable instanceof GrVariable) { type = ((GrVariable)variable).getDeclaredType(); if (type == null) { type = ((GrVariable)variable).getTypeGroovy(); } } if (type == null) { type = variable.getType(); } return type; }
getVariableTypeInner
31,798
PsiType (@NotNull PsiParameter parameter) { if (!(parameter instanceof GrParameter)) { PsiElement scope = parameter.getDeclarationScope(); if (scope instanceof GrAccessorMethod) { return getVarType(((GrAccessorMethod)scope).getProperty()); } return parameter.getType(); } PsiElement parent = parameter.getParent(); if (!(parent instanceof GrParameterList)) { return getVariableTypeInner(parameter); } PsiElement pparent = parent.getParent(); if (!(pparent instanceof GrMethod)) return parameter.getType(); PsiType[] types = inferMethodParameters((GrMethod)pparent); return types[((GrParameterList)parent).getParameterNumber((GrParameter)parameter)]; }
getParameterType
31,799
PsiType (GrClosableBlock closure) { final PsiType returnType = closure.getReturnType(); if (PsiTypes.nullType().equals(returnType) && PsiUtil.isBlockReturnVoid(closure)) { return PsiTypes.voidType(); } if (returnType == null) { return TypesUtil.getJavaLangObject(closure); } return TypesUtil.boxPrimitiveType(returnType, closure.getManager(), closure.getResolveScope()); }
getReturnType