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

Example 11 with IToken

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

the class ScopeAnalyzerVisitorWithoutImports method getTokenOccurrences.

/**
 * @return all the token occurrences
 */
public List<IToken> getTokenOccurrences() {
    List<IToken> ret = new ArrayList<IToken>();
    List<ASTEntry> entryOccurrences = getEntryOccurrences();
    for (ASTEntry entry : entryOccurrences) {
        ret.add(AbstractVisitor.makeToken(entry.node, moduleName, nature));
    }
    return ret;
}

Example 12 with IToken

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

the class ScopeAnalyzerVisitorWithoutImports method getEntryOccurrences.

/**
 * We get the occurrences as tokens for the name we're looking for. Note that the complete name (may be a dotted name)
 * we're looking for may not be equal to the 'partial' name.
 *
 * This can happen when we're looking for some import such as os.path, and are looking just for the 'path' part.
 * So, when this happens, the return is analyzed and only returns names as the one we're looking for (with
 * the correct line and col positions).
 */
public List<ASTEntry> getEntryOccurrences() {
    checkFinished();
    Set<Tuple3<String, Integer, Integer>> s = new HashSet<Tuple3<String, Integer, Integer>>();
    ArrayList<Tuple4<IToken, Integer, ASTEntry, Found>> complete = getCompleteTokenOccurrences();
    ArrayList<ASTEntry> ret = new ArrayList<ASTEntry>();
    for (Tuple4<IToken, Integer, ASTEntry, Found> tup : complete) {
        IToken token = tup.o1;
        if (!(token instanceof SourceToken)) {
            // we want only the source tokens for this module
            continue;
        }
        // if it is different, we have to make partial names
        SourceToken sourceToken = (SourceToken) tup.o1;
        SimpleNode ast = (sourceToken).getAst();
        String representation = null;
        if (ast instanceof ImportFrom) {
            ImportFrom f = (ImportFrom) ast;
            // f.names may be empty if it is a wild import
            for (aliasType t : f.names) {
                NameTok importName = NodeUtils.getNameForAlias(t);
                String importRep = NodeUtils.getFullRepresentationString(importName);
                if (importRep.equals(nameToFind)) {
                    ast = importName;
                    representation = importRep;
                    break;
                }
            }
        } else if (ast instanceof Import) {
            representation = NodeUtils.getFullRepresentationString(ast);
            Import f = (Import) ast;
            NameTok importName = NodeUtils.getNameForRep(f.names, representation);
            if (importName != null) {
                ast = importName;
            }
        } else {
            representation = NodeUtils.getFullRepresentationString(ast);
        }
        if (representation == null) {
        // do nothing
        // can happen on wild imports
        } else if (nameToFind.equals(representation)) {
            if (ast instanceof Attribute) {
                // it can happen, as we won't go up to the part of the actual call (if there's one).
                ast = NodeUtils.getAttributeParts((Attribute) ast).get(0);
                ASTEntry entry = new ASTEntry(tup.o3, ast);
                entry.setAdditionalInfo(FOUND_ADDITIONAL_INFO_IN_AST_ENTRY, tup.o4);
                ret.add(entry);
            } else {
                ASTEntry entry = new ASTEntry(tup.o3, ast);
                entry.setAdditionalInfo(FOUND_ADDITIONAL_INFO_IN_AST_ENTRY, tup.o4);
                ret.add(entry);
            }
        } else if (FullRepIterable.containsPart(representation, nameToFind)) {
            Name nameAst = new Name(nameToFind, Name.Store, false);
            List<String> strings = StringUtils.dotSplit(representation);
            int plus = 0;
            for (String string : strings) {
                if (string.equals(nameToFind) && (plus + nameToFind.length() >= tup.o2)) {
                    break;
                }
                // len + dot
                plus += string.length() + 1;
            }
            nameAst.beginColumn = AbstractMessage.getStartCol(token, document) + plus;
            nameAst.beginLine = AbstractMessage.getStartLine(token, document);
            Tuple3<String, Integer, Integer> t = new Tuple3<String, Integer, Integer>(nameToFind, nameAst.beginColumn, nameAst.beginLine);
            if (!s.contains(t)) {
                s.add(t);
                ASTEntry entry = new ASTEntry(tup.o3, nameAst);
                entry.setAdditionalInfo(FOUND_ADDITIONAL_INFO_IN_AST_ENTRY, tup.o4);
                ret.add(entry);
            }
        }
    }
    return ret;
}

