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