Examples with ExtraArg org.python.pydev.parser.grammarcommon.ExtraArg used on opensource projects

Example 1 with ExtraArg

use of org.python.pydev.parser.grammarcommon.ExtraArg in project Pydev by fabioz.

the class TreeBuilder25 method makeArguments.

private argumentsType makeArguments(int l) throws Exception {
    NameTok kwarg = null;
    NameTok stararg = null;
    if (l > 0 && stack.peekNode().getId() == JJTEXTRAKEYWORDLIST) {
        ExtraArg node = (ExtraArg) stack.popNode();
        kwarg = node.tok;
        l--;
        addSpecialsAndClearOriginal(node, kwarg);
    }
    if (l > 0 && stack.peekNode().getId() == JJTEXTRAARGLIST) {
        ExtraArg node = (ExtraArg) stack.popNode();
        stararg = node.tok;
        l--;
        addSpecialsAndClearOriginal(node, stararg);
    }
    ArrayList<SimpleNode> list = new ArrayList<SimpleNode>();
    for (int i = l - 1; i >= 0; i--) {
        SimpleNode popped = stack.popNode();
        try {
            list.add(popped);
        } catch (ClassCastException e) {
            throw new ParseException("Internal error (ClassCastException):" + e.getMessage() + "\n" + popped, popped);
        }
    }
    // we get them in reverse order in the stack
    Collections.reverse(list);
    return makeArguments(list.toArray(new DefaultArg[0]), stararg, kwarg);
}

Example 2 with ExtraArg

use of org.python.pydev.parser.grammarcommon.ExtraArg in project Pydev by fabioz.

the class TreeBuilder27 method getVargAndKwarg.

NameTok[] getVargAndKwarg(java.util.List<SimpleNode> args) throws Exception {
    NameTok varg = null;
    NameTok kwarg = null;
    for (Iterator<SimpleNode> iter = args.iterator(); iter.hasNext(); ) {
        SimpleNode node = iter.next();
        if (node.getId() == JJTEXTRAKEYWORDLIST) {
            ExtraArg a = (ExtraArg) node;
            kwarg = a.tok;
            addSpecialsAndClearOriginal(a, kwarg);
        } else if (node.getId() == JJTEXTRAARGLIST) {
            ExtraArg a = (ExtraArg) node;
            varg = a.tok;
            addSpecialsAndClearOriginal(a, varg);
        }
    }
    return new NameTok[] { varg, kwarg };
}

Example 3 with ExtraArg

use of org.python.pydev.parser.grammarcommon.ExtraArg in project Pydev by fabioz.

the class TreeBuilder27 method onCloseNode.

