Adapt to newer nightly toolchain

Author: jth

build.rs

@@ -1,10 +1,5 @@
-use std::convert::TryInto;
 use std::env;
-use std::env::VarError;
 use std::error::Error;
-use std::fs::{read_dir, DirEntry, File};
-use std::io::Write;
-use std::path::Path;
 use std::process::Command;
 
 fn main() {
@@ -33,14 +28,14 @@ fn gen_for_grammar(
     grammar_file_name: &str,
     antlr_path: &str,
     additional_arg: Option<&str>,
-) -> Result<(), Box<Error>> {
+) -> Result<(), Box<dyn Error>> {
     // let out_dir = env::var("OUT_DIR").unwrap();
     // let dest_path = Path::new(&out_dir);
 
     let input = env::current_dir().unwrap().join("grammars");
     let file_name = grammar_file_name.to_owned() + ".g4";
 
-    let c = Command::new("java")
+    Command::new("java")
         .current_dir(input)
         .arg("-cp")
         .arg(antlr_path)

src/atn.rs

@@ -55,7 +55,7 @@ impl Debug for ATN {
 }
 
 impl ATN {
-    crate fn new_atn(grammar_type: ATNType, max_token_type: isize) -> ATN {
+    pub(crate) fn new_atn(grammar_type: ATNType, max_token_type: isize) -> ATN {
         ATN {
             decision_to_state: Vec::new(),
             grammar_type,
@@ -93,7 +93,7 @@ impl ATN {
         analyzer.look::<Ctx>(s, None, _ctx)
     }
 
-    crate fn add_state(&mut self, state: Box<dyn ATNState>) {
+    pub(crate) fn add_state(&mut self, state: Box<dyn ATNState>) {
         debug_assert_eq!(state.get_state_number(), self.states.len());
         self.states.push(state)
     }

src/atn_deserialization_options.rs

@@ -1,3 +1,4 @@
+#[allow(unused)]
 #[derive(Debug)]
 pub struct ATNDeserializationOptions {
     read_only: bool,

src/errors.rs

@@ -216,7 +216,7 @@ impl InputMisMatchError {
 
 /// See `ANTLRError::PredicateError`
 #[derive(Debug, Clone)]
-#[allow(missing_docs)]
+#[allow(missing_docs, unused)]
 pub struct FailedPredicateError {
     pub base: BaseRecognitionError,
     pub rule_index: isize,

src/lexer.rs

@@ -110,9 +110,9 @@ pub struct BaseLexer<
 }
 
 #[derive(Debug)]
-crate struct LexerPosition {
-    crate line: Cell<isize>,
-    crate char_position_in_line: Cell<isize>,
+pub(crate) struct LexerPosition {
+    pub(crate) line: Cell<isize>,
+    pub(crate) char_position_in_line: Cell<isize>,
 }
 
 impl<'input, T, Input, TF> Deref for BaseLexer<'input, T, Input, TF>
@@ -123,7 +123,9 @@ where
 {
     type Target = T;
 
-    fn deref(&self) -> &Self::Target { &self.recog }
+    fn deref(&self) -> &Self::Target {
+        &self.recog
+    }
 }
 
 impl<'input, T, Input, TF> DerefMut for BaseLexer<'input, T, Input, TF>
@@ -132,7 +134,9 @@ where
     Input: CharStream<TF::From>,
     TF: TokenFactory<'input>,
 {
-    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.recog }
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.recog
+    }
 }
 
 impl<'input, T, Input, TF> Recognizer<'input> for BaseLexer<'input, T, Input, TF>
@@ -178,16 +182,18 @@ pub use super::token::TOKEN_DEFAULT_CHANNEL as LEXER_DEFAULT_TOKEN_CHANNEL;
 #[doc(inline)]
 pub use super::token::TOKEN_HIDDEN_CHANNEL as LEXER_HIDDEN;
 
-crate const LEXER_MIN_CHAR_VALUE: isize = 0x0000;
-crate const LEXER_MAX_CHAR_VALUE: isize = 0x10FFFF;
+pub(crate) const LEXER_MIN_CHAR_VALUE: isize = 0x0000;
+pub(crate) const LEXER_MAX_CHAR_VALUE: isize = 0x10FFFF;
 
 impl<'input, T, Input, TF> BaseLexer<'input, T, Input, TF>
 where
     T: LexerRecog<'input, Self> + 'static,
     Input: CharStream<TF::From>,
     TF: TokenFactory<'input>,
 {
-    fn emit_token(&mut self, token: TF::Tok) { self.token = Some(token); }
+    fn emit_token(&mut self, token: TF::Tok) {
+        self.token = Some(token);
+    }
 
     fn emit(&mut self) {
         <T as LexerRecog<Self>>::before_emit(self);
@@ -220,7 +226,9 @@ where
     }
 
     /// Current position in input stream
-    pub fn get_char_index(&self) -> isize { self.input.as_ref().unwrap().index() }
+    pub fn get_char_index(&self) -> isize {
+        self.input.as_ref().unwrap().index()
+    }
 
     /// Current token text
     pub fn get_text<'a>(&'a self) -> Cow<'a, TF::Data>
@@ -242,7 +250,9 @@ where
     }
 
     /// Used from lexer actions to override text of the token that will be emitted next
-    pub fn set_text(&mut self, _text: <TF::Data as ToOwned>::Owned) { self.text = Some(_text); }
+    pub fn set_text(&mut self, _text: <TF::Data as ToOwned>::Owned) {
+        self.text = Some(_text);
+    }
 
     // fn get_all_tokens(&mut self) -> Vec<TF::Tok> { unimplemented!() }
 
@@ -254,7 +264,9 @@ where
     }
 
     /// Remove and drop all error listeners
-    pub fn remove_error_listeners(&mut self) { self.error_listeners.borrow_mut().clear(); }
+    pub fn remove_error_listeners(&mut self) {
+        self.error_listeners.borrow_mut().clear();
+    }
 
     /// Creates new lexer instance
     pub fn new_base_lexer(
@@ -375,9 +387,13 @@ where
         self.token.take().unwrap()
     }
 
-    fn get_line(&self) -> isize { self.current_pos.line.get() }
+    fn get_line(&self) -> isize {
+        self.current_pos.line.get()
+    }
 
-    fn get_char_position_in_line(&self) -> isize { self.current_pos.char_position_in_line.get() }
+    fn get_char_position_in_line(&self) -> isize {
+        self.current_pos.char_position_in_line.get()
+    }
 
     fn get_input_stream(&mut self) -> Option<&mut dyn IntStream> {
         match &mut self.input {
@@ -397,7 +413,9 @@ where
     //        self.factory = f;
     //    }
 
-    fn get_token_factory(&self) -> &'input TF { self.factory }
+    fn get_token_factory(&self) -> &'input TF {
+        self.factory
+    }
 }
 
 #[cold]
@@ -440,9 +458,13 @@ where
 {
     type Input = Input;
 
-    fn input(&mut self) -> &mut Self::Input { self.input.as_mut().unwrap() }
+    fn input(&mut self) -> &mut Self::Input {
+        self.input.as_mut().unwrap()
+    }
 
-    fn set_channel(&mut self, v: isize) { self.channel = v; }
+    fn set_channel(&mut self, v: isize) {
+        self.channel = v;
+    }
 
     fn push_mode(&mut self, m: usize) {
         self.mode_stack.push(self.mode);
@@ -456,15 +478,27 @@ where
         })
     }
 
-    fn set_type(&mut self, t: isize) { self.token_type = t; }
+    fn set_type(&mut self, t: isize) {
+        self.token_type = t;
+    }
 
-    fn set_mode(&mut self, m: usize) { self.mode = m; }
+    fn set_mode(&mut self, m: usize) {
+        self.mode = m;
+    }
 
-    fn more(&mut self) { self.set_type(LEXER_MORE) }
+    fn more(&mut self) {
+        self.set_type(LEXER_MORE)
+    }
 
-    fn skip(&mut self) { self.set_type(LEXER_SKIP) }
+    fn skip(&mut self) {
+        self.set_type(LEXER_SKIP)
+    }
 
-    fn reset(&mut self) { unimplemented!() }
+    fn reset(&mut self) {
+        unimplemented!()
+    }
 
-    fn get_interpreter(&self) -> Option<&LexerATNSimulator> { self.interpreter.as_deref() }
+    fn get_interpreter(&self) -> Option<&LexerATNSimulator> {
+        self.interpreter.as_deref()
+    }
 }

src/lib.rs

@@ -8,11 +8,9 @@
 #![feature(coerce_unsized)]
 #![feature(associated_type_defaults)]
 #![feature(generic_associated_types)]
-#![feature(crate_visibility_modifier)]
 // #![feature(generic_associated_types)]
 #![warn(rust_2018_idioms)]
 #![warn(missing_docs)] // warn if there is missing docs
-#![warn(missing_debug_implementations)]
 #![warn(trivial_numeric_casts)]
 #![allow(incomplete_features)]
 

src/token_factory.rs

@@ -14,7 +14,6 @@ use crate::token::Token;
 use crate::token::{CommonToken, OwningToken, TOKEN_INVALID_TYPE};
 use better_any::{Tid, TidAble};
 
-#[allow(non_upper_case_globals)]
 lazy_static! {
     pub(crate) static ref COMMON_TOKEN_FACTORY_DEFAULT: Box<CommonTokenFactory> =
         Box::new(CommonTokenFactory {});