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