예제 #1
0
파일: expr_to_ast.py 프로젝트: grahamc/oil
  def _TestlistComp(self, p_node, id0):
    # type: (PNode, Id_t) -> expr_t
    """
    testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] )
    """
    assert p_node.typ == grammar_nt.testlist_comp
    children = p_node.children
    n = len(children)
    if n > 1 and children[1].typ == grammar_nt.comp_for:
      elt = self.Expr(children[0])
      comp = self._CompFor(children[1])
      if id0 == Id.Op_LParen:
        return expr.GeneratorExp(elt, [comp])
      if id0 == Id.Op_LBracket:
        return expr.ListComp(elt, [comp])
      raise AssertionError()

    if id0 == Id.Op_LParen:
      if len(children) == 1:  # parenthesized expression like (x+1) or (x)
        return self.Expr(children[0])

      # (1,)  (1, 2)  etc.
      if children[1].tok.id == Id.Arith_Comma:
        return self._Tuple(children)

      raise NotImplementedError('testlist_comp')

    if id0 == Id.Op_LBracket:
      elts = []  # type: List[expr_t]
      for i in xrange(0, n, 2):  # skip commas
        elts.append(self.Expr(children[i]))

      return expr.List(elts, expr_context_e.Store)  # unused expr_context_e

    raise AssertionError(Id_str(id0))
예제 #2
0
    def _Argument(self, p_node, do_named, arglist):
        # type: (PNode, bool, arg_list) -> None
        """
    argument: (
      test [comp_for]
      # named arg
    | test '=' test
      # var args
    | '...' test
    )
    """
        positional = arglist.positional
        named = arglist.named

        assert p_node.typ == grammar_nt.argument, p_node
        children = p_node.children
        n = len(children)
        if n == 1:
            arg = self.Expr(children[0])
            positional.append(arg)
            return

        if n == 2:
            # Note: We allow multiple spreads, just like Julia.  They are
            # concatenated as in lists and dicts.
            if children[0].tok.id == Id.Expr_Ellipsis:
                spread_expr = self.Expr(children[1])
                if do_named:
                    # Implicit spread with name = None
                    named.append(named_arg(None, spread_expr))
                else:
                    positional.append(
                        expr.Spread(spread_expr, expr_context_e.Store))
                return

            if children[1].typ == grammar_nt.comp_for:
                elt = self.Expr(children[0])
                comp = self._CompFor(children[1])
                arg = expr.GeneratorExp(elt, [comp])
                positional.append(arg)
                return

            raise AssertionError()

        if n == 3:
            n1 = named_arg(children[0].tok, self.Expr(children[2]))
            named.append(n1)
            return

        raise NotImplementedError()