use crate::util::nodemap::{NodeMap, FxHashSet};
use errors::FatalError;
-use syntax_pos::{Span, DUMMY_SP, symbol::InternedString, MultiSpan};
+use syntax_pos::{Span, DUMMY_SP, MultiSpan};
use syntax::source_map::Spanned;
use syntax::ast::{self, CrateSugar, Ident, Name, NodeId, AsmDialect};
use syntax::ast::{Attribute, Label, LitKind, StrStyle, FloatTy, IntTy, UintTy};
own_counts
}
- pub fn get_named(&self, name: InternedString) -> Option<&GenericParam> {
+ pub fn get_named(&self, name: Symbol) -> Option<&GenericParam> {
for param in &self.params {
- if name == param.name.ident().as_interned_str() {
+ if name == param.name.ident().name {
return Some(param);
}
}
Some(self.span)
}
}
+
+ /// The `WhereClause` under normal circumstances points at either the predicates or the empty
+ /// space where the `where` clause should be. Only of use for diagnostic suggestions.
+ pub fn span_for_predicates_or_empty_place(&self) -> Span {
+ self.span
+ }
}
/// A single predicate in a where-clause.
Excluded,
}
+impl fmt::Display for RangeEnd {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str(match self {
+ RangeEnd::Included => "..=",
+ RangeEnd::Excluded => "..",
+ })
+ }
+}
+
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum PatKind {
/// Represents a wildcard pattern (i.e., `_`).
MutImmutable => MutMutable,
}
}
+
+ pub fn prefix_str(&self) -> &'static str {
+ match self {
+ MutMutable => "mut ",
+ MutImmutable => "",
+ }
+ }
}
-#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Hash, HashStable)]
+#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum BinOpKind {
/// The `+` operator (addition).
Add,
pub type BinOp = Spanned<BinOpKind>;
-#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Hash, HashStable)]
+#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum UnOp {
/// The `*` operator (deferencing).
UnDeref,
}
/// The type of source expression that caused this generator to be created.
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, HashStable,
- RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
+#[derive(Clone, PartialEq, Eq, HashStable, RustcEncodable, RustcDecodable, Debug, Copy)]
pub enum GeneratorKind {
/// An explicit `async` block or the body of an async function.
Async(AsyncGeneratorKind),
///
/// This helps error messages but is also used to drive coercions in
/// type-checking (see #60424).
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, HashStable,
- RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
+#[derive(Clone, PartialEq, Eq, HashStable, RustcEncodable, RustcDecodable, Debug, Copy)]
pub enum AsyncGeneratorKind {
/// An explicit `async` block written by the user.
Block,
Normal,
}
+impl Unsafety {
+ pub fn prefix_str(&self) -> &'static str {
+ match self {
+ Unsafety::Unsafe => "unsafe ",
+ Unsafety::Normal => "",
+ }
+ }
+}
+
#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum Constness {
Const,
Fn(P<FnDecl>, FnHeader, Generics, BodyId),
/// A module.
Mod(Mod),
- /// An external module.
+ /// An external module, e.g. `extern { .. }`.
ForeignMod(ForeignMod),
/// Module-level inline assembly (from `global_asm!`).
GlobalAsm(P<GlobalAsm>),
/// `#[used]`: indicates that LLVM can't eliminate this function (but the
/// linker can!).
const USED = 1 << 9;
- /// #[ffi_returns_twice], indicates that an extern function can return
+ /// `#[ffi_returns_twice]`, indicates that an extern function can return
/// multiple times
const FFI_RETURNS_TWICE = 1 << 10;
- /// #[track_caller]: allow access to the caller location
+ /// `#[track_caller]`: allow access to the caller location
const TRACK_CALLER = 1 << 11;
}
}