Examples with Import org.python.pydev.parser.jython.ast.Import used on opensource projects

Example 1 with Import

use of org.python.pydev.parser.jython.ast.Import in project Pydev by fabioz.

the class MessagesManager method addUnusedMessage.

/**
 * adds a message for something that was not used
 *
 * @param node the node representing the scope being closed when adding the
 *             unused message
 */
public void addUnusedMessage(SimpleNode node, Found f) {
    List<GenAndTok> all = f.getAll();
    int len = all.size();
    for (int i = 0; i < len; i++) {
        GenAndTok g = all.get(i);
        if (g.generator instanceof SourceToken) {
            SimpleNode ast = ((SourceToken) g.generator).getAst();
            // it can be an unused import
            boolean isFromImport = ast instanceof ImportFrom;
            if (isFromImport || ast instanceof Import) {
                if (isFromImport && AbstractVisitor.isWildImport((ImportFrom) ast)) {
                    addMessage(IAnalysisPreferences.TYPE_UNUSED_WILD_IMPORT, g.generator, g.tok);
                } else if (!(g.generator instanceof ImportPartSourceToken)) {
                    addMessage(IAnalysisPreferences.TYPE_UNUSED_IMPORT, g.generator, g.tok);
                }
                // finish it...
                continue;
            }
        }
        // we have to check if this is a name we should ignore
        if (startsWithNamesToIgnore(g)) {
            int type = IAnalysisPreferences.TYPE_UNUSED_VARIABLE;
            if (g.tok instanceof SourceToken) {
                SourceToken t = (SourceToken) g.tok;
                SimpleNode ast = t.getAst();
                if (ast instanceof NameTok) {
                    NameTok n = (NameTok) ast;
                    if (n.ctx == NameTok.KwArg || n.ctx == NameTok.VarArg || n.ctx == NameTok.KeywordName) {
                        type = IAnalysisPreferences.TYPE_UNUSED_PARAMETER;
                    }
                } else if (ast instanceof Name) {
                    Name n = (Name) ast;
                    if (n.ctx == Name.Param || n.ctx == Name.KwOnlyParam) {
                        type = IAnalysisPreferences.TYPE_UNUSED_PARAMETER;
                    }
                }
            }
            boolean addMessage = true;
            if (type == IAnalysisPreferences.TYPE_UNUSED_PARAMETER) {
                if (node instanceof FunctionDef) {
                    addMessage = false;
                    FunctionDef def = (FunctionDef) node;
                    for (stmtType b : def.body) {
                        if (b instanceof Pass) {
                            continue;
                        }
                        if (b instanceof Expr) {
                            Expr expr = (Expr) b;
                            if (expr.value instanceof Str) {
                                continue;
                            }
                        }
                        addMessage = true;
                        break;
                    }
                }
            }
            if (addMessage) {
                addMessage(type, g.generator, g.tok);
            }
        }
    }
}

Example 2 with Import

use of org.python.pydev.parser.jython.ast.Import in project Pydev by fabioz.

the class AbstractMessage method getStartCol.

/**
 * @return the starting column for the given token (1-based)
 */
public static int getStartCol(IToken generator, IDocument doc, String shortMessage, boolean returnAsName) {
    // not import...
    if (!generator.isImport()) {
        return generator.getColDefinition();
    }
    // ok, it is an import... (can only be a source token)
    SourceToken s = (SourceToken) generator;
    SimpleNode ast = s.getAst();
    if (ast instanceof ImportFrom) {
        ImportFrom i = (ImportFrom) ast;
        // if it is a wild import, it starts on the module name
        if (AbstractVisitor.isWildImport(i)) {
            return i.module.beginColumn;
        } else {
            // no wild import, let's check the 'as name'
            return getNameForRepresentation(i, shortMessage, returnAsName).beginColumn;
        }
    } else if (ast instanceof Import) {
        return getNameForRepresentation(ast, shortMessage, returnAsName).beginColumn;
    } else {
        throw new RuntimeException("It is not an import");
    }
}

Example 3 with Import

use of org.python.pydev.parser.jython.ast.Import in project Pydev by fabioz.

the class PythonGrammar26 method import_stmt.