@Override
public final SimpleNode onCloseNode(SimpleNode n, int arity) throws Exception {
    exprType value;
    exprType[] exprs;
    Suite orelseSuite;
    stmtType[] body;
    Suite suite;
    int l;
    switch(n.getId()) {
        case JJTEXPR_STMT:
            value = (exprType) stack.popNode();
            if (arity > 1) {
                exprs = makeExprs(arity - 1);
                ctx.setStore(exprs);
                return new Assign(exprs, value, null);
            } else {
                return new Expr(value);
            }
        case JJTINDEX_OP:
            sliceType slice = (sliceType) stack.popNode();
            value = (exprType) stack.popNode();
            return new Subscript(value, slice, Subscript.Load);
        case JJTPRINT_STMT:
            boolean nl = true;
            if (stack.nodeArity() == 0) {
                Print p = new Print(null, null, true);
                return p;
            }
            if (stack.peekNode().getId() == JJTCOMMA) {
                stack.popNode();
                nl = false;
            }
            Print p = new Print(null, makeExprs(), nl);
            return p;
        case JJTPRINTEXT_STMT:
            nl = true;
            if (stack.peekNode().getId() == JJTCOMMA) {
                stack.popNode();
                nl = false;
            }
            exprs = makeExprs(stack.nodeArity() - 1);
            p = new Print(((exprType) stack.popNode()), exprs, nl);
            return p;
        case JJTBEGIN_FOR_ELSE_STMT:
            return new Suite(null);
        case JJTBEGIN_ELSE_STMT:
            return new Suite(null);
        case JJTBEGIN_WHILE_STMT:
            return new While(null, null, null);
        case JJTWHILE_STMT:
            orelseSuite = null;
            if (stack.nodeArity() == 5) {
                orelseSuite = popSuiteAndSuiteType();
            }
            body = popSuite();
            exprType test = (exprType) stack.popNode();
            While w = (While) stack.popNode();
            w.test = test;
            w.body = body;
            w.orelse = orelseSuite;
            return w;
        case JJTDECORATED:
            if (stack.nodeArity() != 2) {
                throw new RuntimeException("Expected 2 nodes at this context, found: " + arity);
            }
            SimpleNode def = stack.popNode();
            Decorators decorators = (Decorators) stack.popNode();
            if (def instanceof ClassDef) {
                ClassDef classDef = (ClassDef) def;
                classDef.decs = decorators.exp;
            } else {
                FunctionDef fDef = (FunctionDef) def;
                fDef.decs = decorators.exp;
            }
            return def;
        case JJTCALL_OP:
            exprType starargs = null;
            exprType kwargs = null;
            java.util.List<exprType> args = new ArrayList<exprType>();
            java.util.List<keywordType> keywords = new ArrayList<keywordType>();
            for (int i = arity - 2; i >= 0; i--) {
                SimpleNode node = stack.popNode();
                if (node instanceof keywordType) {
                    keywords.add(0, (keywordType) node);
                } else if (node.getId() == JJTEXTRAARGVALUELIST) {
                    ExtraArgValue nstarargs = (ExtraArgValue) node;
                    starargs = nstarargs.value;
                    this.addSpecialsAndClearOriginal(nstarargs, starargs);
                } else if (node.getId() == JJTEXTRAKEYWORDVALUELIST) {
                    ExtraArgValue nkwargs = (ExtraArgValue) node;
                    kwargs = nkwargs.value;
                    this.addSpecialsAndClearOriginal(nkwargs, kwargs);
                } else if (node instanceof ComprehensionCollection) {
                    // what can happen is something like print sum(x for x in y), where we have already passed x in the args, and then get 'for x in y'
                    args.add(0, new ListComp((exprType) stack.popNode(), ((ComprehensionCollection) node).getGenerators(), ListComp.EmptyCtx));
                    // popped node
                    i--;
                } else {
                    args.add(0, (exprType) node);
                }
            }
            exprType func = (exprType) stack.popNode();
            Call c = new Call(func, args.toArray(new exprType[args.size()]), keywords.toArray(new keywordType[keywords.size()]), starargs, kwargs);
            addSpecialsAndClearOriginal(n, c);
            return c;
        case JJTFUNCDEF:
            suite = (Suite) stack.popNode();
            body = suite.body;
            argumentsType arguments = makeArguments(stack.nodeArity() - 1);
            NameTok nameTok = makeNameTok(NameTok.FunctionName);
            // decorator is always null at this point... it's decorated later on
            FunctionDef funcDef = new FunctionDef(nameTok, arguments, body, null, null, false);
            addSpecialsAndClearOriginal(suite, funcDef);
            setParentForFuncOrClass(body, funcDef);
            return funcDef;
        case JJTDEFAULTARG:
            value = (arity == 1) ? null : ((exprType) stack.popNode());
            return new DefaultArg(((exprType) stack.popNode()), value, n.getId());
        case JJTEXTRAARGLIST:
            return new ExtraArg(makeNameTok(NameTok.VarArg), JJTEXTRAARGLIST);
        case JJTEXTRAKEYWORDLIST:
            return new ExtraArg(makeNameTok(NameTok.KwArg), JJTEXTRAKEYWORDLIST);
        case JJTCLASSDEF:
            suite = (Suite) stack.popNode();
            body = suite.body;
            exprType[] bases = makeExprs(stack.nodeArity() - 1);
            nameTok = makeNameTok(NameTok.ClassName);
            ClassDef classDef = new ClassDef(nameTok, bases, body, null, null, null, null);
            addSpecialsAndClearOriginal(suite, classDef);
            setParentForFuncOrClass(body, classDef);
            return classDef;
        case JJTBEGIN_RETURN_STMT:
            return new Return(null);
        case JJTRETURN_STMT:
            value = arity == 2 ? ((exprType) stack.popNode()) : null;
            Return ret = (Return) stack.popNode();
            ret.value = value;
            return ret;
        case JJTYIELD_STMT:
            return stack.popNode();
        case JJTYIELD_EXPR:
            exprType yieldExpr = null;
            if (arity > 0) {
                // we may have an empty yield, so, we have to check it before
                yieldExpr = (exprType) stack.popNode();
            }
            return new Yield(yieldExpr, false);
        case JJTRAISE_STMT:
            exprType tback = arity >= 3 ? ((exprType) stack.popNode()) : null;
            exprType inst = arity >= 2 ? ((exprType) stack.popNode()) : null;
            exprType type = arity >= 1 ? ((exprType) stack.popNode()) : null;
            return new Raise(type, inst, tback, null);
        case JJTGLOBAL_STMT:
            Global global = new Global(makeIdentifiers(NameTok.GlobalName), null);
            return global;
        case JJTASSERT_STMT:
            exprType msg = arity == 2 ? ((exprType) stack.popNode()) : null;
            test = (exprType) stack.popNode();
            return new Assert(test, msg);
        case JJTBEGIN_TRY_STMT:
            // we do that just to get the specials
            return new TryExcept(null, null, null);
        case JJTTRYELSE_STMT:
            orelseSuite = popSuiteAndSuiteType();
            return orelseSuite;
        case JJTTRYFINALLY_OUTER_STMT:
            orelseSuite = popSuiteAndSuiteType();
            // it does not have a body at this time... it will be filled with the inner try..except
            return new TryFinally(null, orelseSuite);
        case JJTTRY_STMT:
            TryFinally outer = null;
            if (stack.peekNode() instanceof TryFinally) {
                outer = (TryFinally) stack.popNode();
                arity--;
            }
            orelseSuite = null;
            if (stack.peekNode() instanceof suiteType) {
                orelseSuite = (Suite) stack.popNode();
                arity--;
            }
            l = arity;
            excepthandlerType[] handlers = new excepthandlerType[l];
            for (int i = l - 1; i >= 0; i--) {
                handlers[i] = (excepthandlerType) stack.popNode();
            }
            suite = (Suite) stack.popNode();
            TryExcept tryExc = (TryExcept) stack.popNode();
            if (outer != null) {
                outer.beginLine = tryExc.beginLine;
            }
            tryExc.body = suite.body;
            tryExc.handlers = handlers;
            tryExc.orelse = orelseSuite;
            addSpecials(suite, tryExc);
            if (outer == null) {
                return tryExc;
            } else {
                if (outer.body != null) {
                    throw new RuntimeException("Error. Expecting null body to be filled on try..except..finally");
                }
                outer.body = new stmtType[] { tryExc };
                return outer;
            }
        case JJTBEGIN_TRY_ELSE_STMT:
            // we do that just to get the specials
            return new Suite(null);
        case JJTBEGIN_EXCEPT_CLAUSE:
            return new excepthandlerType(null, null, null);
        case JJTEXCEPT_CLAUSE:
            suite = (Suite) stack.popNode();
            body = suite.body;
            exprType excname = arity == 4 ? ((exprType) stack.popNode()) : null;
            if (excname != null) {
                ctx.setStore(excname);
            }
            type = arity >= 3 ? ((exprType) stack.popNode()) : null;
            excepthandlerType handler = (excepthandlerType) stack.popNode();
            handler.type = type;
            handler.name = excname;
            handler.body = body;
            addSpecials(suite, handler);
            return handler;
        case JJTBEGIN_FINALLY_STMT:
            // we do that just to get the specials
            return new Suite(null);
        case JJTTRYFINALLY_STMT:
            suiteType finalBody = popSuiteAndSuiteType();
            body = popSuite();
            // We have a try..except in the stack, but we will change it for a try..finally
            // This is because we recognize a try..except in the 'try:' token, but actually end up with a try..finally
            TryExcept tryExcept = (TryExcept) stack.popNode();
            TryFinally tryFinally = new TryFinally(body, finalBody);
            tryFinally.beginLine = tryExcept.beginLine;
            tryFinally.beginColumn = tryExcept.beginColumn;
            addSpecialsAndClearOriginal(tryExcept, tryFinally);
            return tryFinally;
        case JJTWITH_STMT:
            return makeWithStmt(arity);
        case JJTWITH_ITEM:
            return makeWithItem(arity);
        case JJTEXTRAKEYWORDVALUELIST:
            return new ExtraArgValue(((exprType) stack.popNode()), JJTEXTRAKEYWORDVALUELIST);
        case JJTEXTRAARGVALUELIST:
            return new ExtraArgValue(((exprType) stack.popNode()), JJTEXTRAARGVALUELIST);
        case JJTKEYWORD:
            value = (exprType) stack.popNode();
            nameTok = makeNameTok(NameTok.KeywordName);
            return new keywordType(nameTok, value, false);
        case JJTTUPLE:
            if (stack.nodeArity() > 0) {
                SimpleNode peeked = stack.peekNode();
                if (peeked instanceof ComprehensionCollection) {
                    ComprehensionCollection col = (ComprehensionCollection) stack.popNode();
                    return new ListComp(((exprType) stack.popNode()), col.getGenerators(), ListComp.TupleCtx);
                }
            }
            return makeTuple(n);
        case JJTLIST:
            if (stack.nodeArity() > 0 && stack.peekNode() instanceof ComprehensionCollection) {
                ComprehensionCollection col = (ComprehensionCollection) stack.popNode();
                return new ListComp(((exprType) stack.popNode()), col.getGenerators(), ListComp.ListCtx);
            }
            return new List(makeExprs(), List.Load);
        case JJTSET:
            return new Set(null);
        case JJTDICTIONARY:
            return makeDictionaryOrSet(arity);
        case JJTSTR_1OP:
            return new Repr(((exprType) stack.popNode()));
        case JJTTEST:
            if (arity == 2) {
                IfExp node = (IfExp) stack.popNode();
                node.body = (exprType) stack.popNode();
                return node;
            } else {
                return stack.popNode();
            }
        case JJTIF_EXP:
            exprType ifExprOrelse = (exprType) stack.popNode();
            exprType ifExprTest = (exprType) stack.popNode();
            return new IfExp(ifExprTest, null, ifExprOrelse);
        case JJTOLD_LAMBDEF:
        case JJTLAMBDEF:
            test = (exprType) stack.popNode();
            arguments = makeArguments(arity - 1);
            Lambda lambda = new Lambda(arguments, test);
            // }
            return lambda;
        case JJTELLIPSIS:
            return new Ellipsis();
        case JJTSLICE:
            SimpleNode[] arr = new SimpleNode[arity];
            for (int i = arity - 1; i >= 0; i--) {
                arr[i] = stack.popNode();
            }
            exprType[] values = new exprType[3];
            int k = 0;
            java.util.List<Object> specialsBefore = new ArrayList<Object>();
            java.util.List<Object> specialsAfter = new ArrayList<Object>();
            for (int j = 0; j < arity; j++) {
                if (arr[j].getId() == JJTCOLON) {
                    if (arr[j].specialsBefore != null) {
                        specialsBefore.addAll(arr[j].specialsBefore);
                        // this nodes may be reused among parses, so, we have to erase the specials
                        arr[j].specialsBefore.clear();
                    }
                    if (arr[j].specialsAfter != null) {
                        specialsAfter.addAll(arr[j].specialsAfter);
                        arr[j].specialsAfter.clear();
                    }
                    k++;
                } else {
                    values[k] = (exprType) arr[j];
                    if (specialsBefore.size() > 0) {
                        values[k].getSpecialsBefore().addAll(specialsBefore);
                        specialsBefore.clear();
                    }
                    if (specialsAfter.size() > 0) {
                        values[k].getSpecialsBefore().addAll(specialsAfter);
                        specialsAfter.clear();
                    }
                }
            }
            SimpleNode sliceRet;
            if (k == 0) {
                sliceRet = new Index(values[0]);
            } else {
                sliceRet = new Slice(values[0], values[1], values[2]);
            }
            // this may happen if we have no values
            sliceRet.getSpecialsBefore().addAll(specialsBefore);
            sliceRet.getSpecialsAfter().addAll(specialsAfter);
            specialsBefore.clear();
            specialsAfter.clear();
            return sliceRet;
        case JJTCOMP_FOR:
            return makeCompFor(arity);
        case JJTIMPORTFROM:
            return makeImportFrom25Onwards(arity);
        case JJTSTAR_EXPR:
            Starred starred = (Starred) n;
            starred.value = (exprType) this.stack.popNode();
            ctx.setStore(starred);
            return starred;
        default:
            Log.log(("Error at TreeBuilder: default not treated:" + n.getId()));
            return null;
    }
}

