Impossible d'utiliser un néon JsArray: Cette fonction prend 3 paramètres mais 2 ont été fournis

Question

J'apprends à utiliser le néon, mais je ne comprends rien. Si je tente d'exécuter ce code:

#[macro_use] 
extern crate neon; 
use neon::vm::{Call, JsResult}; 
use neon::mem::Handle; 
use neon::js::{JsInteger, JsNumber, JsString, JsObject, JsArray, JsValue, Object, Key}; 
use neon::js::error::{JsError, Kind}; 

fn test(call: Call) -> JsResult<JsArray> { 
    let scope = call.scope; 
    let js_arr: Handle<JsArray> = try!(try!(call.arguments.require(scope, 1)).check::<JsArray>()); 

    js_arr.set(0, JsNumber::new(scope, 1000)); 

    Ok(js_arr) 
} 

register_module!(m, { 
    m.export("test", test) 
}); 

Je reçois cette erreur quand je l'appelle js_arr.set: This function takes 3 parameters but 2 were supplied.

Je ne comprends pas pourquoi car il est un JsArray. Même Racer me dit que la méthode set prend 2 paramètres. Peu importe quoi, js_arr.set prend 3 paramètres dans cet ordre: &mut bool, neon::macro_internal::runtime::raw::Local et neon::macro_internal::runtime::raw::Local.

Que se passe-t-il? Je ne peux pas comprendre comment fonctionne JsArray.

Answer 1

En tant que paulsevere says on a GitHub issue for Neon, importez neon::js::Object. En outre, ne pas importation Key, qui fournit également une méthode set:

#[macro_use] 
extern crate neon; 

use neon::vm::{Call, JsResult}; 
use neon::js::{Object, JsArray, JsInteger, JsObject, JsNumber}; 

fn make_an_array(call: Call) -> JsResult<JsArray> { 
    let scope = call.scope; // the current scope for rooting handles 
    let array = JsArray::new(scope, 3); 
    array.set(0, JsInteger::new(scope, 9000))?; 
    array.set(1, JsObject::new(scope))?; 
    array.set(2, JsNumber::new(scope, 3.14159))?; 
    Ok(array) 
} 

register_module!(m, { 
    m.export("main", make_an_array) 
}); 

Cela crée une toute nouvelle gamme. Si vous souhaitez accepter un tableau comme premier argument à votre fonction, puis le modifier, cela fonctionne:

#[macro_use] 
extern crate neon; 

use neon::vm::{Call, JsResult}; 
use neon::js::{Object, JsArray, JsInteger, JsUndefined}; 
use neon::mem::Handle; 

fn hello(call: Call) -> JsResult<JsUndefined> { 
    let scope = call.scope; 
    let js_arr: Handle<JsArray> = call.arguments.require(scope, 0)?.check::<JsArray>()?; 

    js_arr.set(0, JsInteger::new(scope, 1000))?; 

    Ok(JsUndefined::new()) 
} 

register_module!(m, { 
    m.export("hello", hello) 
}); 

Answer 2

let js_arr: Handle<JsArray> montre clairement que js_arr est un Handle<JsArray> et Handle<T> a cette méthode:

unsafe fn set(self, out: &mut bool, obj: Local, val: Local) -> bool 

Je suppose que vous essayez d'appeler accidentellement Handle::set (qui est unsafe et prend trois arguments non self) plutôt que JsArray::set (qui est sûr et prend deux arguments non self).

Si c'est le cas, vous devez forcer deref_mut à se produire. (_mut parce JsArray::set prend &mut self.)

Je n'ai pas courir dans ce genre de collision nommant avant, donc je ne peux pas être certain que le auto-deref est assez intelligent, mais quelque chose comme cela peut fonctionner:

(&mut js_arr).set(0, JsNumber::new(scope, 1000)); 

A défaut, deux autres choses à essayer sont:

1. JsArray::set(&mut js_arr, 0, JsNumber::new(scope, 1000));

   (Si l'exemple précédent échoue parce que cela ressemble trop à une surcharge de méthode de style C++. Ceci est connu comme Fully Qualified Syntax et est normalement utilisé pour désambiguïser lorsqu'un objet implémente deux traits qui fournissent des méthodes du même nom.)

2. Appelez js_arr.deref_mut() directement pour obtenir une référence mutable à la JsArray sous-jacente, puis appelez set sur ce point.