impl<'a, 'tcx, 'v> Visitor<'v> for ImproperCTypesVisitor<'a, 'tcx> {
fn visit_ty(&mut self, ty: &ast::Ty) {
match ty.node {
- ast::TyPath(_, _, id) => self.check_def(ty.span, ty.id, id),
+ ast::TyPath(_, id) => self.check_def(ty.span, ty.id, id),
_ => (),
}
visit::walk_ty(self, ty);
encode_name(rbml_w, item.ident.name);
encode_attributes(rbml_w, item.attrs.as_slice());
match ty.node {
- ast::TyPath(ref path, ref bounds, _) if path.segments
+ ast::TyPath(ref path, _) if path.segments
.len() == 1 => {
let ident = path.segments.last().unwrap().identifier;
- assert!(bounds.is_none());
encode_impl_type_basename(rbml_w, ident);
}
_ => {}
// * Private trait impls for private types can be completely ignored
ast::ItemImpl(_, _, ref ty, ref impl_items) => {
let public_ty = match ty.node {
- ast::TyPath(_, _, id) => {
+ ast::TyPath(_, id) => {
match self.tcx.def_map.borrow()[id].clone() {
def::DefPrimTy(..) => true,
def => {
ast::ItemTy(ref ty, _) if public_first => {
match ty.node {
- ast::TyPath(_, _, id) => {
+ ast::TyPath(_, id) => {
match self.tcx.def_map.borrow()[id].clone() {
def::DefPrimTy(..) | def::DefTyParam(..) => {},
def => {
// was private.
ast::ItemImpl(_, _, ref ty, _) => {
let id = match ty.node {
- ast::TyPath(_, _, id) => id,
+ ast::TyPath(_, id) => id,
_ => return Some((err_span, err_msg, None)),
};
let def = self.tcx.def_map.borrow()[id].clone();
impl<'a, 'b, 'tcx, 'v> Visitor<'v> for CheckTypeForPrivatenessVisitor<'a, 'b, 'tcx> {
fn visit_ty(&mut self, ty: &ast::Ty) {
match ty.node {
- ast::TyPath(_, _, path_id) => {
+ ast::TyPath(_, path_id) => {
if self.inner.path_is_private_type(path_id) {
self.contains_private = true;
// found what we're looking for so let's stop
fn visit_ty(&mut self, t: &ast::Ty) {
match t.node {
- ast::TyPath(ref p, _, path_id) => {
+ ast::TyPath(ref p, path_id) => {
if !self.tcx.sess.features.borrow().visible_private_types &&
self.path_is_private_type(path_id) {
self.tcx.sess.span_err(p.span,
use syntax::ast::{RegionTyParamBound, StmtDecl, StructField};
use syntax::ast::{StructVariantKind, TraitRef, TraitTyParamBound};
use syntax::ast::{TupleVariantKind, Ty, TyBool, TyChar, TyClosure, TyF32};
-use syntax::ast::{TyF64, TyFloat, TyI, TyI8, TyI16, TyI32, TyI64, TyInt};
+use syntax::ast::{TyF64, TyFloat, TyI, TyI8, TyI16, TyI32, TyI64, TyInt, TyObjectSum};
use syntax::ast::{TyParam, TyParamBound, TyPath, TyPtr, TyPolyTraitRef, TyProc, TyQPath};
use syntax::ast::{TyRptr, TyStr, TyU, TyU8, TyU16, TyU32, TyU64, TyUint};
use syntax::ast::{TypeImplItem, UnnamedField};
// type, the result will be that the type name resolves to a module but not
// a type (shadowing any imported modules or types with this name), leading
// to weird user-visible bugs. So we ward this off here. See #15060.
- TyPath(ref path, _, path_id) => {
+ TyPath(ref path, path_id) => {
match self.def_map.borrow().get(&path_id) {
// FIXME: should we catch other options and give more precise errors?
Some(&DefMod(_)) => {
// Like path expressions, the interpretation of path types depends
// on whether the path has multiple elements in it or not.
- TyPath(ref path, ref bounds, path_id) => {
+ TyPath(ref path, path_id) => {
// This is a path in the type namespace. Walk through scopes
// looking for it.
let mut result_def = None;
self.resolve_error(ty.span, msg.as_slice());
}
}
+ }
- bounds.as_ref().map(|bound_vec| {
- self.resolve_type_parameter_bounds(ty.id, bound_vec,
+ TyObjectSum(ref ty, ref bound_vec) => {
+ self.resolve_type(&**ty);
+ self.resolve_type_parameter_bounds(ty.id, bound_vec,
TraitBoundingTypeParameter);
- });
}
TyQPath(ref qpath) => {
fn extract_path_and_node_id(t: &Ty, allow: FallbackChecks)
-> Option<(Path, NodeId, FallbackChecks)> {
match t.node {
- TyPath(ref path, _, node_id) => Some((path.clone(), node_id, allow)),
+ TyPath(ref path, node_id) => Some((path.clone(), node_id, allow)),
TyPtr(ref mut_ty) => extract_path_and_node_id(&*mut_ty.ty, OnlyTraitAndStatics),
TyRptr(_, ref mut_ty) => extract_path_and_node_id(&*mut_ty.ty, allow),
// This doesn't handle the remaining `Ty` variants as they are not
visit::walk_ty(this, ty);
});
}
- ast::TyPath(ref path, ref opt_bounds, id) => {
+ ast::TyPath(ref path, id) => {
// if this path references a trait, then this will resolve to
// a trait ref, which introduces a binding scope.
match self.def_map.borrow().get(&id) {
self.with(LateScope(&Vec::new(), self.scope), |this| {
this.visit_path(path, id);
});
-
- match *opt_bounds {
- Some(ref bounds) => {
- visit::walk_ty_param_bounds_helper(self, bounds);
- }
- None => { }
- }
}
_ => {
visit::walk_ty(self, ty);
}
ty_queue.push(&*mut_ty.ty);
}
- ast::TyPath(ref path, ref bounds, id) => {
+ ast::TyPath(ref path, id) => {
let a_def = match self.tcx.def_map.borrow().get(&id) {
None => {
self.tcx
let new_path = self.rebuild_path(rebuild_info, lifetime);
let to = ast::Ty {
id: cur_ty.id,
- node: ast::TyPath(new_path, bounds.clone(), id),
+ node: ast::TyPath(new_path, id),
span: cur_ty.span
};
new_ty = self.rebuild_ty(new_ty, P(to));
typ: &ast::Ty,
impl_items: &Vec<ast::ImplItem>) {
match typ.node {
- ast::TyPath(ref path, _, id) => {
+ ast::TyPath(ref path, id) => {
match self.lookup_type_ref(id) {
Some(id) => {
let sub_span = self.span.sub_span_for_type_name(path.span);
}
match t.node {
- ast::TyPath(ref path, _, id) => {
+ ast::TyPath(ref path, id) => {
match self.lookup_type_ref(id) {
Some(id) => {
let sub_span = self.span.sub_span_for_type_name(t.span);
fn visit_ty(&mut self, typ: &Ty) {
self.operation.visit_id(typ.id);
match typ.node {
- TyPath(_, _, id) => self.operation.visit_id(id),
+ TyPath(_, id) => self.operation.visit_id(id),
_ => {}
}
visit::walk_ty(self, typ)
fn ty_mt(&self, ty: P<ast::Ty>, mutbl: ast::Mutability) -> ast::MutTy;
fn ty(&self, span: Span, ty: ast::Ty_) -> P<ast::Ty>;
- fn ty_path(&self, ast::Path, Option<OwnedSlice<ast::TyParamBound>>) -> P<ast::Ty>;
+ fn ty_path(&self, ast::Path) -> P<ast::Ty>;
+ fn ty_sum(&self, ast::Path, OwnedSlice<ast::TyParamBound>) -> P<ast::Ty>;
fn ty_ident(&self, span: Span, idents: ast::Ident) -> P<ast::Ty>;
fn ty_rptr(&self, span: Span,
})
}
- fn ty_path(&self, path: ast::Path, bounds: Option<OwnedSlice<ast::TyParamBound>>)
- -> P<ast::Ty> {
+ fn ty_path(&self, path: ast::Path) -> P<ast::Ty> {
+ self.ty(path.span, ast::TyPath(path, ast::DUMMY_NODE_ID))
+ }
+
+ fn ty_sum(&self, path: ast::Path, bounds: OwnedSlice<ast::TyParamBound>) -> P<ast::Ty> {
self.ty(path.span,
- ast::TyPath(path, bounds, ast::DUMMY_NODE_ID))
+ ast::TyObjectSum(self.ty_path(path),
+ bounds))
}
// Might need to take bounds as an argument in the future, if you ever want
// to generate a bounded existential trait type.
fn ty_ident(&self, span: Span, ident: ast::Ident)
-> P<ast::Ty> {
- self.ty_path(self.path_ident(span, ident), None)
+ self.ty_path(self.path_ident(span, ident))
}
fn ty_rptr(&self,
self.ident_of("Option")
),
Vec::new(),
- vec!( ty )), None)
+ vec!( ty )))
}
fn ty_field_imm(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::TypeField {
}
fn ty_vars_global(&self, ty_params: &OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> {
- ty_params.iter().map(|p| self.ty_path(
- self.path_global(DUMMY_SP, vec!(p.ident)), None)).collect()
+ ty_params
+ .iter()
+ .map(|p| self.ty_path(self.path_global(DUMMY_SP, vec!(p.ident))))
+ .collect()
}
fn trait_ref(&self, path: ast::Path) -> ast::TraitRef {
// Create the type of `self`.
let self_type = cx.ty_path(
cx.path_all(self.span, false, vec!( type_ident ), self_lifetimes,
- self_ty_params.into_vec()), None);
+ self_ty_params.into_vec()));
let attr = cx.attribute(
self.span,
self_ty: Ident,
self_generics: &Generics)
-> P<ast::Ty> {
- cx.ty_path(self.to_path(cx, span, self_ty, self_generics), None)
+ cx.ty_path(self.to_path(cx, span, self_ty, self_generics))
}
pub fn to_path(&self,
cx: &ExtCtxt,
}
Literal(ref p) => { p.to_ty(cx, span, self_ty, self_generics) }
Self => {
- cx.ty_path(self.to_path(cx, span, self_ty, self_generics), None)
+ cx.ty_path(self.to_path(cx, span, self_ty, self_generics))
}
Tuple(ref fields) => {
let ty = ast::TyTup(fields.iter()
true, Context::rtpath(self.ecx, "Argument"),
vec![static_lifetime],
vec![]
- ), None);
+ ));
lets.push(Context::item_static_array(self.ecx,
static_args_name,
piece_ty,
"stmt" => token::NtStmt(p.parse_stmt(Vec::new())),
"pat" => token::NtPat(p.parse_pat()),
"expr" => token::NtExpr(p.parse_expr()),
- "ty" => token::NtTy(p.parse_ty(false /* no need to disambiguate*/)),
+ "ty" => token::NtTy(p.parse_ty()),
// this could be handled like a token, since it is one
"ident" => match p.token {
token::Ident(sn,b) => { p.bump(); token::NtIdent(box sn,b) }
}
},
"path" => {
- token::NtPath(box p.parse_path(LifetimeAndTypesWithoutColons).path)
+ token::NtPath(box p.parse_path(LifetimeAndTypesWithoutColons))
}
"meta" => token::NtMeta(p.parse_meta_item()),
"tt" => {
}
TyTup(tys) => TyTup(tys.move_map(|ty| fld.fold_ty(ty))),
TyParen(ty) => TyParen(fld.fold_ty(ty)),
- TyPath(path, bounds, id) => {
+ TyPath(path, id) => {
let id = fld.new_id(id);
- TyPath(fld.fold_path(path),
- fld.fold_opt_bounds(bounds),
- id)
+ TyPath(fld.fold_path(path), id)
+ }
+ TyObjectSum(ty, bounds) => {
+ TyObjectSum(fld.fold_ty(ty),
+ fld.fold_bounds(bounds))
}
TyQPath(qpath) => {
TyQPath(fld.fold_qpath(qpath))
self.print_expr(coll)
}
- fn print_path_(&mut self,
- path: &ast::Path,
- colons_before_params: bool,
- opt_bounds: &Option<OwnedSlice<ast::TyParamBound>>)
- -> IoResult<()> {
+ fn print_path(&mut self,
+ path: &ast::Path,
+ colons_before_params: bool)
+ -> IoResult<()>
+ {
try!(self.maybe_print_comment(path.span.lo));
if path.global {
try!(word(&mut self.s, "::"));
try!(self.print_path_parameters(&segment.parameters, colons_before_params));
}
- match *opt_bounds {
- None => Ok(()),
- Some(ref bounds) => self.print_bounds("+", bounds)
- }
+ Ok(())
}
fn print_path_parameters(&mut self,
Ok(())
}
- fn print_path(&mut self, path: &ast::Path,
- colons_before_params: bool) -> IoResult<()> {
- self.print_path_(path, colons_before_params, &None)
- }
-
- fn print_bounded_path(&mut self, path: &ast::Path,
- bounds: &Option<OwnedSlice<ast::TyParamBound>>)
- -> IoResult<()> {
- self.print_path_(path, false, bounds)
- }
-
pub fn print_pat(&mut self, pat: &ast::Pat) -> IoResult<()> {
try!(self.maybe_print_comment(pat.span.lo));
try!(self.ann.pre(self, NodePat(pat)));
let ecx = &cx.ext_cx;
let struct_type = ecx.ty_path(ecx.path(sp, vec![ecx.ident_of("self"),
ecx.ident_of("test"),
- ecx.ident_of("TestDescAndFn")]),
- None);
+ ecx.ident_of("TestDescAndFn")]));
let static_lt = ecx.lifetime(sp, token::special_idents::static_lifetime.name);
// &'static [self::test::TestDescAndFn]
let static_type = ecx.ty_rptr(sp,
walk_fn_ret_ty(visitor, &function_declaration.decl.output);
walk_lifetime_decls_helper(visitor, &function_declaration.lifetimes);
}
- TyPath(ref path, ref opt_bounds, id) => {
+ TyPath(ref path, id) => {
visitor.visit_path(path, id);
- match *opt_bounds {
- Some(ref bounds) => {
- walk_ty_param_bounds_helper(visitor, bounds);
- }
- None => { }
- }
+ }
+ TyObjectSum(ref ty, ref bounds) => {
+ visitor.visit_ty(&**ty);
+ walk_ty_param_bounds_helper(visitor, bounds);
}
TyQPath(ref qpath) => {
visitor.visit_ty(&*qpath.self_type);