Remove make_parser_concrete hack!

The need for this hack seems to have disappeared - probably when we moved
to the better code generation of the choice macro, and we just didn't notice
or think to remove it. This completely gets rid of it!

aml/src/expression.rs

@@ -1,17 +1,7 @@
 use crate::{
     name_object::{name_string, super_name, target},
     opcode::{self, opcode},
-    parser::{
-        choice,
-        comment_scope,
-        make_parser_concrete,
-        n_of,
-        take,
-        take_to_end_of_pkglength,
-        try_with_context,
-        Parser,
-        Propagate,
-    },
+    parser::{choice, comment_scope, n_of, take, take_to_end_of_pkglength, try_with_context, Parser, Propagate},
     pkg_length::pkg_length,
     term_object::{data_ref_object, term_arg},
     value::{AmlType, AmlValue, Args},

aml/src/lib.rs

@@ -25,7 +25,7 @@
 //!
 //! The actual combinators can be found in `parser.rs`. Various tricks are used to provide a nice
 //! API and work around limitations in the type system, such as the concrete types like
-//! `MapWithContext`, and the `make_parser_concrete` hack macro.
+//! `MapWithContext`.
 //!
 //! The actual parsers are then grouped into categories based loosely on the AML grammar sections in
 //! the ACPI spec. Most are written in terms of combinators, but some have to be written in a more

aml/src/parser.rs

@@ -487,20 +487,6 @@ pub(crate) macro choice {
     }
 }
 
-/// This encapsulates an unfortunate hack we sometimes need to use, where the type checker gets
-/// caught in an infinite loop of parser types. This occurs when an object can indirectly contain
-/// itself, and so the parser type will contain its own type. This works by breaking the cycle of
-/// `impl Parser` chains that build up, by effectively creating a "concrete" closure type.
-///
-/// You can try using this hack if you are writing a parser and end up with an error of the form:
-/// `error[E0275]: overflow evaluating the requirement 'impl Parser<{a type}>'
-///     help: consider adding a a '#![recursion_limit="128"] attribute to your crate`
-/// Note: Increasing the recursion limit will not fix the issue, as the cycle will just continue
-/// until you either hit the new recursion limit or `rustc` overflows its stack.
-pub(crate) macro make_parser_concrete($parser: expr) {
-    |input, context| ($parser).parse(input, context)
-}
-
 /// Helper macro for use within `map_with_context` as an alternative to "trying" an expression.
 ///
 /// ### Example

aml/src/term_object.rs

@@ -7,7 +7,6 @@ use crate::{
     parser::{
         choice,
         comment_scope,
-        make_parser_concrete,
         take,
         take_to_end_of_pkglength,
         take_u16,
@@ -847,7 +846,7 @@ where
             local_obj().map_with_context(|local_num, context| {
                 (Ok(try_with_context!(context, context.local(local_num)).clone()), context)
             }),
-            make_parser_concrete!(expression_opcode())
+            expression_opcode()
         ),
     )
 }
@@ -937,7 +936,7 @@ where
         choice!(
             ext_opcode(opcode::EXT_REVISION_OP).map(|_| Ok(AmlValue::Integer(crate::AML_INTERPRETER_REVISION))),
             const_parser,
-            make_parser_concrete!(def_buffer())
+            def_buffer()
         ),
     )
 }