Fix bug in Engine::gen_fn_signatures.

CHANGELOG.md

@@ -63,6 +63,7 @@ Other bug fixes
 
 * Arrays in object maps now serialize to JSON correctly via `to_json()` when the `serde` feature is not enabled.
 * `Engine::format_map_as_json` now serializes arrays correctly.
+* `Engine::gen_fn_signatures(false)` now properly skips functions in the standard library.
 
 Enhancements
 ------------

src/api/definitions/mod.rs

@@ -321,7 +321,7 @@ impl Definitions<'_> {
         self.engine
             .global_modules
             .iter()
-            .filter(|m| !m.flags.contains(exclude_flags))
+            .filter(|&m| !m.flags.intersects(exclude_flags))
             .enumerate()
             .for_each(|(i, m)| {
                 if i > 0 {

src/api/options.rs

@@ -68,7 +68,7 @@ impl Engine {
     #[inline(always)]
     #[must_use]
     pub const fn allow_if_expression(&self) -> bool {
-        self.options.contains(LangOptions::IF_EXPR)
+        self.options.intersects(LangOptions::IF_EXPR)
     }
     /// Set whether `if`-expression is allowed.
     #[inline(always)]
@@ -81,7 +81,7 @@ impl Engine {
     #[inline(always)]
     #[must_use]
     pub const fn allow_switch_expression(&self) -> bool {
-        self.options.contains(LangOptions::SWITCH_EXPR)
+        self.options.intersects(LangOptions::SWITCH_EXPR)
     }
     /// Set whether `switch` expression is allowed.
     #[inline(always)]
@@ -94,7 +94,7 @@ impl Engine {
     #[inline(always)]
     #[must_use]
     pub const fn allow_loop_expressions(&self) -> bool {
-        self.options.contains(LangOptions::LOOP_EXPR)
+        self.options.intersects(LangOptions::LOOP_EXPR)
     }
     /// Set whether loop expressions are allowed.
     #[inline(always)]
@@ -107,7 +107,7 @@ impl Engine {
     #[inline(always)]
     #[must_use]
     pub const fn allow_statement_expression(&self) -> bool {
-        self.options.contains(LangOptions::STMT_EXPR)
+        self.options.intersects(LangOptions::STMT_EXPR)
     }
     /// Set whether statement-expression is allowed.
     #[inline(always)]
@@ -123,7 +123,7 @@ impl Engine {
     #[inline(always)]
     #[must_use]
     pub const fn allow_anonymous_fn(&self) -> bool {
-        self.options.contains(LangOptions::ANON_FN)
+        self.options.intersects(LangOptions::ANON_FN)
     }
     /// Set whether anonymous function is allowed.
     ///
@@ -139,7 +139,7 @@ impl Engine {
     #[inline(always)]
     #[must_use]
     pub const fn allow_looping(&self) -> bool {
-        self.options.contains(LangOptions::LOOPING)
+        self.options.intersects(LangOptions::LOOPING)
     }
     /// Set whether looping is allowed.
     #[inline(always)]
@@ -152,7 +152,7 @@ impl Engine {
     #[inline(always)]
     #[must_use]
     pub const fn allow_shadowing(&self) -> bool {
-        self.options.contains(LangOptions::SHADOWING)
+        self.options.intersects(LangOptions::SHADOWING)
     }
     /// Set whether variables shadowing is allowed.
     #[inline(always)]
@@ -165,7 +165,7 @@ impl Engine {
     #[inline(always)]
     #[must_use]
     pub const fn strict_variables(&self) -> bool {
-        self.options.contains(LangOptions::STRICT_VAR)
+        self.options.intersects(LangOptions::STRICT_VAR)
     }
     /// Set whether strict variables mode is enabled.
     #[inline(always)]
@@ -182,7 +182,7 @@ impl Engine {
     #[must_use]
     pub const fn fail_on_invalid_map_property(&self) -> bool {
         self.options
-            .contains(LangOptions::FAIL_ON_INVALID_MAP_PROPERTY)
+            .intersects(LangOptions::FAIL_ON_INVALID_MAP_PROPERTY)
     }
     /// Set whether to raise error if an object map property does not exist.
     ///
@@ -199,7 +199,7 @@ impl Engine {
     #[inline(always)]
     #[must_use]
     pub const fn fast_operators(&self) -> bool {
-        self.options.contains(LangOptions::FAST_OPS)
+        self.options.intersects(LangOptions::FAST_OPS)
     }
     /// Set whether fast operators mode is enabled.
     #[inline(always)]

src/api/register.rs

@@ -772,7 +772,7 @@ impl Engine {
             self.global_modules
                 .iter()
                 .skip(1)
-                .filter(|m| !m.flags.contains(exclude_flags))
+                .filter(|m| !m.flags.intersects(exclude_flags))
                 .flat_map(|m| m.gen_fn_signatures()),
         );
 

src/ast/ast.rs

@@ -807,12 +807,12 @@ impl AST {
     ) -> impl Iterator<Item = (&str, bool, Dynamic)> {
         self.statements().iter().filter_map(move |stmt| match stmt {
             Stmt::Var(x, options, ..)
-                if options.contains(ASTFlags::CONSTANT) && include_constants
-                    || !options.contains(ASTFlags::CONSTANT) && include_variables =>
+                if options.intersects(ASTFlags::CONSTANT) && include_constants
+                    || !options.intersects(ASTFlags::CONSTANT) && include_variables =>
             {
                 let (name, expr, ..) = &**x;
                 expr.get_literal_value()
-                    .map(|value| (name.as_str(), options.contains(ASTFlags::CONSTANT), value))
+                    .map(|value| (name.as_str(), options.intersects(ASTFlags::CONSTANT), value))
             }
             _ => None,
         })

src/ast/stmt.rs

@@ -867,7 +867,7 @@ impl Stmt {
             // Loops that exit can be pure because it can never be infinite.
             Self::While(x, ..) if matches!(x.expr, Expr::BoolConstant(false, ..)) => true,
             Self::Do(x, options, ..) if matches!(x.expr, Expr::BoolConstant(..)) => match x.expr {
-                Expr::BoolConstant(cond, ..) if cond == options.contains(ASTFlags::NEGATED) => {
+                Expr::BoolConstant(cond, ..) if cond == options.intersects(ASTFlags::NEGATED) => {
                     x.body.iter().all(Self::is_pure)
                 }
                 _ => false,

src/eval/chaining.rs

@@ -473,7 +473,7 @@ impl Engine {
             (Expr::Property(..), ChainType::Dotting) => (),
 
             (Expr::Index(x, ..) | Expr::Dot(x, ..), chain_type)
-                if !parent.options().contains(ASTFlags::BREAK) =>
+                if !parent.options().intersects(ASTFlags::BREAK) =>
             {
                 let BinaryExpr { lhs, rhs, .. } = &**x;
 
@@ -556,7 +556,7 @@ impl Engine {
             #[cfg(not(feature = "no_index"))]
             ChainType::Indexing => {
                 // Check for existence with the null conditional operator
-                if parent.options().contains(ASTFlags::NEGATED) && target.as_ref().is_unit() {
+                if parent.options().intersects(ASTFlags::NEGATED) && target.as_ref().is_unit() {
                     return Ok((Dynamic::UNIT, false));
                 }
 
@@ -565,7 +565,7 @@ impl Engine {
                 match (rhs, new_val) {
                     // xxx[idx].expr... | xxx[idx][expr]...
                     (Expr::Dot(x, ..) | Expr::Index(x, ..), new_val)
-                        if !parent.options().contains(ASTFlags::BREAK) =>
+                        if !parent.options().intersects(ASTFlags::BREAK) =>
                     {
                         #[cfg(feature = "debugging")]
                         self.run_debugger(global, caches, _scope, this_ptr.as_deref_mut(), parent)?;
@@ -688,7 +688,7 @@ impl Engine {
             #[cfg(not(feature = "no_object"))]
             ChainType::Dotting => {
                 // Check for existence with the Elvis operator
-                if parent.options().contains(ASTFlags::NEGATED) && target.as_ref().is_unit() {
+                if parent.options().intersects(ASTFlags::NEGATED) && target.as_ref().is_unit() {
                     return Ok((Dynamic::UNIT, false));
                 }
 

src/eval/stmt.rs

@@ -390,12 +390,12 @@ impl Engine {
                 // Let/const statement
                 let (var_name, expr, index) = &**x;
 
-                let access = if options.contains(ASTFlags::CONSTANT) {
+                let access = if options.intersects(ASTFlags::CONSTANT) {
                     AccessMode::ReadOnly
                 } else {
                     AccessMode::ReadWrite
                 };
-                let export = options.contains(ASTFlags::EXPORTED);
+                let export = options.intersects(ASTFlags::EXPORTED);
 
                 // Check variable definition filter
                 if let Some(ref filter) = self.def_var_filter {
@@ -632,7 +632,7 @@ impl Engine {
             // Do loop
             Stmt::Do(x, options, ..) => {
                 let FlowControl { expr, body, .. } = &**x;
-                let is_while = !options.contains(ASTFlags::NEGATED);
+                let is_while = !options.intersects(ASTFlags::NEGATED);
 
                 loop {
                     if !body.is_empty() {
@@ -773,7 +773,7 @@ impl Engine {
 
             // Continue/Break statement
             Stmt::BreakLoop(expr, options, pos) => {
-                let is_break = options.contains(ASTFlags::BREAK);
+                let is_break = options.intersects(ASTFlags::BREAK);
 
                 let value = match expr {
                     Some(ref expr) => self.eval_expr(global, caches, scope, this_ptr, expr)?,
@@ -871,12 +871,12 @@ impl Engine {
             }
 
             // Throw value
-            Stmt::Return(Some(expr), options, pos) if options.contains(ASTFlags::BREAK) => self
+            Stmt::Return(Some(expr), options, pos) if options.intersects(ASTFlags::BREAK) => self
                 .eval_expr(global, caches, scope, this_ptr, expr)
                 .and_then(|v| Err(ERR::ErrorRuntime(v.flatten(), *pos).into())),
 
             // Empty throw
-            Stmt::Return(None, options, pos) if options.contains(ASTFlags::BREAK) => {
+            Stmt::Return(None, options, pos) if options.intersects(ASTFlags::BREAK) => {
                 Err(ERR::ErrorRuntime(Dynamic::UNIT, *pos).into())
             }
 

src/module/mod.rs

@@ -1003,7 +1003,7 @@ impl Module {
     #[inline]
     #[must_use]
     pub fn is_empty(&self) -> bool {
-        !self.flags.contains(ModuleFlags::INDEXED_GLOBAL_FUNCTIONS)
+        !self.flags.intersects(ModuleFlags::INDEXED_GLOBAL_FUNCTIONS)
             && self
                 .functions
                 .as_ref()
@@ -1045,7 +1045,7 @@ impl Module {
     #[inline(always)]
     #[must_use]
     pub const fn is_indexed(&self) -> bool {
-        self.flags.contains(ModuleFlags::INDEXED)
+        self.flags.intersects(ModuleFlags::INDEXED)
     }
 
     /// _(metadata)_ Generate signatures for all the non-private functions in the [`Module`].
@@ -2365,7 +2365,7 @@ impl Module {
     #[inline(always)]
     #[must_use]
     pub const fn contains_indexed_global_functions(&self) -> bool {
-        self.flags.contains(ModuleFlags::INDEXED_GLOBAL_FUNCTIONS)
+        self.flags.intersects(ModuleFlags::INDEXED_GLOBAL_FUNCTIONS)
     }
 
     /// Scan through all the sub-modules in the [`Module`] and build a hash index of all

src/optimizer.rs

@@ -223,7 +223,7 @@ fn optimize_stmt_block(
                 Stmt::Var(x, options, ..) => {
                     optimize_expr(&mut x.1, state, false);
 
-                    let value = if options.contains(ASTFlags::CONSTANT) && x.1.is_constant() {
+                    let value = if options.intersects(ASTFlags::CONSTANT) && x.1.is_constant() {
                         // constant literal
                         Some(Cow::Owned(x.1.get_literal_value().unwrap()))
                     } else {
@@ -282,7 +282,7 @@ fn optimize_stmt_block(
                 match statements[..] {
                     // { return; } -> {}
                     [Stmt::Return(None, options, ..)]
-                        if reduce_return && !options.contains(ASTFlags::BREAK) =>
+                        if reduce_return && !options.intersects(ASTFlags::BREAK) =>
                     {
                         state.set_dirty();
                         statements.clear();
@@ -294,15 +294,15 @@ fn optimize_stmt_block(
                     // { ...; return; } -> { ... }
                     [.., ref last_stmt, Stmt::Return(None, options, ..)]
                         if reduce_return
-                            && !options.contains(ASTFlags::BREAK)
+                            && !options.intersects(ASTFlags::BREAK)
                             && !last_stmt.returns_value() =>
                     {
                         state.set_dirty();
                         statements.pop().unwrap();
                     }
                     // { ...; return val; } -> { ...; val }
                     [.., Stmt::Return(ref mut expr, options, pos)]
-                        if reduce_return && !options.contains(ASTFlags::BREAK) =>
+                        if reduce_return && !options.intersects(ASTFlags::BREAK) =>
                     {
                         state.set_dirty();
                         *statements.last_mut().unwrap() = expr
@@ -339,15 +339,15 @@ fn optimize_stmt_block(
                     }
                     // { ...; return; } -> { ... }
                     [.., Stmt::Return(None, options, ..)]
-                        if reduce_return && !options.contains(ASTFlags::BREAK) =>
+                        if reduce_return && !options.intersects(ASTFlags::BREAK) =>
                     {
                         state.set_dirty();
                         statements.pop().unwrap();
                     }
                     // { ...; return pure_val; } -> { ... }
                     [.., Stmt::Return(Some(ref expr), options, ..)]
                         if reduce_return
-                            && !options.contains(ASTFlags::BREAK)
+                            && !options.intersects(ASTFlags::BREAK)
                             && expr.is_pure() =>
                     {
                         state.set_dirty();
@@ -771,7 +771,7 @@ fn optimize_stmt(stmt: &mut Stmt, state: &mut OptimizerState, preserve_result: b
                 optimize_stmt_block(x.2.body.take_statements(), state, false, true, false);
         }
         // let id = expr;
-        Stmt::Var(x, options, ..) if !options.contains(ASTFlags::CONSTANT) => {
+        Stmt::Var(x, options, ..) if !options.intersects(ASTFlags::CONSTANT) => {
             optimize_expr(&mut x.1, state, false);
         }
         // import expr as var;
@@ -911,7 +911,7 @@ fn optimize_expr(expr: &mut Expr, state: &mut OptimizerState, _chaining: bool) {
         }
         // ()?.rhs
         #[cfg(not(feature = "no_object"))]
-        Expr::Dot(x, options, ..) if options.contains(ASTFlags::NEGATED) && matches!(x.lhs, Expr::Unit(..)) => {
+        Expr::Dot(x, options, ..) if options.intersects(ASTFlags::NEGATED) && matches!(x.lhs, Expr::Unit(..)) => {
             state.set_dirty();
             *expr = x.lhs.take();
         }
@@ -953,7 +953,7 @@ fn optimize_expr(expr: &mut Expr, state: &mut OptimizerState, _chaining: bool) {
 
         // ()?[rhs]
         #[cfg(not(feature = "no_index"))]
-        Expr::Index(x, options, ..) if options.contains(ASTFlags::NEGATED) && matches!(x.lhs, Expr::Unit(..)) => {
+        Expr::Index(x, options, ..) if options.intersects(ASTFlags::NEGATED) && matches!(x.lhs, Expr::Unit(..)) => {
             state.set_dirty();
             *expr = x.lhs.take();
         }
@@ -1300,7 +1300,7 @@ impl Engine {
         if self
             .global_modules
             .iter()
-            .filter(|m| !m.flags.contains(ModuleFlags::STANDARD_LIB))
+            .filter(|m| !m.flags.intersects(ModuleFlags::STANDARD_LIB))
             .any(|m| m.contains_fn(hash))
         {
             return true;