public static boolean openFileWithPsiElement(
PsiElement element, boolean searchForOpen, boolean requestFocus) {
boolean openAsNative = false;
if (element instanceof PsiFile) {
VirtualFile virtualFile = ((PsiFile) element).getVirtualFile();
if (virtualFile != null) {
openAsNative = ElementBase.isNativeFileType(virtualFile.getFileType());
}
}
if (searchForOpen) {
element.putUserData(FileEditorManager.USE_CURRENT_WINDOW, null);
} else {
element.putUserData(FileEditorManager.USE_CURRENT_WINDOW, true);
}
if (openAsNative || !activatePsiElementIfOpen(element, searchForOpen, requestFocus)) {
final NavigationItem navigationItem = (NavigationItem) element;
if (!navigationItem.canNavigate()) return false;
navigationItem.navigate(requestFocus);
return true;
}
element.putUserData(FileEditorManager.USE_CURRENT_WINDOW, null);
return false;
}
void loadFromEditor(@NotNull Editor editor) {
assertDispatchThread();
LOG.assertTrue(!editor.isDisposed());
clear();
PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject);
documentManager.commitDocument(editor.getDocument());
PsiFile file = documentManager.getPsiFile(editor.getDocument());
SmartPointerManager smartPointerManager = SmartPointerManager.getInstance(myProject);
EditorFoldingInfo info = EditorFoldingInfo.get(editor);
FoldRegion[] foldRegions = editor.getFoldingModel().getAllFoldRegions();
for (FoldRegion region : foldRegions) {
if (!region.isValid()) continue;
PsiElement element = info.getPsiElement(region);
boolean expanded = region.isExpanded();
boolean collapseByDefault =
element != null
&& FoldingPolicy.isCollapseByDefault(element)
&& !FoldingUtil.caretInsideRange(editor, TextRange.create(region));
if (collapseByDefault == expanded || element == null) {
FoldingInfo fi = new FoldingInfo(region.getPlaceholderText(), expanded);
if (element != null) {
myPsiElements.add(smartPointerManager.createSmartPsiElementPointer(element, file));
element.putUserData(FOLDING_INFO_KEY, fi);
} else if (region.isValid()) {
myRangeMarkers.add(region);
region.putUserData(FOLDING_INFO_KEY, fi);
}
}
}
}
private CompletionParameters createCompletionParameters(
int invocationCount, final CompletionContext newContext, Editor editor) {
final int offset = newContext.getStartOffset();
final PsiFile fileCopy = newContext.file;
PsiFile originalFile = fileCopy.getOriginalFile();
final PsiElement insertedElement =
findCompletionPositionLeaf(newContext, offset, fileCopy, originalFile);
insertedElement.putUserData(CompletionContext.COMPLETION_CONTEXT_KEY, newContext);
return new CompletionParameters(
insertedElement, originalFile, myCompletionType, offset, invocationCount, editor);
}
@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;
}
@Override
public CachedValueProvider.Result<PsiExpression> compute(
Pair<Project, PsiExpression> pair) {
PsiExpression param = pair.second;
Project project = pair.first;
PsiExpression topLevel = getTopLevel(project, param);
ParameterizedCachedValue<PsiExpression, Pair<Project, PsiExpression>> cachedValue =
param.getUserData(TOP_LEVEL_EXPRESSION);
assert cachedValue != null;
int i = 0;
for (PsiElement element = param;
element != topLevel;
element = element.getParent(), i++) {
if (i % 10
== 0) { // optimization: store up link to the top level expression in each 10nth
// element
element.putUserData(TOP_LEVEL_EXPRESSION, cachedValue);
}
}
return CachedValueProvider.Result.create(
topLevel, PsiManager.getInstance(project).getModificationTracker());
}
private void visitLiteral(PsiElement literal) {
String value = literal.getText();
if (value.length() > 2 && (value.charAt(0) == '"' && value.charAt(value.length() - 1) == '"')
|| (value.charAt(0) == '\'' && value.charAt(value.length() - 1) == '\'')) {
if (mySubstitutionPatterns == null) {
final String[] prefixes = myGlobalVisitor.getContext().getPattern().getTypedVarPrefixes();
mySubstitutionPatterns = createPatterns(prefixes);
}
for (Pattern substitutionPattern : mySubstitutionPatterns) {
@Nullable
MatchingHandler handler =
myGlobalVisitor.processPatternStringWithFragments(
value, GlobalCompilingVisitor.OccurenceKind.LITERAL, substitutionPattern);
if (handler != null) {
literal.putUserData(CompiledPattern.HANDLER_KEY, handler);
break;
}
}
}
}
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 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;
}
public void performAction(IntroduceOperation operation) {
final PsiFile file = operation.getFile();
if (!CommonRefactoringUtil.checkReadOnlyStatus(file)) {
return;
}
final Editor editor = operation.getEditor();
if (editor.getSettings().isVariableInplaceRenameEnabled()) {
final TemplateState templateState =
TemplateManagerImpl.getTemplateState(operation.getEditor());
if (templateState != null && !templateState.isFinished()) {
return;
}
}
PsiElement element1 = null;
PsiElement element2 = null;
final SelectionModel selectionModel = editor.getSelectionModel();
boolean singleElementSelection = false;
if (selectionModel.hasSelection()) {
element1 = file.findElementAt(selectionModel.getSelectionStart());
element2 = file.findElementAt(selectionModel.getSelectionEnd() - 1);
if (element1 instanceof PsiWhiteSpace) {
int startOffset = element1.getTextRange().getEndOffset();
element1 = file.findElementAt(startOffset);
}
if (element2 instanceof PsiWhiteSpace) {
int endOffset = element2.getTextRange().getStartOffset();
element2 = file.findElementAt(endOffset - 1);
}
if (element1 == element2) {
singleElementSelection = true;
}
} else {
if (smartIntroduce(operation)) {
return;
}
final CaretModel caretModel = editor.getCaretModel();
final Document document = editor.getDocument();
int lineNumber = document.getLineNumber(caretModel.getOffset());
if ((lineNumber >= 0) && (lineNumber < document.getLineCount())) {
element1 = file.findElementAt(document.getLineStartOffset(lineNumber));
element2 = file.findElementAt(document.getLineEndOffset(lineNumber) - 1);
}
}
final Project project = operation.getProject();
if (element1 == null || element2 == null) {
showCannotPerformError(project, editor);
return;
}
element1 = PyRefactoringUtil.getSelectedExpression(project, file, element1, element2);
if (element1 == null) {
showCannotPerformError(project, editor);
return;
}
if (singleElementSelection && element1 instanceof PyStringLiteralExpression) {
final PyStringLiteralExpression literal = (PyStringLiteralExpression) element1;
// Currently introduce for substrings of a multi-part string literals is not supported
if (literal.getStringNodes().size() > 1) {
showCannotPerformError(project, editor);
return;
}
final int offset = element1.getTextOffset();
final TextRange selectionRange =
TextRange.create(selectionModel.getSelectionStart(), selectionModel.getSelectionEnd());
final TextRange elementRange = element1.getTextRange();
if (!elementRange.equals(selectionRange) && elementRange.contains(selectionRange)) {
final TextRange innerRange = literal.getStringValueTextRange();
final TextRange intersection = selectionRange.shiftRight(-offset).intersection(innerRange);
final TextRange finalRange = intersection != null ? intersection : selectionRange;
final String text = literal.getText();
if (getFormatValueExpression(literal) != null && breaksStringFormatting(text, finalRange)
|| getNewStyleFormatValueExpression(literal) != null
&& breaksNewStyleStringFormatting(text, finalRange)
|| breaksStringEscaping(text, finalRange)) {
showCannotPerformError(project, editor);
return;
}
element1.putUserData(
PyReplaceExpressionUtil.SELECTION_BREAKS_AST_NODE, Pair.create(element1, finalRange));
}
}
if (!checkIntroduceContext(file, editor, element1)) {
return;
}
operation.setElement(element1);
performActionOnElement(operation);
}
@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;
}
}
