pub fn parse_ty_sum(&mut self) -> PResult<'a, P<Ty>> {
        let lo = self.span.lo;
        let lhs = try!(self.parse_ty());

        if !self.eat(&token::BinOp(token::Plus)) {
            return Ok(lhs);
        }

        let bounds = try!(self.parse_ty_param_bounds(BoundParsingMode::Bare));

        // In type grammar, `+` is treated like a binary operator,
        // and hence both L and R side are required.
        if bounds.is_empty() {
            let last_span = self.last_span;
            self.span_err(last_span,
                          "at least one type parameter bound \
                          must be specified");
        }

        let sp = mk_sp(lo, self.last_span.hi);
        let sum = ast::TyKind::ObjectSum(lhs, bounds);
        Ok(P(Ty {id: ast::DUMMY_NODE_ID, node: sum, span: sp}))
    }
/// Parse a type in a context where `T1+T2` is allowed.
Parse a type in a context where `T1+T2` is allowed.
Parse a type in a context where ` T1 + T2 ` is allowed .
pub fn parse_ty_sum(&mut self) -> PResult<'a, P<Ty>> {
        let lo = self.span.lo;
        let lhs = try!(self.parse_ty());
        if !self.eat(&token::BinOp(token::Plus)) {
            return Ok(lhs);
        }
        let bounds = try!(self.parse_ty_param_bounds(BoundParsingMode::Bare));
        // In type grammar, `+` is treated like a binary operator,
        // and hence both L and R side are required.
        if bounds.is_empty() {
            let last_span = self.last_span;
            self.span_err(last_span,
                          "at least one type parameter bound \
                          must be specified");
        }
        let sp = mk_sp(lo, self.last_span.hi);
        let sum = ast::TyKind::ObjectSum(lhs, bounds);
        Ok(P(Ty {id: ast::DUMMY_NODE_ID, node: sum, span: sp}))
    }
pub fn parse_ty_sum ( & mut self ) -> PResult < ' a , P < Ty > > { let lo = self . span . lo ; let lhs = try ! ( self parse_ty ( ) ) ; if ! self . eat ( & token :: BinOp ( token :: Plus ) ) { return Ok ( lhs ) ; } let bounds = try ! ( self parse_ty_param_bounds ( BoundParsingMode Bare ) ) ; // In type grammar, `+` is treated like a binary operator, // and hence both L and R side are required. if bounds . is_empty ( ) { let last_span = self . last_span ; self . span_err ( last_span , " \
 " ) ; } let sp = mk_sp ( lo , self . last_span . hi ) ; let sum = ast :: TyKind :: ObjectSum ( lhs , bounds ) ; Ok ( P ( Ty { id : ast :: DUMMY_NODE_ID , node : sum , span : sp } ) ) }
Parse a type in a context where `T1+T2` is allowed.
Parse a type in a context where ` T1 + T2 ` is allowed .
&mut self
&mut self