private void replaceIteratorNext( PsiElement element, String contentVariableName, String iteratorName, PsiElement childToSkip, StringBuilder out, PsiType contentType) { if (isIteratorNext(element, iteratorName, contentType)) { out.append(contentVariableName); } else { final PsiElement[] children = element.getChildren(); if (children.length == 0) { final String text = element.getText(); if (PsiKeyword.INSTANCEOF.equals(text) && out.charAt(out.length() - 1) != ' ') { out.append(' '); } out.append(text); } else { boolean skippingWhiteSpace = false; for (final PsiElement child : children) { if (child.equals(childToSkip)) { skippingWhiteSpace = true; } else if (child instanceof PsiWhiteSpace && skippingWhiteSpace) { // don't do anything } else { skippingWhiteSpace = false; replaceIteratorNext( child, contentVariableName, iteratorName, childToSkip, out, contentType); } } } } }
private void replaceCollectionGetAccess( PsiElement element, String contentVariableName, PsiVariable listVariable, String indexName, PsiElement childToSkip, StringBuilder out) { if (isListGetLookup(element, indexName, listVariable)) { out.append(contentVariableName); } else { final PsiElement[] children = element.getChildren(); if (children.length == 0) { final String text = element.getText(); if (PsiKeyword.INSTANCEOF.equals(text) && out.charAt(out.length() - 1) != ' ') { out.append(' '); } out.append(text); } else { boolean skippingWhiteSpace = false; for (final PsiElement child : children) { if (child.equals(childToSkip)) { skippingWhiteSpace = true; } else if (child instanceof PsiWhiteSpace && skippingWhiteSpace) { // don't do anything } else { skippingWhiteSpace = false; replaceCollectionGetAccess( child, contentVariableName, listVariable, indexName, childToSkip, out); } } } } }
private static void generateNameByString( Set<String> possibleNames, String value, NameValidator validator, boolean forStaticVariable, Project project) { if (!JavaPsiFacade.getInstance(project).getNameHelper().isIdentifier(value)) return; if (forStaticVariable) { StringBuilder buffer = new StringBuilder(value.length() + 10); char[] chars = new char[value.length()]; value.getChars(0, value.length(), chars, 0); boolean wasLow = Character.isLowerCase(chars[0]); buffer.append(Character.toUpperCase(chars[0])); for (int i = 1; i < chars.length; i++) { if (Character.isUpperCase(chars[i])) { if (wasLow) { buffer.append('_'); wasLow = false; } } else { wasLow = true; } buffer.append(Character.toUpperCase(chars[i])); } possibleNames.add(validator.validateName(buffer.toString(), true)); } else { possibleNames.add(validator.validateName(value, true)); } }
@Override protected void updateTitle(@Nullable final PsiVariable variable, final String value) { final PsiElement declarationScope = variable != null ? ((PsiParameter) variable).getDeclarationScope() : null; if (declarationScope instanceof PsiMethod) { final PsiMethod psiMethod = (PsiMethod) declarationScope; final StringBuilder buf = new StringBuilder(); buf.append(psiMethod.getName()).append(" ("); boolean frst = true; final List<TextRange> ranges2Remove = new ArrayList<>(); TextRange addedRange = null; for (PsiParameter parameter : psiMethod.getParameterList().getParameters()) { if (frst) { frst = false; } else { buf.append(", "); } int startOffset = buf.length(); if (myMustBeFinal || myPanel.isGenerateFinal()) { buf.append("final "); } buf.append(parameter.getType().getPresentableText()) .append(" ") .append(variable == parameter ? value : parameter.getName()); int endOffset = buf.length(); if (variable == parameter) { addedRange = new TextRange(startOffset, endOffset); } else if (myPanel.isParamToRemove(parameter)) { ranges2Remove.add(new TextRange(startOffset, endOffset)); } } buf.append(")"); setPreviewText(buf.toString()); final MarkupModel markupModel = DocumentMarkupModel.forDocument(getPreviewEditor().getDocument(), myProject, true); markupModel.removeAllHighlighters(); for (TextRange textRange : ranges2Remove) { markupModel.addRangeHighlighter( textRange.getStartOffset(), textRange.getEndOffset(), 0, getTestAttributesForRemoval(), HighlighterTargetArea.EXACT_RANGE); } markupModel.addRangeHighlighter( addedRange.getStartOffset(), addedRange.getEndOffset(), 0, getTextAttributesForAdd(), HighlighterTargetArea.EXACT_RANGE); revalidate(); } }
private static void appendInferredType( PsiElement originalElement, GrVariable variable, StringBuilder buffer) { PsiType inferredType = null; if (PsiImplUtil.isWhiteSpaceOrNls(originalElement)) { originalElement = PsiTreeUtil.prevLeaf(originalElement); } if (originalElement != null && originalElement.getNode().getElementType() == GroovyTokenTypes.mIDENT) { originalElement = originalElement.getParent(); } if (originalElement instanceof GrReferenceExpression) { inferredType = ((GrReferenceExpression) originalElement).getType(); } else if (originalElement instanceof GrVariableDeclaration) { inferredType = variable.getTypeGroovy(); } else if (originalElement instanceof GrVariable) { inferredType = ((GrVariable) originalElement).getTypeGroovy(); } if (inferredType != null) { buffer.append("[inferred type] "); appendTypeString(buffer, inferredType, originalElement); } else { buffer.append("[cannot infer type]"); } }
private static void generateVariableInfo( PsiElement originalElement, StringBuilder buffer, PsiVariable variable) { if (variable instanceof PsiField) { final PsiClass parentClass = ((PsiField) variable).getContainingClass(); if (parentClass != null) { buffer.append(JavaDocUtil.getShortestClassName(parentClass, variable)); newLine(buffer); } generateModifiers(buffer, variable); } final PsiType type = variable instanceof GrVariable ? ((GrVariable) variable).getDeclaredType() : variable.getType(); PsiImplUtil.appendTypeString( buffer, calcSubstitutor(originalElement).substitute(type), originalElement); buffer.append(" "); buffer.append(variable.getName()); if (variable instanceof GrVariable) { newLine(buffer); while (originalElement != null) { PsiReference ref = originalElement.getReference(); if (ref != null && ref.resolve() != null) break; originalElement = originalElement.getParent(); } if (originalElement != null) { appendInferredType(originalElement, (GrVariable) variable, buffer); } } }
public void emit(Emitter emitter) { StringBuilder sb = emitter.getTextBuffer(); if (getCustomizedPrecedingComment().length() > 0) { sb.append("\n"); sb.append(getCustomizedPrecedingComment()); } emitAllElements(sb, emitter.getDocument()); if (getCustomizedTrailingComment().length() > 0) { sb.append("\n"); sb.append(getCustomizedTrailingComment()); } /** emit corresponding setter, overloaded methods, and related methods, if any. */ ListIterator li; if (isGetter()) { for (MethodEntry entry : myCorrespondingGetterSetters) { entry.emit(emitter); } } for (MethodEntry me : myOverloadedMethods) { me.emit(emitter); } for (MethodEntry me : sortedMethods) { me.emit(emitter); } }
public String calcGenerics(@NotNull PsiElement context, InsertionContext insertionContext) { if (insertionContext.getCompletionChar() == '<') { return ""; } assert context.isValid(); if (myDiamond) { return "<>"; } if (getObject() instanceof PsiClass) { PsiClass psiClass = (PsiClass) getObject(); PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(psiClass.getProject()).getResolveHelper(); PsiSubstitutor substitutor = getSubstitutor(); StringBuilder builder = new StringBuilder(); for (PsiTypeParameter parameter : psiClass.getTypeParameters()) { PsiType substitute = substitutor.substitute(parameter); if (substitute == null || (PsiUtil.resolveClassInType(substitute) == parameter && resolveHelper.resolveReferencedClass(parameter.getName(), context) != CompletionUtil.getOriginalOrSelf(parameter))) { return ""; } if (builder.length() > 0) { builder.append(", "); } builder.append(substitute.getCanonicalText()); } if (builder.length() > 0) { return "<" + builder + ">"; } } return ""; }
public static @Nullable PsiType resolveMethod( Project proj, PsiElement context, String clas, String methodName, @NotNull PsiExpression... args) { StringBuilder sb = new StringBuilder(); sb.append(clas).append(".").append(methodName).append("("); boolean comma = false; for (PsiExpression arg : args) { if (comma) sb.append(","); sb.append(arg.getText()); comma = true; } sb.append(")"); PsiExpression exp = JavaPsiFacade.getElementFactory(proj).createExpressionFromText(sb.toString(), context); return exp.getType(); /*if (clas == null || methodName == null) return null; PsiType[] argTypes = new PsiType[args.length]; for (int i = 0; i < args.length; i++) { if (args[i] == null) return null; argTypes[i] = args[i].getType(); } return resolveMethod(clas.getType(), methodName, argTypes);*/ }
@Override public String getEventMessage(LocatableEvent event) { final Location location = event.location(); String sourceName; try { sourceName = location.sourceName(); } catch (AbsentInformationException e) { sourceName = getFileName(); } final boolean printFullTrace = Registry.is("debugger.breakpoint.message.full.trace"); StringBuilder builder = new StringBuilder(); if (printFullTrace) { builder.append( DebuggerBundle.message( "status.line.breakpoint.reached.full.trace", DebuggerUtilsEx.getLocationMethodQName(location))); try { final List<StackFrame> frames = event.thread().frames(); renderTrace(frames, builder); } catch (IncompatibleThreadStateException e) { builder.append("Stacktrace not available: ").append(e.getMessage()); } } else { builder.append( DebuggerBundle.message( "status.line.breakpoint.reached", DebuggerUtilsEx.getLocationMethodQName(location), sourceName, getLineIndex() + 1)); } return builder.toString(); }
/** * Returns the original comment info of the specified element or null * * @param element the specified element * @return text chunk */ @Nullable private static String getOrigCommentInfo(PsiDocCommentOwner element) { StringBuilder sb = new StringBuilder(); PsiElement e = element.getFirstChild(); if (!(e instanceof PsiComment)) { // no comments for this element return null; } else { boolean first = true; while (true) { if (e instanceof PsiDocComment) { PsiComment cm = (PsiComment) e; String text = cm.getText(); if (text.startsWith("//")) { if (!first) sb.append('\n'); sb.append(text.substring(2).trim()); } else if (text.startsWith("/*")) { if (text.charAt(2) == '*') { text = text.substring(3, Math.max(3, text.length() - 2)); } else { text = text.substring(2, Math.max(2, text.length() - 2)); } sb.append(text); } } else if (!(e instanceof PsiWhiteSpace) && !(e instanceof PsiComment)) { break; } first = false; e = e.getNextSibling(); } return sb.toString(); } }
private static boolean generateDelegate(GrChangeInfoImpl grInfo) { final GrMethod method = grInfo.getMethod(); final PsiClass psiClass = method.getContainingClass(); GrMethod newMethod = (GrMethod) method.copy(); newMethod = (GrMethod) psiClass.addAfter(newMethod, method); StringBuilder buffer = new StringBuilder(); buffer.append("\n"); if (method.isConstructor()) { buffer.append("this"); } else { if (!PsiType.VOID.equals(method.getReturnType())) { buffer.append("return "); } buffer.append( GrChangeSignatureUtil.getNameWithQuotesIfNeeded( grInfo.getNewName(), method.getProject())); } generateParametersForDelegateCall(grInfo, method, buffer); final GrCodeBlock codeBlock = GroovyPsiElementFactory.getInstance(method.getProject()) .createMethodBodyFromText(buffer.toString()); newMethod.setBlock(codeBlock); newMethod.getModifierList().setModifierProperty(PsiModifier.ABSTRACT, false); CodeStyleManager.getInstance(method.getProject()).reformat(newMethod); return processPrimaryMethodInner(grInfo, method, null); }
private void suggestNamesFromGenericParameters( final PsiType type, final VariableKind variableKind, final Collection<String> suggestions, boolean correctKeywords) { if (!(type instanceof PsiClassType)) { return; } StringBuilder fullNameBuilder = new StringBuilder(); final PsiType[] parameters = ((PsiClassType) type).getParameters(); for (PsiType parameter : parameters) { if (parameter instanceof PsiClassType) { final String typeName = normalizeTypeName(getTypeName(parameter)); if (typeName != null) { fullNameBuilder.append(typeName); } } } String baseName = normalizeTypeName(getTypeName(type)); if (baseName != null) { fullNameBuilder.append(baseName); ContainerUtil.addAll( suggestions, getSuggestionsByName(fullNameBuilder.toString(), variableKind, false, correctKeywords)); } }
private static String genIteratorVar( GrVariableDeclaration variableDeclaration, StringBuilder builder, ExpressionContext expressionContext, @NotNull GrExpression tupleInitializer, PsiType iteratorType, GroovyResolveResult iteratorMethodResult) { final String iteratorName = suggestVarName(iteratorType, variableDeclaration, expressionContext); builder.append("final "); writeType(builder, iteratorType, variableDeclaration); builder.append(' ').append(iteratorName).append(" = "); invokeMethodByResolveResult( tupleInitializer, iteratorMethodResult, "iterator", GrExpression.EMPTY_ARRAY, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, new ExpressionGenerator(builder, expressionContext), variableDeclaration); builder.append(";\n"); return iteratorName; }
@Override public String getSignature(@NotNull final PsiElement element) { StringBuilder buffer = null; for (PsiElement current = element; current != null && !(current instanceof PsiFile); current = current.getParent()) { int length = buffer == null ? 0 : buffer.length(); StringBuilder b = getSignature(current, buffer); if (b == null && buffer != null && current.getParent() instanceof PsiFile && canResolveTopLevelChild(current)) { buffer .append(TYPE_MARKER) .append(ELEMENT_TOKENS_SEPARATOR) .append(TOP_LEVEL_CHILD_MARKER) .append(ELEMENTS_SEPARATOR); break; } buffer = b; if (buffer == null || length >= buffer.length()) { return null; } buffer.append(ELEMENTS_SEPARATOR); } if (buffer == null) { return null; } buffer.setLength(buffer.length() - 1); return buffer.toString(); }
@Override public String variableNameToPropertyName(String name, VariableKind variableKind) { if (variableKind == VariableKind.STATIC_FINAL_FIELD || variableKind == VariableKind.STATIC_FIELD && name.contains("_")) { StringBuilder buffer = new StringBuilder(); for (int i = 0; i < name.length(); i++) { char c = name.charAt(i); if (c != '_') { if (Character.isLowerCase(c)) { return variableNameToPropertyNameInner(name, variableKind); } buffer.append(Character.toLowerCase(c)); continue; } //noinspection AssignmentToForLoopParameter i++; if (i < name.length()) { c = name.charAt(i); buffer.append(c); } } return buffer.toString(); } return variableNameToPropertyNameInner(name, variableKind); }
private static void appendElementText( @NotNull PsiElement element, @NotNull PsiElement elementToReplace, @Nullable PsiExpression replacementExpression, @NotNull StringBuilder out) { if (element.equals(elementToReplace)) { final String replacementText = (replacementExpression == null) ? "" : replacementExpression.getText(); out.append(replacementText); return; } final PsiElement[] children = element.getChildren(); if (children.length == 0) { out.append(element.getText()); if (element instanceof PsiComment) { final PsiComment comment = (PsiComment) element; final IElementType tokenType = comment.getTokenType(); if (tokenType == JavaTokenType.END_OF_LINE_COMMENT) { out.append('\n'); } } return; } for (PsiElement child : children) { appendElementText(child, elementToReplace, replacementExpression, out); } }
private static PsiField createField( PsiLocalVariable local, PsiType forcedType, String fieldName, boolean includeInitializer) { @NonNls StringBuilder pattern = new StringBuilder(); pattern.append("private int "); pattern.append(fieldName); if (local.getInitializer() == null) { includeInitializer = false; } if (includeInitializer) { pattern.append("=0"); } pattern.append(";"); final Project project = local.getProject(); PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); try { PsiField field = factory.createFieldFromText(pattern.toString(), null); field.getTypeElement().replace(factory.createTypeElement(forcedType)); if (includeInitializer) { PsiExpression initializer = RefactoringUtil.convertInitializerToNormalExpression( local.getInitializer(), forcedType); field.getInitializer().replace(initializer); } for (PsiAnnotation annotation : local.getModifierList().getAnnotations()) { field.getModifierList().add(annotation.copy()); } return field; } catch (IncorrectOperationException e) { LOG.error(e); return null; } }
private static void genForPart( StringBuilder builder, GroovyPsiElement part, final Generator visitor) { part.accept(visitor); for (String statement : visitor.getContext().myStatements) { builder.append(statement).append(", "); } builder.append(visitor.getBuilder()); }
private static String constantValueToConstantName(final String[] names) { final StringBuilder result = new StringBuilder(); for (int i = 0; i < names.length; i++) { if (i > 0) result.append("_"); result.append(names[i]); } return result.toString(); }
public void commentRange( int startOffset, int endOffset, String commentPrefix, String commentSuffix, Commenter commenter) { final CharSequence chars = myDocument.getCharsSequence(); LogicalPosition caretPosition = myCaret.getLogicalPosition(); if (startOffset == 0 || chars.charAt(startOffset - 1) == '\n') { if (endOffset == myDocument.getTextLength() || endOffset > 0 && chars.charAt(endOffset - 1) == '\n') { CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(myProject); CommonCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(myProject).getCommonSettings(myFile.getLanguage()); String space; if (!settings.BLOCK_COMMENT_AT_FIRST_COLUMN) { final FileType fileType = myFile.getFileType(); int line1 = myEditor.offsetToLogicalPosition(startOffset).line; int line2 = myEditor.offsetToLogicalPosition(endOffset - 1).line; Indent minIndent = CommentUtil.getMinLineIndent(myProject, myDocument, line1, line2, fileType); if (minIndent == null) { minIndent = codeStyleManager.zeroIndent(); } space = codeStyleManager.fillIndent(minIndent, fileType); } else { space = ""; } final StringBuilder nestingPrefix = new StringBuilder(space).append(commentPrefix); if (!commentPrefix.endsWith("\n")) { nestingPrefix.append("\n"); } final StringBuilder nestingSuffix = new StringBuilder(space); nestingSuffix.append( commentSuffix.startsWith("\n") ? commentSuffix.substring(1) : commentSuffix); nestingSuffix.append("\n"); TextRange range = insertNestedComments( startOffset, endOffset, nestingPrefix.toString(), nestingSuffix.toString(), commenter); myCaret.setSelection(range.getStartOffset(), range.getEndOffset()); LogicalPosition pos = new LogicalPosition(caretPosition.line + 1, caretPosition.column); myCaret.moveToLogicalPosition(pos); return; } } TextRange range = insertNestedComments(startOffset, endOffset, commentPrefix, commentSuffix, commenter); myCaret.setSelection(range.getStartOffset(), range.getEndOffset()); LogicalPosition pos = new LogicalPosition(caretPosition.line, caretPosition.column + commentPrefix.length()); myCaret.moveToLogicalPosition(pos); }
private static String stripSpaces(String text) { String[] lines = LineTokenizer.tokenize(text.toCharArray(), false); StringBuilder buf = new StringBuilder(text.length()); for (int i = 0; i < lines.length; i++) { if (i > 0) buf.append('\n'); buf.append(rTrim(lines[i])); } return buf.toString(); }
private static void generateModifiers(StringBuilder buffer, PsiElement element) { String modifiers = PsiFormatUtil.formatModifiers(element, PsiFormatUtilBase.JAVADOC_MODIFIERS_ONLY); if (!modifiers.isEmpty()) { buffer.append(modifiers); buffer.append(" "); } }
private static void createElementLink( @NonNls final StringBuilder sb, final PsiElement element, final String str) { sb.append(" <a href=\"psi_element://"); sb.append(JavaDocUtil.getReferenceText(element.getProject(), element)); sb.append("\">"); sb.append(str); sb.append("</a>"); sb.append("<br>"); }
@Override public void visitFlowInterruptStatement(GrFlowInterruptingStatement statement) { builder.append(statement.getStatementText()); final String name = statement.getLabelName(); if (name != null) { builder.append(' ').append(name); // todo check incorrect labels } builder.append(';'); }
public static String getLocationMethodQName(@NotNull Location location) { StringBuilder res = new StringBuilder(); ReferenceType type = location.declaringType(); if (type != null) { res.append(type.name()).append('.'); } res.append(location.method().name()); return res.toString(); }
private static void generateTraitType( @NotNull StringBuilder buffer, @NotNull GrTraitType type, PsiElement context) { appendTypeString(buffer, type.getExprType(), context); buffer.append(" as "); for (PsiType traitType : type.getTraitTypes()) { appendTypeString(buffer, traitType, context); buffer.append(", "); } buffer.delete(buffer.length() - 2, buffer.length()); }
@Override public void visitCatchClause(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); } }
private void commitToOriginalInner() { final String text = myNewDocument.getText(); final Map< PsiLanguageInjectionHost, Set<Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer>>> map = ContainerUtil.classify( myMarkers.iterator(), new Convertor< Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer>, PsiLanguageInjectionHost>() { @Override public PsiLanguageInjectionHost convert( final Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer> o) { final PsiElement element = o.third.getElement(); return (PsiLanguageInjectionHost) element; } }); PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject); documentManager.commitDocument(myOrigDocument); // commit here and after each manipulator update int localInsideFileCursor = 0; for (PsiLanguageInjectionHost host : map.keySet()) { if (host == null) continue; String hostText = host.getText(); ProperTextRange insideHost = null; StringBuilder sb = new StringBuilder(); for (Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer> entry : map.get(host)) { RangeMarker origMarker = entry.first; // check for validity? int hostOffset = host.getTextRange().getStartOffset(); ProperTextRange localInsideHost = new ProperTextRange( origMarker.getStartOffset() - hostOffset, origMarker.getEndOffset() - hostOffset); RangeMarker rangeMarker = entry.second; ProperTextRange localInsideFile = new ProperTextRange( Math.max(localInsideFileCursor, rangeMarker.getStartOffset()), rangeMarker.getEndOffset()); if (insideHost != null) { // append unchanged inter-markers fragment sb.append( hostText.substring(insideHost.getEndOffset(), localInsideHost.getStartOffset())); } sb.append( localInsideFile.getEndOffset() <= text.length() && !localInsideFile.isEmpty() ? localInsideFile.substring(text) : ""); localInsideFileCursor = localInsideFile.getEndOffset(); insideHost = insideHost == null ? localInsideHost : insideHost.union(localInsideHost); } assert insideHost != null; ElementManipulators.getManipulator(host).handleContentChange(host, insideHost, sb.toString()); documentManager.commitDocument(myOrigDocument); } }
public String getFlagsString() { final StringBuilder result = new StringBuilder(); result.append(returnFlag).append(':'); boolean first = true; for (boolean b : paramFlags) { if (first) first = false; else result.append(','); result.append(b); } return result.toString(); }