Examples with IToken org.python.pydev.core.IToken used on opensource projects

Example 6 with IToken

use of org.python.pydev.core.IToken in project Pydev by fabioz.

the class MessagesManager method getMessages.

/**
 * @return the generated messages.
 */
public List<IMessage> getMessages() {
    List<IMessage> result = new ArrayList<IMessage>();
    // let's get the messages
    for (List<IMessage> l : messages.values()) {
        if (l.size() < 1) {
            // we need at least one message
            continue;
        }
        Map<Integer, List<IMessage>> messagesByType = getMessagesByType(l);
        for (int type : messagesByType.keySet()) {
            l = messagesByType.get(type);
            // the values are guaranteed to have size at least equal to 1
            IMessage message = l.get(0);
            // messages are grouped by type, and the severity is set by type, so, this is ok...
            if (message.getSeverity() < IMarker.SEVERITY_INFO) {
                if (doIgnoreMessageIfJustInformational(message.getType())) {
                    // used anyways for other actions)
                    continue;
                }
            }
            if (l.size() == 1) {
                // don't add additional info: not being used
                // addAdditionalInfoToUnusedWildImport(message);
                addToResult(result, message);
            } else {
                // the generator token has many associated messages - the messages may have different types,
                // so, we need to get them by types
                IToken generator = message.getGenerator();
                CompositeMessage compositeMessage;
                if (generator != null) {
                    compositeMessage = new CompositeMessage(message.getType(), generator, prefs);
                } else {
                    compositeMessage = new CompositeMessage(message.getType(), message.getStartLine(document), message.getEndLine(document), message.getStartCol(document), message.getEndCol(document), prefs);
                }
                for (IMessage m : l) {
                    compositeMessage.addMessage(m);
                }
                // don't add additional info: not being used
                // addAdditionalInfoToUnusedWildImport(compositeMessage);
                addToResult(result, compositeMessage);
            }
        }
    }
    for (IMessage message : independentMessages) {
        if (message.getSeverity() < IMarker.SEVERITY_INFO) {
            if (doIgnoreMessageIfJustInformational(message.getType())) {
                // used anyways for other actions)
                continue;
            }
        // otherwise keep on and add it (needed for some actions)
        }
        addToResult(result, message);
    }
    return result;
}

Example 7 with IToken

use of org.python.pydev.core.IToken in project Pydev by fabioz.

the class ForcedLibGroup method calculateChildren.

@Override
protected void calculateChildren() throws MisconfigurationException {
    SystemModulesManager m = (SystemModulesManager) this.interpreterInfo.getModulesManager();
    AbstractModule builtinModule = m.getBuiltinModule(forcedLib, true, new BaseModuleRequest(true));
    TokensList globalTokens = builtinModule.getGlobalTokens();
    ArrayList<LeafElement> lst = new ArrayList<LeafElement>();
    for (IterTokenEntry entry : globalTokens) {
        IToken iToken = entry.getToken();
        lst.add(new LeafElement(this, iToken.getRepresentation()));
    }
    Collections.sort(lst, new Comparator<LeafElement>() {

        @Override
        public int compare(LeafElement o1, LeafElement o2) {
            return o1.toString().compareTo(o2.toString());
        }
    });
    for (LeafElement leafElement : lst) {
        addChild(leafElement);
    }
}

Example 8 with IToken

use of org.python.pydev.core.IToken in project Pydev by fabioz.

the class AbstractScopeAnalyzerVisitor method visitImport.

/**
 * when visiting an import, just make the token and add it
 *
 * e.g.: if it is an import such as 'os.path', it will return 2 tokens, one for 'os' and one for 'os.path',
 *
 * @see org.python.pydev.parser.jython.ast.VisitorIF#visitImport(org.python.pydev.parser.jython.ast.Import)
 */
@Override
public Object visitImport(Import node) throws Exception {
    unhandled_node(node);
    List<IToken> list = AbstractVisitor.makeImportToken(node, null, moduleName, true, nature);
    if (checkCurrentScopeForAssignmentsToBuiltins()) {
        for (IToken token : list) {
            if (builtinTokens.contains(token.getRepresentation())) {
                // Overriding builtin...
                onAddAssignmentToBuiltinMessage(token, token.getRepresentation());
            }
        }
    }
    scope.addImportTokens(new TokensList(list), null, this.completionCache);
    return null;
}

Example 9 with IToken

