protected void addKeywords(
final Set<LookupElement> set,
final PsiElement position,
final PrefixMatcher matcher,
final PsiFile file,
final CompletionVariant variant,
final Object comp,
final TailType tailType) {
if (comp instanceof String) {
addKeyword(set, tailType, comp, matcher, file, variant);
} else {
final CompletionContext context =
position.getUserData(CompletionContext.COMPLETION_CONTEXT_KEY);
if (comp instanceof ContextGetter) {
final Object[] elements = ((ContextGetter) comp).get(position, context);
for (Object element : elements) {
addLookupItem(set, tailType, element, file, variant);
}
}
// TODO: KeywordChooser -> ContextGetter
else if (comp instanceof KeywordChooser) {
final String[] keywords = ((KeywordChooser) comp).getKeywords(context, position);
for (String keyword : keywords) {
addKeyword(set, tailType, keyword, matcher, file, variant);
}
}
}
}
@Override
public boolean hasDocumentationFor(PsiElement element, PsiElement originalElement) {
PsiElement docElement = getDocumentationElement(element, originalElement);
if (docElement != null
&& docElement.getUserData(NonCodeMembersHolder.DOCUMENTATION_URL) != null) return true;
return JavaDocumentationProvider.hasUrlFor(element);
}
public static void highlightOriginalElement(
@NotNull PsiElement element,
@NotNull AnnotationHolder holder,
@NotNull TextAttributesKey key) {
PsiElement originalElement = element.getUserData(CMainPsiBuilder.ORIGINAL_SINGLE_ELEMENT);
if (originalElement != null)
holder.createInfoAnnotation(originalElement, null).setTextAttributes(key);
else throw new UnsupportedOperationException("Unknown how highlight element : " + element);
}
@Nullable
public PsiElement addDeclaration(IntroduceOperation operation, PsiElement declaration) {
final PsiElement expression = operation.getInitializer();
final Pair<PsiElement, TextRange> data =
expression.getUserData(PyReplaceExpressionUtil.SELECTION_BREAKS_AST_NODE);
if (data == null) {
return addDeclaration(expression, declaration, operation);
} else {
return addDeclaration(data.first, declaration, operation);
}
}
@Nullable
protected PsiElement replaceExpression(
PsiElement expression, PyExpression newExpression, IntroduceOperation operation) {
PyExpressionStatement statement =
PsiTreeUtil.getParentOfType(expression, PyExpressionStatement.class);
if (statement != null) {
if (statement.getExpression() == expression
&& expression.getUserData(PyReplaceExpressionUtil.SELECTION_BREAKS_AST_NODE) == null) {
statement.delete();
return null;
}
}
return PyReplaceExpressionUtil.replaceExpression(expression, newExpression);
}
@Nullable
public List<String> getUrlFor(PsiElement element, PsiElement originalElement) {
List<String> result = new ArrayList<String>();
PsiElement docElement = getDocumentationElement(element, originalElement);
if (docElement != null) {
ContainerUtil.addIfNotNull(
result, docElement.getUserData(NonCodeMembersHolder.DOCUMENTATION_URL));
}
List<String> list = JavaDocumentationProvider.getExternalJavaDocUrl(element);
if (list != null) {
result.addAll(list);
}
return result.isEmpty() ? null : result;
}
private static PsiElement getDocumentationElement(
PsiElement element, PsiElement originalElement) {
if (element instanceof GrGdkMethod) {
element = ((GrGdkMethod) element).getStaticMethod();
}
final GrDocComment doc = PsiTreeUtil.getParentOfType(originalElement, GrDocComment.class);
if (doc != null) {
element = GrDocCommentUtil.findDocOwner(doc);
}
if (element instanceof GrLightVariable) {
PsiElement navigationElement = element.getNavigationElement();
if (navigationElement != null) {
element = navigationElement;
if (element.getContainingFile() instanceof PsiCompiledFile) {
navigationElement = element.getNavigationElement();
if (navigationElement != null) {
element = navigationElement;
}
}
if (element instanceof GrAccessorMethod) {
element = ((GrAccessorMethod) element).getProperty();
}
}
}
if (element instanceof GrPropertyForCompletion) {
element = ((GrPropertyForCompletion) element).getOriginalAccessor();
}
if (element != null) {
PsiElement delegate = element.getUserData(ResolveUtil.DOCUMENTATION_DELEGATE);
if (delegate != null) {
return delegate;
}
}
return element;
}
@Nullable("null means DFA analysis has failed (too complex to analyze)")
public static Collection<PsiExpression> getCachedVariableValues(
@Nullable final PsiVariable variable, @Nullable final PsiElement context) {
if (variable == null || context == null) return Collections.emptyList();
CachedValue<MultiValuesMap<PsiVariable, PsiExpression>> cachedValue =
context.getUserData(DFA_VARIABLE_INFO_KEY);
if (cachedValue == null) {
final PsiElement codeBlock = DfaPsiUtil.getEnclosingCodeBlock(variable, context);
cachedValue =
CachedValuesManager.getManager(context.getProject())
.createCachedValue(
new CachedValueProvider<MultiValuesMap<PsiVariable, PsiExpression>>() {
@Override
public Result<MultiValuesMap<PsiVariable, PsiExpression>> compute() {
final MultiValuesMap<PsiVariable, PsiExpression> result;
if (codeBlock == null) {
result = null;
} else {
final ValuableInstructionVisitor visitor =
new ValuableInstructionVisitor(context);
RunnerResult runnerResult =
new ValuableDataFlowRunner().analyzeMethod(codeBlock, visitor);
if (runnerResult == RunnerResult.OK) {
result = visitor.myValues;
} else {
result = TOO_COMPLEX;
}
}
return new Result<MultiValuesMap<PsiVariable, PsiExpression>>(
result, variable);
}
},
false);
context.putUserData(DFA_VARIABLE_INFO_KEY, cachedValue);
}
final MultiValuesMap<PsiVariable, PsiExpression> value = cachedValue.getValue();
if (value == TOO_COMPLEX) return null;
final Collection<PsiExpression> expressions = value == null ? null : value.get(variable);
return expressions == null ? Collections.<PsiExpression>emptyList() : expressions;
}
public void visitLiteral(PsiElement literal) {
final PsiElement l2 = myGlobalVisitor.getElement();
MatchingHandler handler = (MatchingHandler) literal.getUserData(CompiledPattern.HANDLER_KEY);
if (handler instanceof SubstitutionHandler) {
int offset = 0;
int length = l2.getTextLength();
final String text = l2.getText();
if (length > 2 && (text.charAt(0) == '"' && text.charAt(length - 1) == '"')
|| (text.charAt(0) == '\'' && text.charAt(length - 1) == '\'')) {
length--;
offset++;
}
myGlobalVisitor.setResult(
((SubstitutionHandler) handler)
.handle(l2, offset, length, myGlobalVisitor.getMatchContext()));
} else if (handler != null) {
myGlobalVisitor.setResult(handler.match(literal, l2, myGlobalVisitor.getMatchContext()));
} else {
myGlobalVisitor.setResult(literal.textMatches(l2));
}
}
public final RunnerResult analyzeMethod(
@NotNull PsiElement psiBlock,
InstructionVisitor visitor,
boolean ignoreAssertions,
@NotNull Collection<DfaMemoryState> initialStates) {
try {
prepareAnalysis(psiBlock, initialStates);
final ControlFlow flow =
createControlFlowAnalyzer().buildControlFlow(psiBlock, ignoreAssertions);
if (flow == null) return RunnerResult.NOT_APPLICABLE;
int endOffset = flow.getInstructionCount();
myInstructions = flow.getInstructions();
myFields = flow.getFields();
myNestedClosures.clear();
if (LOG.isDebugEnabled()) {
LOG.debug("Analyzing code block: " + psiBlock.getText());
for (int i = 0; i < myInstructions.length; i++) {
Instruction instruction = myInstructions[i];
LOG.debug(i + ": " + instruction.toString());
}
}
Integer tooExpensiveHash = psiBlock.getUserData(TOO_EXPENSIVE_HASH);
if (tooExpensiveHash != null && tooExpensiveHash == psiBlock.getText().hashCode()) {
LOG.debug("Too complex because hasn't changed since being too complex already");
return RunnerResult.TOO_COMPLEX;
}
final ArrayList<DfaInstructionState> queue = new ArrayList<DfaInstructionState>();
for (final DfaMemoryState initialState : initialStates) {
queue.add(new DfaInstructionState(myInstructions[0], initialState));
}
long timeLimit = ourTimeLimit;
final boolean unitTestMode = ApplicationManager.getApplication().isUnitTestMode();
WorkingTimeMeasurer measurer = new WorkingTimeMeasurer(timeLimit);
int count = 0;
while (!queue.isEmpty()) {
if (count % 50 == 0 && !unitTestMode && measurer.isTimeOver()) {
LOG.debug("Too complex because the analysis took too long");
psiBlock.putUserData(TOO_EXPENSIVE_HASH, psiBlock.getText().hashCode());
return RunnerResult.TOO_COMPLEX;
}
ProgressManager.checkCanceled();
DfaInstructionState instructionState = queue.remove(0);
if (LOG.isDebugEnabled()) {
LOG.debug(instructionState.toString());
}
// System.out.println(instructionState.toString());
Instruction instruction = instructionState.getInstruction();
long distance = instructionState.getDistanceFromStart();
if (instruction instanceof BranchingInstruction) {
if (!instruction.setMemoryStateProcessed(
instructionState.getMemoryState().createCopy())) {
LOG.debug("Too complex because too many different possible states");
return RunnerResult.TOO_COMPLEX; // Too complex :(
}
}
DfaInstructionState[] after = acceptInstruction(visitor, instructionState);
for (DfaInstructionState state : after) {
Instruction nextInstruction = state.getInstruction();
if ((!(nextInstruction instanceof BranchingInstruction)
|| !nextInstruction.isMemoryStateProcessed(state.getMemoryState()))
&& instruction.getIndex() < endOffset) {
state.setDistanceFromStart(distance + 1);
queue.add(state);
}
}
count++;
}
psiBlock.putUserData(TOO_EXPENSIVE_HASH, null);
LOG.debug("Analysis ok");
return RunnerResult.OK;
} catch (ArrayIndexOutOfBoundsException e) {
LOG.error(psiBlock.getText(), e); // TODO fix in better times
return RunnerResult.ABORTED;
} catch (EmptyStackException e) {
if (LOG.isDebugEnabled()) {
LOG.error(e); // TODO fix in better times
}
return RunnerResult.ABORTED;
}
}
@Override
public void writeExternal(Element element) throws WriteExternalException {
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
if (myPsiElements.isEmpty() && myRangeMarkers.isEmpty() && mySerializedElements.isEmpty()) {
throw new WriteExternalException();
}
if (mySerializedElements.isEmpty()) {
for (SmartPsiElementPointer<PsiElement> ptr : myPsiElements) {
PsiElement psiElement = ptr.getElement();
if (psiElement == null || !psiElement.isValid()) {
continue;
}
FoldingInfo fi = psiElement.getUserData(FOLDING_INFO_KEY);
boolean state = fi != null && fi.expanded;
String signature = FoldingPolicy.getSignature(psiElement);
if (signature == null) {
continue;
}
PsiFile containingFile = psiElement.getContainingFile();
PsiElement restoredElement = FoldingPolicy.restoreBySignature(containingFile, signature);
if (!psiElement.equals(restoredElement)) {
StringBuilder trace = new StringBuilder();
PsiElement restoredAgain =
FoldingPolicy.restoreBySignature(containingFile, signature, trace);
LOG.error(
"element: "
+ psiElement
+ "("
+ psiElement.getText()
+ "); restoredElement: "
+ restoredElement
+ "; signature: '"
+ signature
+ "'; file: "
+ containingFile
+ "; injected: "
+ InjectedLanguageManager.getInstance(myProject)
.isInjectedFragment(containingFile)
+ "; languages: "
+ containingFile.getViewProvider().getLanguages()
+ "; restored again: "
+ restoredAgain
+ "; restore produces same results: "
+ (restoredAgain == restoredElement)
+ "; trace:\n"
+ trace);
}
Element e = new Element(ELEMENT_TAG);
e.setAttribute(SIGNATURE_ATT, signature);
e.setAttribute(EXPANDED_ATT, Boolean.toString(state));
element.addContent(e);
}
} else {
// get back postponed state (before folding initialization)
for (SerializedPsiElement entry : mySerializedElements) {
Element e = new Element(ELEMENT_TAG);
e.setAttribute(SIGNATURE_ATT, entry.mySerializedElement);
e.setAttribute(EXPANDED_ATT, Boolean.toString(entry.myFoldingInfo.getExpanded()));
element.addContent(e);
}
}
String date = null;
for (RangeMarker marker : myRangeMarkers) {
FoldingInfo fi = marker.getUserData(FOLDING_INFO_KEY);
boolean state = fi != null && fi.expanded;
Element e = new Element(MARKER_TAG);
if (date == null) {
date = getTimeStamp();
}
if (date.isEmpty()) {
continue;
}
e.setAttribute(DATE_ATT, date);
e.setAttribute(EXPANDED_ATT, Boolean.toString(state));
String signature =
Integer.valueOf(marker.getStartOffset()) + ":" + Integer.valueOf(marker.getEndOffset());
e.setAttribute(SIGNATURE_ATT, signature);
String placeHolderText = fi == null ? DEFAULT_PLACEHOLDER : fi.placeHolder;
e.setAttribute(PLACEHOLDER_ATT, placeHolderText);
element.addContent(e);
}
}
@Override
public void setToEditor(@NotNull final Editor editor) {
assertDispatchThread();
final PsiManager psiManager = PsiManager.getInstance(myProject);
if (psiManager.isDisposed()) return;
if (!myFile.isValid()) return;
final PsiFile psiFile = psiManager.findFile(myFile);
if (psiFile == null) return;
if (!mySerializedElements.isEmpty()) {
// Restore postponed state
assert myPsiElements.isEmpty() : "Sequential deserialization";
for (SerializedPsiElement entry : mySerializedElements) {
PsiElement restoredElement =
FoldingPolicy.restoreBySignature(psiFile, entry.mySerializedElement);
if (restoredElement != null && restoredElement.isValid()) {
myPsiElements.add(
SmartPointerManager.getInstance(myProject)
.createSmartPsiElementPointer(restoredElement));
restoredElement.putUserData(FOLDING_INFO_KEY, entry.myFoldingInfo);
}
}
mySerializedElements.clear();
}
Map<PsiElement, FoldingDescriptor> ranges = null;
for (SmartPsiElementPointer<PsiElement> ptr : myPsiElements) {
PsiElement element = ptr.getElement();
if (element == null || !element.isValid()) {
continue;
}
if (ranges == null) {
ranges = buildRanges(editor, psiFile);
}
FoldingDescriptor descriptor = ranges.get(element);
if (descriptor == null) {
continue;
}
TextRange range = descriptor.getRange();
FoldRegion region =
FoldingUtil.findFoldRegion(editor, range.getStartOffset(), range.getEndOffset());
if (region != null) {
FoldingInfo fi = element.getUserData(FOLDING_INFO_KEY);
boolean state = fi != null && fi.expanded;
region.setExpanded(state);
}
}
for (RangeMarker marker : myRangeMarkers) {
if (!marker.isValid()) {
continue;
}
FoldRegion region =
FoldingUtil.findFoldRegion(editor, marker.getStartOffset(), marker.getEndOffset());
FoldingInfo info = marker.getUserData(FOLDING_INFO_KEY);
if (region == null) {
if (info != null) {
region =
editor
.getFoldingModel()
.addFoldRegion(marker.getStartOffset(), marker.getEndOffset(), info.placeHolder);
}
if (region == null) {
return;
}
}
boolean state = info != null && info.expanded;
region.setExpanded(state);
}
}
private static MultiHostRegistrarImpl probeElementsUp(
@NotNull PsiElement element, @NotNull PsiFile hostPsiFile, boolean probeUp) {
PsiManager psiManager = hostPsiFile.getManager();
final Project project = psiManager.getProject();
InjectedLanguageManagerImpl injectedManager =
InjectedLanguageManagerImpl.getInstanceImpl(project);
if (injectedManager == null) {
return null; // for tests
}
MultiHostRegistrarImpl registrar = null;
PsiElement current = element;
nextParent:
while (current != null && current != hostPsiFile) {
ProgressManager.checkCanceled();
if ("EL".equals(current.getLanguage().getID())) break;
ParameterizedCachedValue<MultiHostRegistrarImpl, PsiElement> data =
current.getUserData(INJECTED_PSI);
if (data == null) {
registrar =
InjectedPsiCachedValueProvider.doCompute(
current, injectedManager, project, hostPsiFile);
} else {
registrar = data.getValue(current);
}
current = current.getParent(); // cache no injection for current
if (registrar != null) {
List<Pair<Place, PsiFile>> places = registrar.getResult();
// check that injections found intersect with queried element
TextRange elementRange = element.getTextRange();
for (Pair<Place, PsiFile> pair : places) {
Place place = pair.first;
for (PsiLanguageInjectionHost.Shred shred : place) {
if (shred.getHost().getTextRange().intersects(elementRange)) {
if (place.isValid()) break nextParent;
}
}
}
}
if (!probeUp) {
break;
}
}
if (probeUp) {
// cache only if we walked all parents
for (PsiElement e = element;
e != current && e != null && e != hostPsiFile;
e = e.getParent()) {
ProgressManager.checkCanceled();
if (registrar == null) {
e.putUserData(INJECTED_PSI, null);
} else {
ParameterizedCachedValue<MultiHostRegistrarImpl, PsiElement> cachedValue =
CachedValuesManager.getManager(project)
.createParameterizedCachedValue(INJECTED_PSI_PROVIDER, false);
CachedValueProvider.Result<MultiHostRegistrarImpl> result =
CachedValueProvider.Result.create(
registrar, PsiModificationTracker.MODIFICATION_COUNT, registrar);
((PsiParameterizedCachedValue<MultiHostRegistrarImpl, PsiElement>) cachedValue)
.setValue(result);
e.putUserData(INJECTED_PSI, cachedValue);
}
}
}
return registrar;
}
@Override
@Nullable
public String generateDoc(PsiElement element, PsiElement originalElement) {
if (element instanceof CustomMembersGenerator.GdslNamedParameter) {
CustomMembersGenerator.GdslNamedParameter parameter =
(CustomMembersGenerator.GdslNamedParameter) element;
String result = "<pre><b>" + parameter.getName() + "</b>";
if (parameter.myParameterTypeText != null) {
result += ": " + parameter.myParameterTypeText;
}
result += "</pre>";
if (parameter.docString != null) {
result += "<p>" + parameter.docString;
}
return result;
}
if (element instanceof GrReferenceExpression) {
return getMethodCandidateInfo((GrReferenceExpression) element);
}
element = getDocumentationElement(element, originalElement);
if (element == null) return null;
String standard =
element.getNavigationElement() instanceof PsiDocCommentOwner
? JavaDocumentationProvider.generateExternalJavadoc(element)
: null;
if (element instanceof GrVariable
&& ((GrVariable) element).getTypeElementGroovy() == null
&& standard != null) {
final String truncated = StringUtil.trimEnd(standard, BODY_HTML);
StringBuilder buffer = new StringBuilder(truncated);
buffer.append("<p>");
if (originalElement != null) {
appendInferredType(originalElement, (GrVariable) element, buffer);
} else if (element.getParent() instanceof GrVariableDeclaration) {
appendInferredType(element.getParent(), (GrVariable) element, buffer);
}
if (!truncated.equals(standard)) {
buffer.append(BODY_HTML);
}
standard = buffer.toString();
}
String gdslDoc = element.getUserData(NonCodeMembersHolder.DOCUMENTATION);
if (gdslDoc != null) {
if (standard != null) {
String truncated = StringUtil.trimEnd(standard, BODY_HTML);
String appended = truncated + "<p>" + gdslDoc;
if (truncated.equals(standard)) {
return appended;
}
return appended + BODY_HTML;
}
return gdslDoc;
}
return standard;
}
public void replace(final ReplacementInfo info, ReplaceOptions options) {
PsiElement elementToReplace = info.getMatch(0);
PsiElement elementParent = elementToReplace.getParent();
String replacementToMake = info.getReplacement();
Project project = myContext.getProject();
PsiElement el = findRealSubstitutionElement(elementToReplace);
boolean listContext = isListContext(el);
if (el instanceof PsiAnnotation && !StringUtil.startsWithChar(replacementToMake, '@')) {
replacementToMake = "@" + replacementToMake;
}
PsiElement[] statements =
ReplacerUtil.createTreeForReplacement(
replacementToMake,
el instanceof PsiMember && !isSymbolReplacement(el)
? PatternTreeContext.Class
: PatternTreeContext.Block,
myContext);
if (listContext) {
if (statements.length > 1) {
elementParent.addRangeBefore(
statements[0], statements[statements.length - 1], elementToReplace);
} else if (statements.length == 1) {
PsiElement replacement = getMatchExpr(statements[0], elementToReplace);
handleModifierList(el, replacement);
replacement = handleSymbolReplacement(replacement, el);
if (replacement instanceof PsiTryStatement) {
final List<PsiCatchSection> unmatchedCatchSections =
el.getUserData(JavaMatchingVisitor.UNMATCHED_CATCH_SECTION_CONTENT_VAR_KEY);
final PsiCatchSection[] catches = ((PsiTryStatement) replacement).getCatchSections();
if (unmatchedCatchSections != null) {
for (int i = unmatchedCatchSections.size() - 1; i >= 0; --i) {
final PsiParameter parameter = unmatchedCatchSections.get(i).getParameter();
final PsiElementFactory elementFactory =
JavaPsiFacade.getInstance(project).getElementFactory();
final PsiCatchSection catchSection =
elementFactory.createCatchSection(parameter.getType(), parameter.getName(), null);
catchSection.getCatchBlock().replace(unmatchedCatchSections.get(i).getCatchBlock());
replacement.addAfter(catchSection, catches[catches.length - 1]);
replacement.addBefore(createWhiteSpace(replacement), replacement.getLastChild());
}
}
}
try {
final PsiElement inserted = elementParent.addBefore(replacement, elementToReplace);
if (replacement instanceof PsiComment
&& (elementParent instanceof PsiIfStatement
|| elementParent instanceof PsiLoopStatement)) {
elementParent.addAfter(createSemicolon(replacement), inserted);
}
} catch (IncorrectOperationException e) {
elementToReplace.replace(replacement);
}
}
} else if (statements.length > 0) {
PsiElement replacement =
ReplacerUtil.copySpacesAndCommentsBefore(
elementToReplace, statements, replacementToMake, elementParent);
replacement = getMatchExpr(replacement, elementToReplace);
if (replacement instanceof PsiStatement
&& !(replacement.getLastChild() instanceof PsiJavaToken)
&& !(replacement.getLastChild() instanceof PsiComment)) {
// assert w/o ;
final PsiElement prevLastChildInParent = replacement.getLastChild().getPrevSibling();
if (prevLastChildInParent != null) {
elementParent.addRangeBefore(replacement.getFirstChild(), prevLastChildInParent, el);
} else {
elementParent.addBefore(replacement.getFirstChild(), el);
}
el.getNode().getTreeParent().removeChild(el.getNode());
} else {
// preserve comments
handleModifierList(el, replacement);
if (replacement instanceof PsiClass) {
// modifier list
final PsiStatement[] searchStatements = getCodeBlock().getStatements();
if (searchStatements.length > 0
&& searchStatements[0] instanceof PsiDeclarationStatement
&& ((PsiDeclarationStatement) searchStatements[0]).getDeclaredElements()[0]
instanceof PsiClass) {
final PsiClass replaceClazz = (PsiClass) replacement;
final PsiClass queryClazz =
(PsiClass) ((PsiDeclarationStatement) searchStatements[0]).getDeclaredElements()[0];
final PsiClass clazz = (PsiClass) el;
if (replaceClazz.getExtendsList().getTextLength() == 0
&& queryClazz.getExtendsList().getTextLength() == 0
&& clazz.getExtendsList().getTextLength() != 0) {
replaceClazz.addBefore(
clazz.getExtendsList().getPrevSibling(),
replaceClazz.getExtendsList()); // whitespace
replaceClazz
.getExtendsList()
.addRange(
clazz.getExtendsList().getFirstChild(),
clazz.getExtendsList().getLastChild());
}
if (replaceClazz.getImplementsList().getTextLength() == 0
&& queryClazz.getImplementsList().getTextLength() == 0
&& clazz.getImplementsList().getTextLength() != 0) {
replaceClazz.addBefore(
clazz.getImplementsList().getPrevSibling(),
replaceClazz.getImplementsList()); // whitespace
replaceClazz
.getImplementsList()
.addRange(
clazz.getImplementsList().getFirstChild(),
clazz.getImplementsList().getLastChild());
}
if (replaceClazz.getTypeParameterList().getTextLength() == 0
&& queryClazz.getTypeParameterList().getTextLength() == 0
&& clazz.getTypeParameterList().getTextLength() != 0) {
// skip < and >
replaceClazz.getTypeParameterList().replace(clazz.getTypeParameterList());
}
}
}
replacement = handleSymbolReplacement(replacement, el);
el.replace(replacement);
}
} else {
final PsiElement nextSibling = el.getNextSibling();
el.delete();
if (nextSibling instanceof PsiWhiteSpace && nextSibling.isValid()) {
nextSibling.delete();
}
}
if (listContext) {
final int matchSize = info.getMatchesCount();
for (int i = 0; i < matchSize; ++i) {
PsiElement matchElement = info.getMatch(i);
PsiElement element = findRealSubstitutionElement(matchElement);
if (element == null) continue;
PsiElement firstToDelete = element;
PsiElement lastToDelete = element;
PsiElement prevSibling = element.getPrevSibling();
PsiElement nextSibling = element.getNextSibling();
if (prevSibling instanceof PsiWhiteSpace) {
firstToDelete = prevSibling;
prevSibling = prevSibling != null ? prevSibling.getPrevSibling() : null;
} else if (prevSibling == null && nextSibling instanceof PsiWhiteSpace) {
lastToDelete = nextSibling;
}
if (nextSibling instanceof XmlText && i + 1 < matchSize) {
final PsiElement next = info.getMatch(i + 1);
if (next != null && next == nextSibling.getNextSibling()) {
lastToDelete = nextSibling;
}
}
if (element instanceof PsiExpression) {
final PsiElement parent = element.getParent().getParent();
if ((parent instanceof PsiCall || parent instanceof PsiAnonymousClass)
&& prevSibling instanceof PsiJavaToken
&& ((PsiJavaToken) prevSibling).getTokenType() == JavaTokenType.COMMA) {
firstToDelete = prevSibling;
}
} else if (element instanceof PsiParameter
&& prevSibling instanceof PsiJavaToken
&& ((PsiJavaToken) prevSibling).getTokenType() == JavaTokenType.COMMA) {
firstToDelete = prevSibling;
}
element.getParent().deleteChildRange(firstToDelete, lastToDelete);
}
}
}
@NotNull
final RunnerResult analyzeMethod(
@NotNull PsiElement psiBlock,
@NotNull InstructionVisitor visitor,
boolean ignoreAssertions,
@NotNull Collection<DfaMemoryState> initialStates) {
if (PsiTreeUtil.findChildOfType(psiBlock, OuterLanguageElement.class) != null)
return RunnerResult.NOT_APPLICABLE;
try {
final ControlFlow flow =
new ControlFlowAnalyzer(myValueFactory, psiBlock, ignoreAssertions).buildControlFlow();
if (flow == null) return RunnerResult.NOT_APPLICABLE;
int[] loopNumber = LoopAnalyzer.calcInLoop(flow);
int endOffset = flow.getInstructionCount();
myInstructions = flow.getInstructions();
myNestedClosures.clear();
Set<Instruction> joinInstructions = ContainerUtil.newHashSet();
for (int index = 0; index < myInstructions.length; index++) {
Instruction instruction = myInstructions[index];
if (instruction instanceof GotoInstruction) {
joinInstructions.add(myInstructions[((GotoInstruction) instruction).getOffset()]);
} else if (instruction instanceof ConditionalGotoInstruction) {
joinInstructions.add(
myInstructions[((ConditionalGotoInstruction) instruction).getOffset()]);
} else if (instruction instanceof MethodCallInstruction
&& !((MethodCallInstruction) instruction).getContracts().isEmpty()) {
joinInstructions.add(myInstructions[index + 1]);
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("Analyzing code block: " + psiBlock.getText());
for (int i = 0; i < myInstructions.length; i++) {
LOG.debug(i + ": " + myInstructions[i]);
}
}
// for (int i = 0; i < myInstructions.length; i++) System.out.println(i + ": " +
// myInstructions[i].toString());
Integer tooExpensiveHash = psiBlock.getUserData(TOO_EXPENSIVE_HASH);
if (tooExpensiveHash != null && tooExpensiveHash == psiBlock.getText().hashCode()) {
LOG.debug("Too complex because hasn't changed since being too complex already");
return RunnerResult.TOO_COMPLEX;
}
final StateQueue queue = new StateQueue();
for (final DfaMemoryState initialState : initialStates) {
queue.offer(new DfaInstructionState(myInstructions[0], initialState));
}
MultiMap<BranchingInstruction, DfaMemoryState> processedStates = MultiMap.createSet();
MultiMap<BranchingInstruction, DfaMemoryState> incomingStates = MultiMap.createSet();
long msLimit =
shouldCheckTimeLimit()
? Registry.intValue("ide.dfa.time.limit.online")
: Registry.intValue("ide.dfa.time.limit.offline");
WorkingTimeMeasurer measurer = new WorkingTimeMeasurer(msLimit * 1000 * 1000);
int count = 0;
while (!queue.isEmpty()) {
List<DfaInstructionState> states = queue.getNextInstructionStates(joinInstructions);
for (DfaInstructionState instructionState : states) {
if (count++ % 1024 == 0 && measurer.isTimeOver()) {
LOG.debug("Too complex because the analysis took too long");
psiBlock.putUserData(TOO_EXPENSIVE_HASH, psiBlock.getText().hashCode());
return RunnerResult.TOO_COMPLEX;
}
ProgressManager.checkCanceled();
if (LOG.isDebugEnabled()) {
LOG.debug(instructionState.toString());
}
// System.out.println(instructionState.toString());
Instruction instruction = instructionState.getInstruction();
if (instruction instanceof BranchingInstruction) {
BranchingInstruction branching = (BranchingInstruction) instruction;
Collection<DfaMemoryState> processed = processedStates.get(branching);
if (processed.contains(instructionState.getMemoryState())) {
continue;
}
if (processed.size() > MAX_STATES_PER_BRANCH) {
LOG.debug("Too complex because too many different possible states");
return RunnerResult.TOO_COMPLEX; // Too complex :(
}
if (loopNumber[branching.getIndex()] != 0) {
processedStates.putValue(branching, instructionState.getMemoryState().createCopy());
}
}
DfaInstructionState[] after = acceptInstruction(visitor, instructionState);
for (DfaInstructionState state : after) {
Instruction nextInstruction = state.getInstruction();
if (nextInstruction.getIndex() >= endOffset) {
continue;
}
handleStepOutOfLoop(
instruction,
nextInstruction,
loopNumber,
processedStates,
incomingStates,
states,
after,
queue);
if (nextInstruction instanceof BranchingInstruction) {
BranchingInstruction branching = (BranchingInstruction) nextInstruction;
if (processedStates.get(branching).contains(state.getMemoryState())
|| incomingStates.get(branching).contains(state.getMemoryState())) {
continue;
}
if (loopNumber[branching.getIndex()] != 0) {
incomingStates.putValue(branching, state.getMemoryState().createCopy());
}
}
queue.offer(state);
}
}
}
psiBlock.putUserData(TOO_EXPENSIVE_HASH, null);
LOG.debug("Analysis ok");
return RunnerResult.OK;
} catch (ArrayIndexOutOfBoundsException e) {
LOG.error(psiBlock.getText(), e);
return RunnerResult.ABORTED;
} catch (EmptyStackException e) {
LOG.error(psiBlock.getText(), e);
return RunnerResult.ABORTED;
}
}