@Override protected IStatus run(IProgressMonitor monitor) { IParserObserver observer = new RenameInFileParserObserver(); PyParser parser = pyEdit.getParser(); parser.addParseListener(observer); // it will analyze when the next parse is finished parser.forceReparse(); return Status.OK_STATUS; }
private List<FoldingEntry> getMarks(Document doc, int grammarVersion) { ParseOutput r = PyParser.reparseDocument(new PyParser.ParserInfo(doc, grammarVersion, null)); List<FoldingEntry> marks = CodeFoldingSetter.getMarks(doc, (SimpleNode) r.ast, true); if (DEBUG) { for (FoldingEntry entry : marks) { System.out.println(entry); } } return marks; }
/** * @param request this is the request for the completion * @param theList OUT - returned completions are added here. (IToken instances) * @param getOnlySupers whether we should only get things from super classes (in this case, we * won't get things from the current class) * @param checkIfInCorrectScope if true, we'll first check if we're in a scope that actually has a * method with 'self' or 'cls' * @return true if we actually tried to get the completions for self or cls. * @throws MisconfigurationException */ @SuppressWarnings("unchecked") public static boolean getSelfOrClsCompletions( CompletionRequest request, List theList, ICompletionState state, boolean getOnlySupers, boolean checkIfInCorrectScope, String lookForRep) throws MisconfigurationException { SimpleNode s = PyParser.reparseDocument( new PyParser.ParserInfo(request.doc, true, request.nature, state.getLine())) .o1; if (s != null) { FindScopeVisitor visitor = new FindScopeVisitor(state.getLine(), 0); try { s.accept(visitor); if (checkIfInCorrectScope) { boolean scopeCorrect = false; FastStack<SimpleNode> scopeStack = visitor.scope.getScopeStack(); for (Iterator<SimpleNode> it = scopeStack.topDownIterator(); scopeCorrect == false && it.hasNext(); ) { SimpleNode node = it.next(); if (node instanceof FunctionDef) { FunctionDef funcDef = (FunctionDef) node; if (funcDef.args != null && funcDef.args.args != null && funcDef.args.args.length > 0) { // ok, we have some arg, let's check for self or cls String rep = NodeUtils.getRepresentationString(funcDef.args.args[0]); if (rep != null && (rep.equals("self") || rep.equals("cls"))) { scopeCorrect = true; } } } } if (!scopeCorrect) { return false; } } if (lookForRep.equals("self")) { state.setLookingFor(ICompletionState.LOOKING_FOR_INSTANCED_VARIABLE); } else { state.setLookingFor(ICompletionState.LOOKING_FOR_CLASSMETHOD_VARIABLE); } getSelfOrClsCompletions(visitor.scope, request, theList, state, getOnlySupers); } catch (Exception e1) { PydevPlugin.log(e1); } return true; } return false; }
/** * This function creates the module given that you have a document (that will be parsed) * * @throws MisconfigurationException */ public static SourceModule createModuleFromDoc( String name, File f, IDocument doc, IPythonNature nature, boolean checkForPath, IGrammarVersionProvider grammarVersionProvider) throws MisconfigurationException { // for doc, we are only interested in python files. if (f != null) { if (!checkForPath || PythonPathHelper.isValidSourceFile(f.getName())) { ParseOutput obj = PyParser.reparseDocument(new PyParser.ParserInfo(doc, grammarVersionProvider, name, f)); return new SourceModule(name, f, (SimpleNode) obj.ast, obj.error, nature); } } else { ParseOutput obj = PyParser.reparseDocument(new PyParser.ParserInfo(doc, grammarVersionProvider, name, f)); return new SourceModule(name, f, (SimpleNode) obj.ast, obj.error, nature); } return null; }
public static Module getRootNode(IDocument doc) throws ParseException { Tuple<SimpleNode, Throwable> objects = PyParser.reparseDocument( new PyParser.ParserInfo(doc, false, IPythonNature.LATEST_GRAMMAR_VERSION)); Throwable exception = objects.o2; if (exception != null) { /* We try to get rid of the 'Throwable' exception, if possible */ if (exception instanceof ParseException) { throw (ParseException) exception; } else if (exception instanceof TokenMgrError) { /* Error from Lexer */ throw new ParseException(exception.toString()); } else { throw new RuntimeException(exception); } } if (objects.o2 != null) throw new RuntimeException(objects.o2); return (Module) objects.o1; }
/** * Restores the info for a module manager * * @param monitor a monitor to keep track of the progress * @param m the module manager * @param nature the associated nature (may be null if there is no associated nature -- as is the * case when restoring system info). * @return the info generated from the module manager */ public static AbstractAdditionalTokensInfo restoreInfoForModuleManager( IProgressMonitor monitor, IModulesManager m, String additionalFeedback, AbstractAdditionalTokensInfo info, IPythonNature nature, int grammarVersion) { if (monitor == null) { monitor = new NullProgressMonitor(); } // TODO: Check if keeping a zip file open makes things faster... // Timer timer = new Timer(); ModulesKey[] allModules = m.getOnlyDirectModules(); int i = 0; FastStringBuffer msgBuffer = new FastStringBuffer(); for (ModulesKey key : allModules) { if (monitor.isCanceled()) { return null; } i++; if (PythonPathHelper.canAddAstInfoFor( key)) { // otherwise it should be treated as a compiled module (no ast generation) if (i % 17 == 0) { msgBuffer.clear(); msgBuffer.append("Creating "); msgBuffer.append(additionalFeedback); msgBuffer.append(" additional info ("); msgBuffer.append(i); msgBuffer.append(" of "); msgBuffer.append(allModules.length); msgBuffer.append(") for "); msgBuffer.append(key.file.getName()); monitor.setTaskName(msgBuffer.toString()); monitor.worked(1); } try { if (info.addAstInfo(key, false) == null) { String str = "Unable to generate ast -- using %s.\nError:%s"; ErrorDescription errorDesc = null; throw new RuntimeException( com.aptana.shared_core.string.StringUtils.format( str, PyParser.getGrammarVersionStr(grammarVersion), (errorDesc != null && errorDesc.message != null) ? errorDesc.message : "unable to determine")); } } catch (Throwable e) { Log.log(IStatus.ERROR, "Problem parsing the file :" + key.file + ".", e); } } } // timer.printDiff("Time to restore additional info"); return info; }
private boolean ensureParsed(PyEdit edit) { // Ok, we have a little problem here: we have to ensure not that only a regular ast parse took // place, but // that the analysis of the related document is updated (so that the markers are in-place). // To do that, we ask for a reparse asking to analyze the results in that same thread (without // scheduling it). // // Maybe better would be having some extension that allowed to call the analysis of the document // directly // (so we don't have to rely on markers in place?) final PyParser parser = edit.getParser(); final boolean[] notified = new boolean[] {false}; final Object sentinel = new Object(); parser.addPostParseListener( new IPostParserListener() { @Override public void participantsNotified(Object... argsToReparse) { synchronized (OrganizeImportsFixesUnused.this) { parser.removePostParseListener(this); if (argsToReparse.length == 2 && argsToReparse[1] == sentinel) { notified[0] = true; OrganizeImportsFixesUnused.this.notify(); } } } }); long initial = System.currentTimeMillis(); while ((System.currentTimeMillis() - initial) < 5000) { if (parser.forceReparse( new Tuple<String, Boolean>( IMiscConstants.ANALYSIS_PARSER_OBSERVER_FORCE_IN_THIS_THREAD, true), sentinel)) { // ok, we were able to schedule it with our parameters, let's wait for its completion... synchronized (this) { try { wait(5000); } catch (InterruptedException e) { } } break; } else { synchronized (this) { try { wait(200); } catch (InterruptedException e) { } } } } // Commented out: in the worse case, we already waited 5 seconds, if because of a racing // condition we couldn't decide // that it worked, let's just keep on going hoping that the markers are in place... // if (!notified[0]) { // return false; // } return true; }