Don't define namespace under no_module.

Author: schungx

CHANGELOG.md

@@ -4,6 +4,11 @@ Rhai Release Notes
 Version 1.18.0
 ==============
 
+Bug fixes
+---------
+
+* The position of an undefined operation call now points to the operator instead of the first operand.
+
 Deprecated API's
 ----------------
 

src/api/custom_syntax.rs

@@ -106,8 +106,8 @@ impl Expression<'_> {
     pub fn get_string_value(&self) -> Option<&str> {
         match self.0 {
             #[cfg(not(feature = "no_module"))]
-            Expr::Variable(x, ..) if !x.1.is_empty() => None,
-            Expr::Variable(x, ..) => Some(&x.3),
+            Expr::Variable(x, ..) if !x.2.is_empty() => None,
+            Expr::Variable(x, ..) => Some(&x.1),
             #[cfg(not(feature = "no_function"))]
             Expr::ThisPtr(..) => Some(crate::engine::KEYWORD_THIS),
             Expr::StringConstant(x, ..) => Some(x),
@@ -138,7 +138,7 @@ impl Expression<'_> {
 
             Expr::CharConstant(x, ..) => reify! { *x => Option<T> },
             Expr::StringConstant(x, ..) => reify! { x.clone() => Option<T> },
-            Expr::Variable(x, ..) => reify! { x.3.clone() => Option<T> },
+            Expr::Variable(x, ..) => reify! { x.1.clone() => Option<T> },
             Expr::BoolConstant(x, ..) => reify! { *x => Option<T> },
             Expr::Unit(..) => reify! { () => Option<T> },
 

src/ast/expr.rs

@@ -1,6 +1,6 @@
 //! Module defining script expressions.
 
-use super::{ASTFlags, ASTNode, Ident, Namespace, Stmt, StmtBlock};
+use super::{ASTFlags, ASTNode, Ident, Stmt, StmtBlock};
 use crate::engine::KEYWORD_FN_PTR;
 use crate::tokenizer::Token;
 use crate::types::dynamic::Union;
@@ -184,7 +184,8 @@ impl FnCallHashes {
 #[derive(Clone, Hash)]
 pub struct FnCallExpr {
     /// Namespace of the function, if any.
-    pub namespace: Namespace,
+    #[cfg(not(feature = "no_module"))]
+    pub namespace: super::Namespace,
     /// Function name.
     pub name: ImmutableString,
     /// Pre-calculated hashes.
@@ -202,13 +203,14 @@ impl fmt::Debug for FnCallExpr {
     #[inline(never)]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut ff = f.debug_struct("FnCallExpr");
+        #[cfg(not(feature = "no_module"))]
         if !self.namespace.is_empty() {
             ff.field("namespace", &self.namespace);
         }
         ff.field("hash", &self.hashes)
             .field("name", &self.name)
             .field("args", &self.args);
-        if self.op_token.is_some() {
+        if self.is_operator_call() {
             ff.field("op_token", &self.op_token);
         }
         if self.capture_parent_scope {
@@ -221,12 +223,19 @@ impl fmt::Debug for FnCallExpr {
 impl FnCallExpr {
     /// Does this function call contain a qualified namespace?
     ///
-    /// Always `false` under `no_module`.
+    /// Not available under [`no_module`]
+    #[cfg(not(feature = "no_module"))]
     #[inline(always)]
     #[must_use]
     pub fn is_qualified(&self) -> bool {
         !self.namespace.is_empty()
     }
+    /// Is this function call an operator expression?
+    #[inline(always)]
+    #[must_use]
+    pub fn is_operator_call(&self) -> bool {
+        self.op_token.is_some()
+    }
     /// Convert this into an [`Expr::FnCall`].
     #[inline(always)]
     #[must_use]
@@ -276,13 +285,15 @@ pub enum Expr {
     ),
     /// ()
     Unit(Position),
-    /// Variable access - (optional long index, namespace, namespace hash, variable name), optional short index, position
+    /// Variable access - (optional long index, variable name, namespace, namespace hash), optional short index, position
     ///
     /// The short index is [`u8`] which is used when the index is <= 255, which should be
     /// the vast majority of cases (unless there are more than 255 variables defined!).
     /// This is to avoid reading a pointer redirection during each variable access.
     Variable(
-        Box<(Option<NonZeroUsize>, Namespace, u64, ImmutableString)>,
+        #[cfg(not(feature = "no_module"))]
+        Box<(Option<NonZeroUsize>, ImmutableString, super::Namespace, u64)>,
+        #[cfg(feature = "no_module")] Box<(Option<NonZeroUsize>, ImmutableString)>,
         Option<NonZeroU8>,
         Position,
     ),
@@ -371,16 +382,16 @@ impl fmt::Debug for Expr {
                 f.write_str("Variable(")?;
 
                 #[cfg(not(feature = "no_module"))]
-                if !x.1.is_empty() {
+                if !x.2.is_empty() {
                     write!(f, "{}{}", x.1, crate::engine::NAMESPACE_SEPARATOR)?;
-                    let pos = x.1.position();
+                    let pos = x.2.position();
                     if !pos.is_none() {
                         display_pos = pos;
                     }
                 }
-                f.write_str(&x.3)?;
+                f.write_str(&x.1)?;
                 #[cfg(not(feature = "no_module"))]
-                if let Some(n) = x.1.index {
+                if let Some(n) = x.2.index {
                     write!(f, " #{n}")?;
                 }
                 if let Some(n) = i.map_or_else(|| x.0, |n| NonZeroUsize::new(n.get() as usize)) {
@@ -495,18 +506,20 @@ impl Expr {
                 s.into()
             }
 
-            // Fn
-            Self::FnCall(ref x, ..)
-                if !x.is_qualified() && x.args.len() == 1 && x.name == KEYWORD_FN_PTR =>
-            {
+            // Qualified function call
+            #[cfg(not(feature = "no_module"))]
+            Self::FnCall(x, ..) if x.is_qualified() => return None,
+
+            // Function call
+            Self::FnCall(x, ..) if x.args.len() == 1 && x.name == KEYWORD_FN_PTR => {
                 match x.args[0] {
                     Self::StringConstant(ref s, ..) => FnPtr::new(s.clone()).ok()?.into(),
                     _ => return None,
                 }
             }
 
-            // Binary operators
-            Self::FnCall(x, ..) if !x.is_qualified() && x.args.len() == 2 => {
+            // Binary operator call
+            Self::FnCall(x, ..) if x.args.len() == 2 => {
                 pub const OP_EXCLUSIVE_RANGE: &str = Token::ExclusiveRange.literal_syntax();
                 pub const OP_INCLUSIVE_RANGE: &str = Token::InclusiveRange.literal_syntax();
 
@@ -559,7 +572,8 @@ impl Expr {
 
             Union::FnPtr(f, ..) if !f.is_curried() => Self::FnCall(
                 FnCallExpr {
-                    namespace: Namespace::NONE,
+                    #[cfg(not(feature = "no_module"))]
+                    namespace: super::Namespace::NONE,
                     name: KEYWORD_FN_PTR.into(),
                     hashes: FnCallHashes::from_hash(calc_fn_hash(None, f.fn_name(), 1)),
                     args: once(Self::StringConstant(f.fn_name().into(), pos)).collect(),
@@ -581,8 +595,8 @@ impl Expr {
     pub(crate) fn get_variable_name(&self, _non_qualified: bool) -> Option<&str> {
         match self {
             #[cfg(not(feature = "no_module"))]
-            Self::Variable(x, ..) if _non_qualified && !x.1.is_empty() => None,
-            Self::Variable(x, ..) => Some(&x.3),
+            Self::Variable(x, ..) if _non_qualified && !x.2.is_empty() => None,
+            Self::Variable(x, ..) => Some(&x.1),
             _ => None,
         }
     }
@@ -661,10 +675,10 @@ impl Expr {
         match self {
             #[cfg(not(feature = "no_module"))]
             Self::Variable(x, ..) => {
-                if x.1.is_empty() {
+                if x.2.is_empty() {
                     self.position()
                 } else {
-                    x.1.position()
+                    x.2.position()
                 }
             }
 

src/ast/mod.rs

@@ -6,7 +6,6 @@ pub mod expr;
 pub mod flags;
 pub mod ident;
 pub mod namespace;
-pub mod namespace_none;
 pub mod script_fn;
 pub mod stmt;
 
@@ -18,8 +17,6 @@ pub use flags::{ASTFlags, FnAccess};
 pub use ident::Ident;
 #[cfg(not(feature = "no_module"))]
 pub use namespace::Namespace;
-#[cfg(feature = "no_module")]
-pub use namespace_none::Namespace;
 #[cfg(not(feature = "no_function"))]
 pub use script_fn::{ScriptFnMetadata, ScriptFuncDef};
 pub use stmt::{

src/ast/namespace_none.rs

@@ -913,11 +913,16 @@ impl Stmt {
 
             Self::Expr(e) => match &**e {
                 Expr::Stmt(s) => s.iter().all(Self::is_block_dependent),
-                Expr::FnCall(x, ..) => !x.is_qualified() && x.name == KEYWORD_EVAL,
+                #[cfg(not(feature = "no_module"))]
+                Expr::FnCall(x, ..) if x.is_qualified() => false,
+                Expr::FnCall(x, ..) => x.name == KEYWORD_EVAL,
                 _ => false,
             },
 
-            Self::FnCall(x, ..) => !x.is_qualified() && x.name == KEYWORD_EVAL,
+            #[cfg(not(feature = "no_module"))]
+            Self::FnCall(x, ..) if x.is_qualified() => false,
+
+            Self::FnCall(x, ..) => x.name == KEYWORD_EVAL,
 
             #[cfg(not(feature = "no_module"))]
             Self::Import(..) | Self::Export(..) => true,

src/ast/stmt.rs

@@ -462,6 +462,7 @@ impl Engine {
         match (expr, ChainType::from(parent)) {
             #[cfg(not(feature = "no_object"))]
             (Expr::MethodCall(x, ..), ChainType::Dotting) => {
+                #[cfg(not(feature = "no_module"))]
                 debug_assert!(
                     !x.is_qualified(),
                     "method call in dot chain should not be namespace-qualified"
@@ -491,6 +492,7 @@ impl Engine {
 
                     #[cfg(not(feature = "no_object"))]
                     (Expr::MethodCall(x, ..), ChainType::Dotting) => {
+                        #[cfg(not(feature = "no_module"))]
                         debug_assert!(
                             !x.is_qualified(),
                             "method call in dot chain should not be namespace-qualified"
@@ -735,6 +737,7 @@ impl Engine {
                     }
                     // xxx.fn_name(arg_expr_list)
                     (Expr::MethodCall(x, pos), None, ..) => {
+                        #[cfg(not(feature = "no_module"))]
                         debug_assert!(
                             !x.is_qualified(),
                             "method call in dot chain should not be namespace-qualified"
@@ -937,6 +940,7 @@ impl Engine {
                             }
                             // {xxx:map}.fn_name(arg_expr_list)[expr] | {xxx:map}.fn_name(arg_expr_list).expr
                             Expr::MethodCall(ref x, pos) => {
+                                #[cfg(not(feature = "no_module"))]
                                 debug_assert!(
                                     !x.is_qualified(),
                                     "method call in dot chain should not be namespace-qualified"
@@ -1058,6 +1062,7 @@ impl Engine {
                             }
                             // xxx.fn_name(arg_expr_list)[expr] | xxx.fn_name(arg_expr_list).expr
                             Expr::MethodCall(ref f, pos) => {
+                                #[cfg(not(feature = "no_module"))]
                                 debug_assert!(
                                     !f.is_qualified(),
                                     "method call in dot chain should not be namespace-qualified"

src/eval/chaining.rs

@@ -63,16 +63,19 @@ impl Engine {
 
             Expr::Variable(_, Some(i), ..) => i.get() as usize,
             Expr::Variable(v, None, ..) => {
+                #[cfg(not(feature = "no_module"))]
+                debug_assert!(v.2.is_empty(), "variable should not be namespace-qualified");
+
                 // Scripted function with the same name
                 #[cfg(not(feature = "no_function"))]
                 if let Some(fn_def) = global
                     .lib
                     .iter()
                     .flat_map(|m| m.iter_script_fn())
-                    .find_map(|(_, _, f, _, func)| if f == v.3 { Some(func) } else { None })
+                    .find_map(|(_, _, f, _, func)| if f == v.1 { Some(func) } else { None })
                 {
                     let val: Dynamic = crate::FnPtr {
-                        name: v.3.clone(),
+                        name: v.1.clone(),
                         curry: <_>::default(),
                         environ: None,
                         fn_def: Some(fn_def.clone()),
@@ -156,14 +159,9 @@ impl Engine {
                 self.search_scope_only(global, caches, scope, this_ptr, expr)
             }
             Expr::Variable(v, None, ..) => match &**v {
-                // Normal variable access
-                (_, ns, ..) if ns.is_empty() => {
-                    self.search_scope_only(global, caches, scope, this_ptr, expr)
-                }
-
                 // Qualified variable access
                 #[cfg(not(feature = "no_module"))]
-                (_, ns, hash_var, var_name) => {
+                (_, var_name, ns, hash_var) if !ns.is_empty() => {
                     // foo:bar::baz::VARIABLE
                     if let Some(module) = self.search_imports(global, ns) {
                         return module.get_qualified_var(*hash_var).map_or_else(
@@ -211,8 +209,8 @@ impl Engine {
                     Err(ERR::ErrorModuleNotFound(ns.to_string(), ns.position()).into())
                 }
 
-                #[cfg(feature = "no_module")]
-                _ => unreachable!("Invalid expression {:?}", expr),
+                // Normal variable access
+                _ => self.search_scope_only(global, caches, scope, this_ptr, expr),
             },
             _ => unreachable!("Expr::Variable expected but gets {:?}", expr),
         }

src/eval/expr.rs

@@ -336,7 +336,7 @@ impl Engine {
                     // Cannot assign to temp result from expression
                     if is_temp_result {
                         return Err(ERR::ErrorAssignmentToConstant(
-                            x.3.to_string(),
+                            x.1.to_string(),
                             lhs.position(),
                         )
                         .into());
@@ -850,7 +850,7 @@ impl Engine {
                             if scope.len() >= self.max_variables() {
                                 return Err(ERR::ErrorTooManyVariables(catch_var.position()).into());
                             }
-                            scope.push(x.3.clone(), err_value);
+                            scope.push(x.1.clone(), err_value);
                         }
 
                         let this_ptr = this_ptr.as_deref_mut();