crates/proc-macro-srv/src/abis/abi_1_63/rustc_server.rs

   1 //! Rustc proc-macro server implementation with tt
   2 //!
   3 //! Based on idea from <https://github.com/fedochet/rust-proc-macro-expander>
   4 //! The lib-proc-macro server backend is `TokenStream`-agnostic, such that
   5 //! we could provide any TokenStream implementation.
   6 //! The original idea from fedochet is using proc-macro2 as backend,
   7 //! we use tt instead for better integration with RA.
   8 //!
   9 //! FIXME: No span and source file information is implemented yet
  10
  11 use super::proc_macro::bridge::{self, server};
  12
  13 use std::collections::HashMap;
  14 use std::hash::Hash;
  15 use std::iter::FromIterator;
  16 use std::ops::Bound;
  17 use std::{ascii, vec::IntoIter};
  18
  19 type Group = tt::Subtree;
  20 type TokenTree = tt::TokenTree;
  21 type Punct = tt::Punct;
  22 type Spacing = tt::Spacing;
  23 type Literal = tt::Literal;
  24 type Span = tt::TokenId;
  25
  26 #[derive(Debug, Default, Clone)]
  27 pub struct TokenStream {
  28     pub token_trees: Vec<TokenTree>,
  29 }
  30
  31 impl TokenStream {
  32     pub fn new() -> Self {
  33         TokenStream::default()
  34     }
  35
  36     pub fn with_subtree(subtree: tt::Subtree) -> Self {
  37         if subtree.delimiter.is_some() {
  38             TokenStream { token_trees: vec![TokenTree::Subtree(subtree)] }
  39         } else {
  40             TokenStream { token_trees: subtree.token_trees }
  41         }
  42     }
  43
  44     pub fn into_subtree(self) -> tt::Subtree {
  45         tt::Subtree { delimiter: None, token_trees: self.token_trees }
  46     }
  47
  48     pub fn is_empty(&self) -> bool {
  49         self.token_trees.is_empty()
  50     }
  51 }
  52
  53 /// Creates a token stream containing a single token tree.
  54 impl From<TokenTree> for TokenStream {
  55     fn from(tree: TokenTree) -> TokenStream {
  56         TokenStream { token_trees: vec![tree] }
  57     }
  58 }
  59
  60 /// Collects a number of token trees into a single stream.
  61 impl FromIterator<TokenTree> for TokenStream {
  62     fn from_iter<I: IntoIterator<Item = TokenTree>>(trees: I) -> Self {
  63         trees.into_iter().map(TokenStream::from).collect()
  64     }
  65 }
  66
  67 /// A "flattening" operation on token streams, collects token trees
  68 /// from multiple token streams into a single stream.
  69 impl FromIterator<TokenStream> for TokenStream {
  70     fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
  71         let mut builder = TokenStreamBuilder::new();
  72         streams.into_iter().for_each(|stream| builder.push(stream));
  73         builder.build()
  74     }
  75 }
  76
  77 impl Extend<TokenTree> for TokenStream {
  78     fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, trees: I) {
  79         self.extend(trees.into_iter().map(TokenStream::from));
  80     }
  81 }
  82
  83 impl Extend<TokenStream> for TokenStream {
  84     fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
  85         for item in streams {
  86             for tkn in item {
  87                 match tkn {
  88                     tt::TokenTree::Subtree(subtree) if subtree.delimiter.is_none() => {
  89                         self.token_trees.extend(subtree.token_trees);
  90                     }
  91                     _ => {
  92                         self.token_trees.push(tkn);
  93                     }
  94                 }
  95             }
  96         }
  97     }
  98 }
  99
 100 #[derive(Clone)]
 101 pub struct SourceFile {
 102     // FIXME stub
 103 }
 104
 105 type Level = super::proc_macro::Level;
 106 type LineColumn = super::proc_macro::LineColumn;
 107
 108 /// A structure representing a diagnostic message and associated children
 109 /// messages.
 110 #[derive(Clone, Debug)]
 111 pub struct Diagnostic {
 112     level: Level,
 113     message: String,
 114     spans: Vec<Span>,
 115     children: Vec<Diagnostic>,
 116 }
 117
 118 impl Diagnostic {
 119     /// Creates a new diagnostic with the given `level` and `message`.
 120     pub fn new<T: Into<String>>(level: Level, message: T) -> Diagnostic {
 121         Diagnostic { level, message: message.into(), spans: vec![], children: vec![] }
 122     }
 123 }
 124
 125 // Rustc Server Ident has to be `Copyable`
 126 // We use a stub here for bypassing
 127 #[derive(Hash, Eq, PartialEq, Copy, Clone)]
 128 pub struct IdentId(u32);
 129
 130 #[derive(Clone, Hash, Eq, PartialEq)]
 131 struct IdentData(tt::Ident);
 132
 133 #[derive(Default)]
 134 struct IdentInterner {
 135     idents: HashMap<IdentData, u32>,
 136     ident_data: Vec<IdentData>,
 137 }
 138
 139 impl IdentInterner {
 140     fn intern(&mut self, data: &IdentData) -> u32 {
 141         if let Some(index) = self.idents.get(data) {
 142             return *index;
 143         }
 144
 145         let index = self.idents.len() as u32;
 146         self.ident_data.push(data.clone());
 147         self.idents.insert(data.clone(), index);
 148         index
 149     }
 150
 151     fn get(&self, index: u32) -> &IdentData {
 152         &self.ident_data[index as usize]
 153     }
 154
 155     #[allow(unused)]
 156     fn get_mut(&mut self, index: u32) -> &mut IdentData {
 157         self.ident_data.get_mut(index as usize).expect("Should be consistent")
 158     }
 159 }
 160
 161 pub struct TokenStreamBuilder {
 162     acc: TokenStream,
 163 }
 164
 165 /// Public implementation details for the `TokenStream` type, such as iterators.
 166 pub mod token_stream {
 167     use std::str::FromStr;
 168
 169     use super::{TokenStream, TokenTree};
 170
 171     /// An iterator over `TokenStream`'s `TokenTree`s.
 172     /// The iteration is "shallow", e.g., the iterator doesn't recurse into delimited groups,
 173     /// and returns whole groups as token trees.
 174     impl IntoIterator for TokenStream {
 175         type Item = TokenTree;
 176         type IntoIter = super::IntoIter<TokenTree>;
 177
 178         fn into_iter(self) -> Self::IntoIter {
 179             self.token_trees.into_iter()
 180         }
 181     }
 182
 183     type LexError = String;
 184
 185     /// Attempts to break the string into tokens and parse those tokens into a token stream.
 186     /// May fail for a number of reasons, for example, if the string contains unbalanced delimiters
 187     /// or characters not existing in the language.
 188     /// All tokens in the parsed stream get `Span::call_site()` spans.
 189     ///
 190     /// NOTE: some errors may cause panics instead of returning `LexError`. We reserve the right to
 191     /// change these errors into `LexError`s later.
 192     impl FromStr for TokenStream {
 193         type Err = LexError;
 194
 195         fn from_str(src: &str) -> Result<TokenStream, LexError> {
 196             let (subtree, _token_map) =
 197                 mbe::parse_to_token_tree(src).ok_or("Failed to parse from mbe")?;
 198
 199             let subtree = subtree_replace_token_ids_with_unspecified(subtree);
 200             Ok(TokenStream::with_subtree(subtree))
 201         }
 202     }
 203
 204     impl ToString for TokenStream {
 205         fn to_string(&self) -> String {
 206             tt::pretty(&self.token_trees)
 207         }
 208     }
 209
 210     fn subtree_replace_token_ids_with_unspecified(subtree: tt::Subtree) -> tt::Subtree {
 211         tt::Subtree {
 212             delimiter: subtree
 213                 .delimiter
 214                 .map(|d| tt::Delimiter { id: tt::TokenId::unspecified(), ..d }),
 215             token_trees: subtree
 216                 .token_trees
 217                 .into_iter()
 218                 .map(token_tree_replace_token_ids_with_unspecified)
 219                 .collect(),
 220         }
 221     }
 222
 223     fn token_tree_replace_token_ids_with_unspecified(tt: tt::TokenTree) -> tt::TokenTree {
 224         match tt {
 225             tt::TokenTree::Leaf(leaf) => {
 226                 tt::TokenTree::Leaf(leaf_replace_token_ids_with_unspecified(leaf))
 227             }
 228             tt::TokenTree::Subtree(subtree) => {
 229                 tt::TokenTree::Subtree(subtree_replace_token_ids_with_unspecified(subtree))
 230             }
 231         }
 232     }
 233
 234     fn leaf_replace_token_ids_with_unspecified(leaf: tt::Leaf) -> tt::Leaf {
 235         match leaf {
 236             tt::Leaf::Literal(lit) => {
 237                 tt::Leaf::Literal(tt::Literal { id: tt::TokenId::unspecified(), ..lit })
 238             }
 239             tt::Leaf::Punct(punct) => {
 240                 tt::Leaf::Punct(tt::Punct { id: tt::TokenId::unspecified(), ..punct })
 241             }
 242             tt::Leaf::Ident(ident) => {
 243                 tt::Leaf::Ident(tt::Ident { id: tt::TokenId::unspecified(), ..ident })
 244             }
 245         }
 246     }
 247 }
 248
 249 impl TokenStreamBuilder {
 250     fn new() -> TokenStreamBuilder {
 251         TokenStreamBuilder { acc: TokenStream::new() }
 252     }
 253
 254     fn push(&mut self, stream: TokenStream) {
 255         self.acc.extend(stream.into_iter())
 256     }
 257
 258     fn build(self) -> TokenStream {
 259         self.acc
 260     }
 261 }
 262
 263 pub struct FreeFunctions;
 264
 265 #[derive(Clone)]
 266 pub struct TokenStreamIter {
 267     trees: IntoIter<TokenTree>,
 268 }
 269
 270 #[derive(Default)]
 271 pub struct Rustc {
 272     ident_interner: IdentInterner,
 273     // FIXME: store span information here.
 274 }
 275
 276 impl server::Types for Rustc {
 277     type FreeFunctions = FreeFunctions;
 278     type TokenStream = TokenStream;
 279     type Group = Group;
 280     type Punct = Punct;
 281     type Ident = IdentId;
 282     type Literal = Literal;
 283     type SourceFile = SourceFile;
 284     type Diagnostic = Diagnostic;
 285     type Span = Span;
 286     type MultiSpan = Vec<Span>;
 287 }
 288
 289 impl server::FreeFunctions for Rustc {
 290     fn track_env_var(&mut self, _var: &str, _value: Option<&str>) {
 291         // FIXME: track env var accesses
 292         // https://github.com/rust-lang/rust/pull/71858
 293     }
 294     fn track_path(&mut self, _path: &str) {}
 295 }
 296
 297 impl server::TokenStream for Rustc {
 298     fn is_empty(&mut self, stream: &Self::TokenStream) -> bool {
 299         stream.is_empty()
 300     }
 301     fn from_str(&mut self, src: &str) -> Self::TokenStream {
 302         use std::str::FromStr;
 303
 304         Self::TokenStream::from_str(src).expect("cannot parse string")
 305     }
 306     fn to_string(&mut self, stream: &Self::TokenStream) -> String {
 307         stream.to_string()
 308     }
 309     fn from_token_tree(
 310         &mut self,
 311         tree: bridge::TokenTree<Self::Group, Self::Punct, Self::Ident, Self::Literal>,
 312     ) -> Self::TokenStream {
 313         match tree {
 314             bridge::TokenTree::Group(group) => {
 315                 let tree = TokenTree::from(group);
 316                 Self::TokenStream::from_iter(vec![tree])
 317             }
 318
 319             bridge::TokenTree::Ident(IdentId(index)) => {
 320                 let IdentData(ident) = self.ident_interner.get(index).clone();
 321                 let ident: tt::Ident = ident;
 322                 let leaf = tt::Leaf::from(ident);
 323                 let tree = TokenTree::from(leaf);
 324                 Self::TokenStream::from_iter(vec![tree])
 325             }
 326
 327             bridge::TokenTree::Literal(literal) => {
 328                 let leaf = tt::Leaf::from(literal);
 329                 let tree = TokenTree::from(leaf);
 330                 Self::TokenStream::from_iter(vec![tree])
 331             }
 332
 333             bridge::TokenTree::Punct(p) => {
 334                 let leaf = tt::Leaf::from(p);
 335                 let tree = TokenTree::from(leaf);
 336                 Self::TokenStream::from_iter(vec![tree])
 337             }
 338         }
 339     }
 340
 341     fn expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
 342         Ok(self_.clone())
 343     }
 344
 345     fn concat_trees(
 346         &mut self,
 347         base: Option<Self::TokenStream>,
 348         trees: Vec<bridge::TokenTree<Self::Group, Self::Punct, Self::Ident, Self::Literal>>,
 349     ) -> Self::TokenStream {
 350         let mut builder = TokenStreamBuilder::new();
 351         if let Some(base) = base {
 352             builder.push(base);
 353         }
 354         for tree in trees {
 355             builder.push(self.from_token_tree(tree));
 356         }
 357         builder.build()
 358     }
 359
 360     fn concat_streams(
 361         &mut self,
 362         base: Option<Self::TokenStream>,
 363         streams: Vec<Self::TokenStream>,
 364     ) -> Self::TokenStream {
 365         let mut builder = TokenStreamBuilder::new();
 366         if let Some(base) = base {
 367             builder.push(base);
 368         }
 369         for stream in streams {
 370             builder.push(stream);
 371         }
 372         builder.build()
 373     }
 374
 375     fn into_trees(
 376         &mut self,
 377         stream: Self::TokenStream,
 378     ) -> Vec<bridge::TokenTree<Self::Group, Self::Punct, Self::Ident, Self::Literal>> {
 379         stream
 380             .into_iter()
 381             .map(|tree| match tree {
 382                 tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
 383                     bridge::TokenTree::Ident(IdentId(self.ident_interner.intern(&IdentData(ident))))
 384                 }
 385                 tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) => bridge::TokenTree::Literal(lit),
 386                 tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) => bridge::TokenTree::Punct(punct),
 387                 tt::TokenTree::Subtree(subtree) => bridge::TokenTree::Group(subtree),
 388             })
 389             .collect()
 390     }
 391 }
 392
 393 fn delim_to_internal(d: bridge::Delimiter) -> Option<tt::Delimiter> {
 394     let kind = match d {
 395         bridge::Delimiter::Parenthesis => tt::DelimiterKind::Parenthesis,
 396         bridge::Delimiter::Brace => tt::DelimiterKind::Brace,
 397         bridge::Delimiter::Bracket => tt::DelimiterKind::Bracket,
 398         bridge::Delimiter::None => return None,
 399     };
 400     Some(tt::Delimiter { id: tt::TokenId::unspecified(), kind })
 401 }
 402
 403 fn delim_to_external(d: Option<tt::Delimiter>) -> bridge::Delimiter {
 404     match d.map(|it| it.kind) {
 405         Some(tt::DelimiterKind::Parenthesis) => bridge::Delimiter::Parenthesis,
 406         Some(tt::DelimiterKind::Brace) => bridge::Delimiter::Brace,
 407         Some(tt::DelimiterKind::Bracket) => bridge::Delimiter::Bracket,
 408         None => bridge::Delimiter::None,
 409     }
 410 }
 411
 412 fn spacing_to_internal(spacing: bridge::Spacing) -> Spacing {
 413     match spacing {
 414         bridge::Spacing::Alone => Spacing::Alone,
 415         bridge::Spacing::Joint => Spacing::Joint,
 416     }
 417 }
 418
 419 fn spacing_to_external(spacing: Spacing) -> bridge::Spacing {
 420     match spacing {
 421         Spacing::Alone => bridge::Spacing::Alone,
 422         Spacing::Joint => bridge::Spacing::Joint,
 423     }
 424 }
 425
 426 impl server::Group for Rustc {
 427     fn new(
 428         &mut self,
 429         delimiter: bridge::Delimiter,
 430         stream: Option<Self::TokenStream>,
 431     ) -> Self::Group {
 432         Self::Group {
 433             delimiter: delim_to_internal(delimiter),
 434             token_trees: stream.unwrap_or_default().token_trees,
 435         }
 436     }
 437     fn delimiter(&mut self, group: &Self::Group) -> bridge::Delimiter {
 438         delim_to_external(group.delimiter)
 439     }
 440
 441     // NOTE: Return value of do not include delimiter
 442     fn stream(&mut self, group: &Self::Group) -> Self::TokenStream {
 443         TokenStream { token_trees: group.token_trees.clone() }
 444     }
 445
 446     fn span(&mut self, group: &Self::Group) -> Self::Span {
 447         group.delimiter.map(|it| it.id).unwrap_or_else(tt::TokenId::unspecified)
 448     }
 449
 450     fn set_span(&mut self, group: &mut Self::Group, span: Self::Span) {
 451         if let Some(delim) = &mut group.delimiter {
 452             delim.id = span;
 453         }
 454     }
 455
 456     fn span_open(&mut self, group: &Self::Group) -> Self::Span {
 457         // FIXME we only store one `TokenId` for the delimiters
 458         group.delimiter.map(|it| it.id).unwrap_or_else(tt::TokenId::unspecified)
 459     }
 460
 461     fn span_close(&mut self, group: &Self::Group) -> Self::Span {
 462         // FIXME we only store one `TokenId` for the delimiters
 463         group.delimiter.map(|it| it.id).unwrap_or_else(tt::TokenId::unspecified)
 464     }
 465 }
 466
 467 impl server::Punct for Rustc {
 468     fn new(&mut self, ch: char, spacing: bridge::Spacing) -> Self::Punct {
 469         tt::Punct {
 470             char: ch,
 471             spacing: spacing_to_internal(spacing),
 472             id: tt::TokenId::unspecified(),
 473         }
 474     }
 475     fn as_char(&mut self, punct: Self::Punct) -> char {
 476         punct.char
 477     }
 478     fn spacing(&mut self, punct: Self::Punct) -> bridge::Spacing {
 479         spacing_to_external(punct.spacing)
 480     }
 481     fn span(&mut self, punct: Self::Punct) -> Self::Span {
 482         punct.id
 483     }
 484     fn with_span(&mut self, punct: Self::Punct, span: Self::Span) -> Self::Punct {
 485         tt::Punct { id: span, ..punct }
 486     }
 487 }
 488
 489 impl server::Ident for Rustc {
 490     fn new(&mut self, string: &str, span: Self::Span, _is_raw: bool) -> Self::Ident {
 491         IdentId(self.ident_interner.intern(&IdentData(tt::Ident { text: string.into(), id: span })))
 492     }
 493
 494     fn span(&mut self, ident: Self::Ident) -> Self::Span {
 495         self.ident_interner.get(ident.0).0.id
 496     }
 497     fn with_span(&mut self, ident: Self::Ident, span: Self::Span) -> Self::Ident {
 498         let data = self.ident_interner.get(ident.0);
 499         let new = IdentData(tt::Ident { id: span, ..data.0.clone() });
 500         IdentId(self.ident_interner.intern(&new))
 501     }
 502 }
 503
 504 impl server::Literal for Rustc {
 505     fn debug_kind(&mut self, _literal: &Self::Literal) -> String {
 506         // r-a: debug_kind and suffix are unsupported; corresponding client code has been changed to not call these.
 507         // They must still be present to be ABI-compatible and work with upstream proc_macro.
 508         "".to_owned()
 509     }
 510     fn from_str(&mut self, s: &str) -> Result<Self::Literal, ()> {
 511         Ok(Literal { text: s.into(), id: tt::TokenId::unspecified() })
 512     }
 513     fn symbol(&mut self, literal: &Self::Literal) -> String {
 514         literal.text.to_string()
 515     }
 516     fn suffix(&mut self, _literal: &Self::Literal) -> Option<String> {
 517         None
 518     }
 519
 520     fn to_string(&mut self, literal: &Self::Literal) -> String {
 521         literal.to_string()
 522     }
 523
 524     fn integer(&mut self, n: &str) -> Self::Literal {
 525         let n = match n.parse::<i128>() {
 526             Ok(n) => n.to_string(),
 527             Err(_) => n.parse::<u128>().unwrap().to_string(),
 528         };
 529         Literal { text: n.into(), id: tt::TokenId::unspecified() }
 530     }
 531
 532     fn typed_integer(&mut self, n: &str, kind: &str) -> Self::Literal {
 533         macro_rules! def_suffixed_integer {
 534             ($kind:ident, $($ty:ty),*) => {
 535                 match $kind {
 536                     $(
 537                         stringify!($ty) => {
 538                             let n: $ty = n.parse().unwrap();
 539                             format!(concat!("{}", stringify!($ty)), n)
 540                         }
 541                     )*
 542                     _ => unimplemented!("unknown args for typed_integer: n {}, kind {}", n, $kind),
 543                 }
 544             }
 545         }
 546
 547         let text = def_suffixed_integer! {kind, u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize};
 548
 549         Literal { text: text.into(), id: tt::TokenId::unspecified() }
 550     }
 551
 552     fn float(&mut self, n: &str) -> Self::Literal {
 553         let n: f64 = n.parse().unwrap();
 554         let mut text = f64::to_string(&n);
 555         if !text.contains('.') {
 556             text += ".0"
 557         }
 558         Literal { text: text.into(), id: tt::TokenId::unspecified() }
 559     }
 560
 561     fn f32(&mut self, n: &str) -> Self::Literal {
 562         let n: f32 = n.parse().unwrap();
 563         let text = format!("{}f32", n);
 564         Literal { text: text.into(), id: tt::TokenId::unspecified() }
 565     }
 566
 567     fn f64(&mut self, n: &str) -> Self::Literal {
 568         let n: f64 = n.parse().unwrap();
 569         let text = format!("{}f64", n);
 570         Literal { text: text.into(), id: tt::TokenId::unspecified() }
 571     }
 572
 573     fn string(&mut self, string: &str) -> Self::Literal {
 574         let mut escaped = String::new();
 575         for ch in string.chars() {
 576             escaped.extend(ch.escape_debug());
 577         }
 578         Literal { text: format!("\"{}\"", escaped).into(), id: tt::TokenId::unspecified() }
 579     }
 580
 581     fn character(&mut self, ch: char) -> Self::Literal {
 582         Literal { text: format!("'{}'", ch).into(), id: tt::TokenId::unspecified() }
 583     }
 584
 585     fn byte_string(&mut self, bytes: &[u8]) -> Self::Literal {
 586         let string = bytes
 587             .iter()
 588             .cloned()
 589             .flat_map(ascii::escape_default)
 590             .map(Into::<char>::into)
 591             .collect::<String>();
 592
 593         Literal { text: format!("b\"{}\"", string).into(), id: tt::TokenId::unspecified() }
 594     }
 595
 596     fn span(&mut self, literal: &Self::Literal) -> Self::Span {
 597         literal.id
 598     }
 599
 600     fn set_span(&mut self, literal: &mut Self::Literal, span: Self::Span) {
 601         literal.id = span;
 602     }
 603
 604     fn subspan(
 605         &mut self,
 606         _literal: &Self::Literal,
 607         _start: Bound<usize>,
 608         _end: Bound<usize>,
 609     ) -> Option<Self::Span> {
 610         // FIXME handle span
 611         None
 612     }
 613 }
 614
 615 impl server::SourceFile for Rustc {
 616     // FIXME these are all stubs
 617     fn eq(&mut self, _file1: &Self::SourceFile, _file2: &Self::SourceFile) -> bool {
 618         true
 619     }
 620     fn path(&mut self, _file: &Self::SourceFile) -> String {
 621         String::new()
 622     }
 623     fn is_real(&mut self, _file: &Self::SourceFile) -> bool {
 624         true
 625     }
 626 }
 627
 628 impl server::Diagnostic for Rustc {
 629     fn new(&mut self, level: Level, msg: &str, spans: Self::MultiSpan) -> Self::Diagnostic {
 630         let mut diag = Diagnostic::new(level, msg);
 631         diag.spans = spans;
 632         diag
 633     }
 634
 635     fn sub(
 636         &mut self,
 637         _diag: &mut Self::Diagnostic,
 638         _level: Level,
 639         _msg: &str,
 640         _spans: Self::MultiSpan,
 641     ) {
 642         // FIXME handle diagnostic
 643         //
 644     }
 645
 646     fn emit(&mut self, _diag: Self::Diagnostic) {
 647         // FIXME handle diagnostic
 648         // diag.emit()
 649     }
 650 }
 651
 652 impl server::Span for Rustc {
 653     fn debug(&mut self, span: Self::Span) -> String {
 654         format!("{:?}", span.0)
 655     }
 656     fn def_site(&mut self) -> Self::Span {
 657         // MySpan(self.span_interner.intern(&MySpanData(Span::def_site())))
 658         // FIXME handle span
 659         tt::TokenId::unspecified()
 660     }
 661     fn call_site(&mut self) -> Self::Span {
 662         // MySpan(self.span_interner.intern(&MySpanData(Span::call_site())))
 663         // FIXME handle span
 664         tt::TokenId::unspecified()
 665     }
 666     fn source_file(&mut self, _span: Self::Span) -> Self::SourceFile {
 667         SourceFile {}
 668     }
 669     fn save_span(&mut self, _span: Self::Span) -> usize {
 670         // FIXME stub
 671         0
 672     }
 673     fn recover_proc_macro_span(&mut self, _id: usize) -> Self::Span {
 674         // FIXME stub
 675         tt::TokenId::unspecified()
 676     }
 677     /// Recent feature, not yet in the proc_macro
 678     ///
 679     /// See PR:
 680     /// https://github.com/rust-lang/rust/pull/55780
 681     fn source_text(&mut self, _span: Self::Span) -> Option<String> {
 682         None
 683     }
 684
 685     fn parent(&mut self, _span: Self::Span) -> Option<Self::Span> {
 686         // FIXME handle span
 687         None
 688     }
 689     fn source(&mut self, span: Self::Span) -> Self::Span {
 690         // FIXME handle span
 691         span
 692     }
 693     fn start(&mut self, _span: Self::Span) -> LineColumn {
 694         // FIXME handle span
 695         LineColumn { line: 0, column: 0 }
 696     }
 697     fn end(&mut self, _span: Self::Span) -> LineColumn {
 698         // FIXME handle span
 699         LineColumn { line: 0, column: 0 }
 700     }
 701     fn join(&mut self, first: Self::Span, _second: Self::Span) -> Option<Self::Span> {
 702         // Just return the first span again, because some macros will unwrap the result.
 703         Some(first)
 704     }
 705     fn resolved_at(&mut self, _span: Self::Span, _at: Self::Span) -> Self::Span {
 706         // FIXME handle span
 707         tt::TokenId::unspecified()
 708     }
 709
 710     fn mixed_site(&mut self) -> Self::Span {
 711         // FIXME handle span
 712         tt::TokenId::unspecified()
 713     }
 714
 715     fn after(&mut self, _self_: Self::Span) -> Self::Span {
 716         tt::TokenId::unspecified()
 717     }
 718
 719     fn before(&mut self, _self_: Self::Span) -> Self::Span {
 720         tt::TokenId::unspecified()
 721     }
 722 }
 723
 724 impl server::MultiSpan for Rustc {
 725     fn new(&mut self) -> Self::MultiSpan {
 726         // FIXME handle span
 727         vec![]
 728     }
 729
 730     fn push(&mut self, other: &mut Self::MultiSpan, span: Self::Span) {
 731         //TODP
 732         other.push(span)
 733     }
 734 }
 735
 736 #[cfg(test)]
 737 mod tests {
 738     use super::super::proc_macro::bridge::server::Literal;
 739     use super::*;
 740
 741     #[test]
 742     fn test_rustc_server_literals() {
 743         let mut srv = Rustc { ident_interner: IdentInterner::default() };
 744         assert_eq!(srv.integer("1234").text, "1234");
 745
 746         assert_eq!(srv.typed_integer("12", "u8").text, "12u8");
 747         assert_eq!(srv.typed_integer("255", "u16").text, "255u16");
 748         assert_eq!(srv.typed_integer("1234", "u32").text, "1234u32");
 749         assert_eq!(srv.typed_integer("15846685", "u64").text, "15846685u64");
 750         assert_eq!(srv.typed_integer("15846685258", "u128").text, "15846685258u128");
 751         assert_eq!(srv.typed_integer("156788984", "usize").text, "156788984usize");
 752         assert_eq!(srv.typed_integer("127", "i8").text, "127i8");
 753         assert_eq!(srv.typed_integer("255", "i16").text, "255i16");
 754         assert_eq!(srv.typed_integer("1234", "i32").text, "1234i32");
 755         assert_eq!(srv.typed_integer("15846685", "i64").text, "15846685i64");
 756         assert_eq!(srv.typed_integer("15846685258", "i128").text, "15846685258i128");
 757         assert_eq!(srv.float("0").text, "0.0");
 758         assert_eq!(srv.float("15684.5867").text, "15684.5867");
 759         assert_eq!(srv.f32("15684.58").text, "15684.58f32");
 760         assert_eq!(srv.f64("15684.58").text, "15684.58f64");
 761
 762         assert_eq!(srv.string("hello_world").text, "\"hello_world\"");
 763         assert_eq!(srv.character('c').text, "'c'");
 764         assert_eq!(srv.byte_string(b"1234586\x88").text, "b\"1234586\\x88\"");
 765
 766         // u128::max
 767         assert_eq!(
 768             srv.integer("340282366920938463463374607431768211455").text,
 769             "340282366920938463463374607431768211455"
 770         );
 771         // i128::min
 772         assert_eq!(
 773             srv.integer("-170141183460469231731687303715884105728").text,
 774             "-170141183460469231731687303715884105728"
 775         );
 776     }
 777
 778     #[test]
 779     fn test_rustc_server_to_string() {
 780         let s = TokenStream {
 781             token_trees: vec![
 782                 tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {
 783                     text: "struct".into(),
 784                     id: tt::TokenId::unspecified(),
 785                 })),
 786                 tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {
 787                     text: "T".into(),
 788                     id: tt::TokenId::unspecified(),
 789                 })),
 790                 tt::TokenTree::Subtree(tt::Subtree {
 791                     delimiter: Some(tt::Delimiter {
 792                         id: tt::TokenId::unspecified(),
 793                         kind: tt::DelimiterKind::Brace,
 794                     }),
 795                     token_trees: vec![],
 796                 }),
 797             ],
 798         };
 799
 800         assert_eq!(s.to_string(), "struct T {}");
 801     }
 802
 803     #[test]
 804     fn test_rustc_server_from_str() {
 805         use std::str::FromStr;
 806         let subtree_paren_a = tt::TokenTree::Subtree(tt::Subtree {
 807             delimiter: Some(tt::Delimiter {
 808                 id: tt::TokenId::unspecified(),
 809                 kind: tt::DelimiterKind::Parenthesis,
 810             }),
 811             token_trees: vec![tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {
 812                 text: "a".into(),
 813                 id: tt::TokenId::unspecified(),
 814             }))],
 815         });
 816
 817         let t1 = TokenStream::from_str("(a)").unwrap();
 818         assert_eq!(t1.token_trees.len(), 1);
 819         assert_eq!(t1.token_trees[0], subtree_paren_a);
 820
 821         let t2 = TokenStream::from_str("(a);").unwrap();
 822         assert_eq!(t2.token_trees.len(), 2);
 823         assert_eq!(t2.token_trees[0], subtree_paren_a);
 824
 825         let underscore = TokenStream::from_str("_").unwrap();
 826         assert_eq!(
 827             underscore.token_trees[0],
 828             tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {
 829                 text: "_".into(),
 830                 id: tt::TokenId::unspecified(),
 831             }))
 832         );
 833     }
 834 }