core: tokenizer recognize extra whitespace/line terminators; create arguments object for constructors; throw TypeError for non-constructors; support spread assignment parsing

Author: ssrlive

src/core/eval.rs

@@ -2765,7 +2765,34 @@ fn evaluate_expr_assign<'gc>(
                 Err(EvalError::Js(raise_eval_error!("Cannot assign to property of non-object")))
             }
         }
-        _ => todo!("Assignment target not supported"),
+        _ => {
+            // Diagnostic: report the specific Expr variant of the unsupported assignment target
+            let variant = match target {
+                Expr::Var(_, _, _) => "Var",
+                Expr::Property(_, _) => "Property",
+                Expr::Index(_, _) => "Index",
+                Expr::Array(_) => "Array",
+                Expr::Object(_) => "Object",
+                Expr::Spread(_) => "Spread",
+                Expr::Call(_, _) => "Call",
+                Expr::New(_, _) => "New",
+                Expr::Function(_, _, _) => "Function",
+                Expr::ArrowFunction(_, _) => "ArrowFunction",
+                Expr::Assign(_, _) => "Assign",
+                Expr::Comma(_, _) => "Comma",
+                Expr::OptionalProperty(_, _) => "OptionalProperty",
+                Expr::OptionalIndex(_, _) => "OptionalIndex",
+                Expr::OptionalCall(_, _) => "OptionalCall",
+                Expr::TaggedTemplate(_, _, _) => "TaggedTemplate",
+                Expr::TemplateString(_) => "TemplateString",
+                Expr::GeneratorFunction(_, _, _) => "GeneratorFunction",
+                Expr::AsyncFunction(_, _, _) => "AsyncFunction",
+                Expr::AsyncArrowFunction(_, _) => "AsyncArrowFunction",
+                _ => "Other",
+            };
+            log::error!("Unsupported assignment target reached in evaluate_expr_assign: {}", variant);
+            Err(EvalError::Js(raise_eval_error!("Assignment target not supported")))
+        }
     }
 }
 
@@ -4897,7 +4924,32 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
             evaluate_expr(mc, env, left)?;
             evaluate_expr(mc, env, right)
         }
-        Expr::Assign(target, value_expr) => evaluate_expr_assign(mc, env, target, value_expr),
+        Expr::Assign(target, value_expr) => {
+            // Diagnostic: log the assignment target variant to help identify unsupported targets
+            let target_variant = match &**target {
+                Expr::Var(_, _, _) => "Var",
+                Expr::Property(_, _) => "Property",
+                Expr::Index(_, _) => "Index",
+                Expr::Spread(inner) => {
+                    // log inner variant for better diagnostics
+                    let inner_variant = match &**inner {
+                        Expr::Array(_) => "Array",
+                        Expr::Index(_, _) => "Index",
+                        Expr::Property(_, _) => "Property",
+                        Expr::Var(_, _, _) => "Var",
+                        Expr::Call(_, _) => "Call",
+                        _ => "Other",
+                    };
+                    log::debug!("evaluate_expr: Assign target is Spread with inner variant = {}", inner_variant);
+                    "Spread"
+                }
+                Expr::Array(_) => "Array",
+                Expr::Object(_) => "Object",
+                _ => "Other",
+            };
+            log::debug!("evaluate_expr: Assign target variant = {}", target_variant);
+            evaluate_expr_assign(mc, env, target, value_expr)
+        }
         Expr::AddAssign(target, value_expr) => evaluate_expr_add_assign(mc, env, target, value_expr),
         Expr::SubAssign(target, value_expr) => evaluate_expr_sub_assign(mc, env, target, value_expr),
         Expr::MulAssign(target, value_expr) => evaluate_expr_mul_assign(mc, env, target, value_expr),
@@ -7041,6 +7093,9 @@ fn evaluate_expr_new<'gc>(
                                 _ => {}
                             }
                         }
