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