// import_stmt: 'import' dotted_name (',' dotted_name)* | 'from' dotted_name 'import' ('*' | NAME (',' NAME)*)
public final void import_stmt() throws ParseException {
    Import imp;
    Object spStr;
    try {
        switch((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case IMPORT:
                spStr = jj_consume_token(IMPORT);
                imp = Import();
                if (imp != null) {
                    imp.addSpecial(spStr, false);
                }
                break;
            case FROM:
                temporaryToken = grammarActions.createSpecialStr("from");
                jj_consume_token(FROM);
                grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
                ImportFrom();
                break;
            default:
                jj_la1[42] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    } catch (ParseException e) {
        handleErrorInImport(e);
    }
}

Example 4 with Import

use of org.python.pydev.parser.jython.ast.Import in project Pydev by fabioz.

the class NodeUtils method getLineEnd.

public static int getLineEnd(SimpleNode v) {
    if (v instanceof Expr) {
        Expr expr = (Expr) v;
        v = expr.value;
    }
    if (v instanceof ImportFrom) {
        ImportFrom f = (ImportFrom) v;
        FindLastLineVisitor findLastLineVisitor = new FindLastLineVisitor();
        try {
            f.accept(findLastLineVisitor);
            SimpleNode lastNode = findLastLineVisitor.getLastNode();
            ISpecialStr lastSpecialStr = findLastLineVisitor.getLastSpecialStr();
            if (lastSpecialStr != null && lastSpecialStr.toString().equals(")")) {
                // it was an from xxx import (euheon, utehon)
                return lastSpecialStr.getBeginLine();
            } else {
                return lastNode.beginLine;
            }
        } catch (Exception e) {
            Log.log(e);
        }
    }
    if (v instanceof Import) {
        Import f = (Import) v;
        FindLastLineVisitor findLastLineVisitor = new FindLastLineVisitor();
        try {
            f.accept(findLastLineVisitor);
            SimpleNode lastNode = findLastLineVisitor.getLastNode();
            return lastNode.beginLine;
        } catch (Exception e) {
            Log.log(e);
        }
    }
    if (v instanceof Str) {
        String s = ((Str) v).s;
        int found = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '\n') {
                found += 1;
            }
        }
        return getLineDefinition(v) + found;
    }
    return getLineDefinition(v);
}

Example 5 with Import

use of org.python.pydev.parser.jython.ast.Import in project Pydev by fabioz.

the class NodeUtils method getRepresentationString.

/**
 * @param node this is the node from whom we want to get the representation
 * @return A suitable String representation for some node.
 */
public static String getRepresentationString(SimpleNode node, boolean useTypeRepr) {
    if (node instanceof NameTok) {
        NameTok tok = (NameTok) node;
        return tok.id;
    }
    if (node instanceof Name) {
        Name name = (Name) node;
        return name.id;
    }
    if (node instanceof aliasType) {
        aliasType type = (aliasType) node;
        return ((NameTok) type.name).id;
    }
    if (node instanceof Attribute) {
        Attribute attribute = (Attribute) node;
        return discoverRep(attribute.attr);
    }
    if (node instanceof keywordType) {
        keywordType type = (keywordType) node;
        return discoverRep(type.arg);
    }
    if (node instanceof ClassDef) {
        ClassDef def = (ClassDef) node;
        return ((NameTok) def.name).id;
    }
    if (node instanceof FunctionDef) {
        FunctionDef def = (FunctionDef) node;
        return ((NameTok) def.name).id;
    }
    if (node instanceof Call) {
        Call call = ((Call) node);
        return getRepresentationString(call.func, useTypeRepr);
    }
    if (node instanceof org.python.pydev.parser.jython.ast.List || node instanceof ListComp) {
        String val = "[]";
        if (useTypeRepr) {
            val = getBuiltinType(val);
        }
        return val;
    }
    if (node instanceof org.python.pydev.parser.jython.ast.Dict || node instanceof org.python.pydev.parser.jython.ast.DictComp) {
        String val = "{}";
        if (useTypeRepr) {
            val = getBuiltinType(val);
        }
        return val;
    }
    if (node instanceof BinOp) {
        BinOp binOp = (BinOp) node;
        if (binOp.left instanceof Str && binOp.op == BinOp.Mod) {
            node = binOp.left;
        // Just change the node... the check below will work with the Str already.
        }
    }
    if (node instanceof Str) {
        String val;
        if (useTypeRepr) {
            val = getBuiltinType("''");
        } else {
            val = "'" + ((Str) node).s + "'";
        }
        return val;
    }
    if (node instanceof Tuple) {
        StringBuffer buf = new StringBuffer();
        Tuple t = (Tuple) node;
        for (exprType e : t.elts) {
            buf.append(getRepresentationString(e, useTypeRepr));
            buf.append(", ");
        }
        if (t.elts.length > 0) {
            int l = buf.length();
            buf.deleteCharAt(l - 1);
            buf.deleteCharAt(l - 2);
        }
        String val = "(" + buf + ")";
        if (useTypeRepr) {
            val = getBuiltinType(val);
        }
        return val;
    }
    if (node instanceof Num) {
        String val = ((Num) node).n.toString();
        if (useTypeRepr) {
            val = getBuiltinType(val);
        }
        return val;
    }
    if (node instanceof Import) {
        aliasType[] names = ((Import) node).names;
        for (aliasType n : names) {
            if (n.asname != null) {
                return ((NameTok) n.asname).id;
            }
            return ((NameTok) n.name).id;
        }
    }
    if (node instanceof commentType) {
        commentType type = (commentType) node;
        return type.id;
    }
    if (node instanceof excepthandlerType) {
        excepthandlerType type = (excepthandlerType) node;
        return type.name.toString();
    }
    return null;
}