Example 4 with ExtraArg

use of org.python.pydev.parser.grammarcommon.ExtraArg in project Pydev by fabioz.

the class TreeBuilder30 method makeArguments.

private argumentsType makeArguments(int l) throws Exception {
    NameTok kwarg = null;
    NameTok stararg = null;
    exprType varargannotation = null;
    exprType kwargannotation = null;
    ArrayList<SimpleNode> list = new ArrayList<SimpleNode>();
    for (int i = l - 1; i >= 0; i--) {
        SimpleNode popped = stack.popNode();
        try {
            if (popped.getId() == JJTEXTRAKEYWORDLIST) {
                ExtraArg node = (ExtraArg) popped;
                kwarg = node.tok;
                kwargannotation = node.typeDef;
                addSpecialsAndClearOriginal(node, kwarg);
            } else if (popped.getId() == JJTEXTRAARGLIST) {
                ExtraArg node = (ExtraArg) popped;
                stararg = node.tok;
                varargannotation = node.typeDef;
                if (stararg != null) {
                    // can happen, as in 3.0 we can have a single '*'
                    addSpecialsAndClearOriginal(node, stararg);
                }
            } else {
                list.add(popped);
            }
        } catch (ClassCastException e) {
            throw new ParseException("Internal error (ClassCastException):" + e.getMessage() + "\n" + popped, popped);
        }
    }
    // we get them in reverse order in the stack
    Collections.reverse(list);
    argumentsType arguments = __makeArguments(list.toArray(new DefaultArg[0]), stararg, kwarg);
    arguments.varargannotation = varargannotation;
    arguments.kwargannotation = kwargannotation;
    return arguments;
}