+
+                        crate::js_class::create_arguments_object(mc, &call_env, &eval_args)?;
+
                         let body_clone = cl.body.clone();
                         match evaluate_statements_with_labels(mc, &call_env, &body_clone, &[], &[])? {
                             ControlFlow::Return(Value::Object(obj)) => Ok(Value::Object(obj)),
@@ -7163,7 +7218,7 @@ fn evaluate_expr_new<'gc>(
                 Err(EvalError::Js(raise_type_error!("Not a constructor")))
             }
         }
-        _ => todo!("New expression with non-object constructor not implemented yet"),
+        _ => Err(EvalError::Js(raise_type_error!("Not a constructor"))),
     }
 }
 

src/core/parser.rs

@@ -2248,7 +2248,11 @@ fn parse_primary(tokens: &[TokenData], index: &mut usize, allow_call: bool) -> R
             Expr::Decrement(Box::new(inner))
         }
         Token::Spread => {
-            let inner = parse_primary(tokens, index, true)?;
+            // Parse the inner expression as an AssignmentExpression so that
+            // constructs like `...target = source` are parsed as `Spread(Assign(...))`
+            // rather than `Assign(Spread(...))` which would make `Spread` the
+            // assignment target (invalid for assignment).
+            let inner = parse_assignment(tokens, index)?;
             Expr::Spread(Box::new(inner))
         }
         Token::TemplateString(parts) => {

src/core/token.rs

@@ -217,11 +217,13 @@ pub fn tokenize(expr: &str) -> Result<Vec<TokenData>, JSError> {
     while i < chars.len() {
         let start_col = column;
         match chars[i] {
-            ' ' | '\t' | '\r' => {
+            // Treat common whitespace characters (including VT, FF, NBSP) as whitespace
+            ' ' | '\t' | '\r' | '\u{000B}' | '\u{000C}' | '\u{00A0}' => {
                 i += 1;
                 column += 1;
             }
-            '\n' => {
+            // Line terminators: LF, LS (U+2028), PS (U+2029)
+            '\n' | '\u{2028}' | '\u{2029}' => {
                 tokens.push(TokenData {
                     token: Token::LineTerminator,
                     line,

src/js_class.rs

@@ -90,6 +90,20 @@ pub(crate) fn evaluate_this<'gc>(_mc: &MutationContext<'gc>, env: &JSObjectDataP
     Ok(Value::Object(last_seen))
 }
 
+pub fn create_arguments_object<'gc>(
+    mc: &MutationContext<'gc>,
+    func_env: &JSObjectDataPtr<'gc>,
+    evaluated_args: &[Value<'gc>],
+) -> Result<(), JSError> {
+    let arguments_obj = crate::js_array::create_array(mc, func_env)?;
+    crate::js_array::set_array_length(mc, &arguments_obj, evaluated_args.len())?;
+    for (i, arg) in evaluated_args.iter().enumerate() {
+        object_set_key_value(mc, &arguments_obj, i, arg.clone())?;
+    }
+    object_set_key_value(mc, func_env, "arguments", Value::Object(arguments_obj))?;
+    Ok(())
+}
+
 pub(crate) fn evaluate_new<'gc>(
     mc: &MutationContext<'gc>,
     env: &JSObjectDataPtr<'gc>,
@@ -167,6 +181,9 @@ pub(crate) fn evaluate_new<'gc>(
                         Some(env),
                     )?;
 
+                    // Create the arguments object
+                    create_arguments_object(mc, &func_env, evaluated_args)?;
+
                     // Execute constructor body
                     evaluate_statements(mc, &func_env, body)?;
 
@@ -452,6 +469,8 @@ pub(crate) fn evaluate_new<'gc>(
                 Some(env),
             )?;
 
+            create_arguments_object(mc, &func_env, evaluated_args)?;
+
             // Execute function body
             evaluate_statements(mc, &func_env, body)?;