use of org.python.pydev.core.IToken in project Pydev by fabioz.

the class AbstractScopeAnalyzerVisitor method endScope.

/**
 * finalizes the current scope
 * @param reportUnused: defines whether we should report unused things found (we may not want to do that
 * when we have an abstract method)
 */
protected void endScope(SimpleNode node) {
    onBeforeEndScope(node);
    // clear the last scope
    ScopeItems m = scope.endScope();
    for (Iterator<Found> it = probablyNotDefined.iterator(); it.hasNext(); ) {
        Found n = it.next();
        final GenAndTok probablyNotDefinedFirst = n.getSingle();
        IToken tok = probablyNotDefinedFirst.tok;
        String rep = tok.getRepresentation();
        // we also get a last pass to the unused to see if they might have been defined later on the higher scope
        List<Found> foundItems = find(m, rep);
        boolean setUsed = false;
        for (Found found : foundItems) {
            // the scope where it is defined must be an outer scope so that we can say it was defined later...
            final GenAndTok foundItemFirst = found.getSingle();
            if ((probablyNotDefinedFirst.scopeFound.getScopeType() & Scope.ACCEPTED_METHOD_AND_LAMBDA) != 0 && m.getScopeType() != Scope.SCOPE_TYPE_CLASS) {
                if (foundItemFirst.scopeId < probablyNotDefinedFirst.scopeId) {
                    found.setUsed(true);
                    setUsed = true;
                }
            }
        }
        if (setUsed) {
            it.remove();
        }
    }
    // point
    if (scope.size() == 0) {
        onLastScope(m);
    }
    onAfterEndScope(node, m);
}

Example 10 with IToken

use of org.python.pydev.core.IToken in project Pydev by fabioz.

the class ScopeAnalyzerVisitor method onGetCompleteTokenOccurrences.

/**
 * Called for each found occurrence in the complete token occurrences
 *
 * Is used to add other returns to ret
 */
@Override
protected void onGetCompleteTokenOccurrences(Tuple3<Found, Integer, ASTEntry> found, Set<IToken> f, ArrayList<Tuple4<IToken, Integer, ASTEntry, Found>> ret) {
    // other matches for the imports that we had already found.
    Tuple<List<Tuple4<IToken, Integer, ASTEntry, Found>>, List<Tuple4<IToken, Integer, ASTEntry, Found>>> matchingImportEntries = getImportEntries(found, f);
    List<Tuple4<IToken, Integer, ASTEntry, Found>> fromModule = matchingImportEntries.o1;
    List<Tuple4<IToken, Integer, ASTEntry, Found>> fromImports = matchingImportEntries.o2;
    ret.addAll(fromModule);
    ret.addAll(fromImports);
    // import is different from the context of that import)
    for (Tuple4<IToken, Integer, ASTEntry, Found> tuple3 : fromImports) {
        try {
            if (!(tuple3.o1 instanceof SourceToken)) {
                continue;
            }
            SourceToken tok = (SourceToken) tuple3.o1;
            SimpleNode ast = tok.getAst();
            int line = 0;
            int col = 0;
            if (!(ast instanceof Import)) {
                continue;
            }
            Import import1 = (Import) ast;
            line = import1.names[0].beginLine - 1;
            col = import1.names[0].beginColumn - 1;
            PySelection ps = new PySelection(this.document, line, col);
            ScopeAnalyzerVisitorWithoutImports analyzerVisitorWithoutImports = new ScopeAnalyzerVisitorWithoutImports(this.nature, this.moduleName, this.current, this.monitor, ps);
            SourceModule s = (SourceModule) this.current;
            s.getAst().accept(analyzerVisitorWithoutImports);
            analyzerVisitorWithoutImports.checkFinished();
            // now, let's get the token occurrences for the analyzer that worked without gathering the imports
            ArrayList<Tuple4<IToken, Integer, ASTEntry, Found>> completeTokenOccurrences = analyzerVisitorWithoutImports.getCompleteTokenOccurrences();
            for (Tuple4<IToken, Integer, ASTEntry, Found> oc : completeTokenOccurrences) {
                if (!f.contains(oc.o1) && !oc.o1.isImport()) {
                    // the import should be already added
                    if (oc.o2 < tuple3.o2) {
                        oc.o2 = tuple3.o2;
                    }
                    f.add(oc.o1);
                    ret.add(oc);
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}