Example 5 with ExtraArg

use of org.python.pydev.parser.grammarcommon.ExtraArg in project Pydev by fabioz.

the class TreeBuilder36 method makeArguments.

private argumentsType makeArguments(int l) throws Exception {
    NameTok kwarg = null;
    NameTok stararg = null;
    exprType varargannotation = null;
    exprType kwargannotation = null;
    ArrayList<SimpleNode> list = new ArrayList<SimpleNode>();
    for (int i = l - 1; i >= 0; i--) {
        SimpleNode popped = stack.popNode();
        try {
            if (popped.getId() == JJTEXTRAKEYWORDLIST) {
                ExtraArg node = (ExtraArg) popped;
                kwarg = node.tok;
                kwargannotation = node.typeDef;
                addSpecialsAndClearOriginal(node, kwarg);
            } else if (popped.getId() == JJTEXTRAARGLIST) {
                ExtraArg node = (ExtraArg) popped;
                stararg = node.tok;
                varargannotation = node.typeDef;
                if (stararg != null) {
                    // can happen, as in 3.0 we can have a single '*'
                    addSpecialsAndClearOriginal(node, stararg);
                }
            } else {
                list.add(popped);
            }
        } catch (ClassCastException e) {
            throw new ParseException("Internal error (ClassCastException):" + e.getMessage() + "\n" + popped, popped);
        }
    }
    // we get them in reverse order in the stack
    Collections.reverse(list);
    argumentsType arguments = __makeArguments(list.toArray(new DefaultArg[0]), stararg, kwarg);
    arguments.varargannotation = varargannotation;
    arguments.kwargannotation = kwargannotation;
    return arguments;
}