Example 13 with IToken

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

the class ScopeAnalyzerVisitorWithoutImports method getCompleteTokenOccurrences.

/**
 * @return all the occurrences found in a 'complete' way (dotted name).
 * The ASTEtries are decorated with the Found here...
 */
protected ArrayList<Tuple4<IToken, Integer, ASTEntry, Found>> getCompleteTokenOccurrences() {
    // that's because we don't want duplicates
    Set<IToken> f = new HashSet<IToken>();
    ArrayList<Tuple4<IToken, Integer, ASTEntry, Found>> ret = new ArrayList<Tuple4<IToken, Integer, ASTEntry, Found>>();
    for (Tuple3<Found, Integer, ASTEntry> found : foundOccurrences) {
        List<GenAndTok> all = found.o1.getAll();
        for (GenAndTok tok : all) {
            Tuple4<IToken, Integer, ASTEntry, Found> tup4 = new Tuple4<IToken, Integer, ASTEntry, Found>(tok.generator, found.o2, found.o3, found.o1);
            if (!f.contains(tok.generator)) {
                f.add(tok.generator);
                ret.add(tup4);
            }
            for (IToken t : tok.references) {
                tup4 = new Tuple4<IToken, Integer, ASTEntry, Found>(t, found.o2, found.o3, found.o1);
                if (!f.contains(t)) {
                    f.add(t);
                    ret.add(tup4);
                }
            }
        }
        onGetCompleteTokenOccurrences(found, f, ret);
    }
    return ret;
}

Example 14 with IToken

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

the class Scope method addImportTokens.

/**
 * Adds many tokens at once. (created by the same token)
 * Adding more than one ONLY happens for:
 * - wild imports (kind of obvious)
 * - imports such as import os.path (one token is created for os and one for os.path)
 */
public void addImportTokens(TokensList list, IToken generator, ICompletionCache completionCache) {
    ScopeItems.TryExceptInfo withinExceptNode = scope.peek().getTryExceptImportError();
    // only report undefined imports if we're not inside a try..except ImportError.
    boolean reportUndefinedImports = withinExceptNode == null;
    boolean requireTokensToBeImports = false;
    ImportInfo importInfo = null;
    if (generator != null) {
        // import)
        if (!generator.isImport()) {
            throw new RuntimeException("Only imports should generate multiple tokens " + "(it may be null for imports in the form import foo.bar, but then all its tokens must be imports).");
        }
        importInfo = importChecker.visitImportToken(generator, reportUndefinedImports, completionCache);
    } else {
        requireTokensToBeImports = true;
    }
    ScopeItems m = scope.peek();
    for (IterTokenEntry entry : list) {
        IToken o = entry.getToken();
        // System.out.println("adding: "+o.getRepresentation());
        Found found = addToken(generator, m, o, o.getRepresentation());
        if (withinExceptNode != null) {
            // may mark previous as used...
            withinExceptNode.addFoundImportToTryExcept(found);
        }
        // or a Name, ClassDef, MethodDef, etc. (in the case of wild imports)
        if (requireTokensToBeImports) {
            if (!o.isImport()) {
                throw new RuntimeException("Expecting import token");
            }
            importInfo = importChecker.visitImportToken(o, reportUndefinedImports, completionCache);
        }
        // can be either the one resolved in the wild import or in this token (if it is not a wild import)
        found.importInfo = importInfo;
        visitor.onImportInfoSetOnFound(found);
    }
}

Example 15 with IToken

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

the class CtxParticipant method getImportedNames.

/**
 * @return the names that are already imported in the current document
 */
private HashSet<String> getImportedNames(ICompletionState state) {
    TokensList tokenImportedModules = state.getTokenImportedModules();
    HashSet<String> importedNames = new HashSet<String>();
    if (tokenImportedModules != null) {
        for (IterTokenEntry entry : tokenImportedModules) {
            IToken token = entry.getToken();
            importedNames.add(token.getRepresentation());
        }
    }
    return importedNames;
}