Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
refactor(webapi): add native cross-origin member declarations
ldm0b4f9a9677fc2
diff --git a/moli-webapi-declare-derive/src/expand.rs b/moli-webapi-declare-derive/src/expand.rsindex e1b8060e9..1a2d0400c 100644--- a/moli-webapi-declare-derive/src/expand.rs+++ b/moli-webapi-declare-derive/src/expand.rs@@ -15,6 +15,9 @@ struct DeclaredField {attrs: FieldAttrs,}+mod cross_origin;+pub(crate) use cross_origin::expand_webapi_cross_origin;+fn declared_fields(data: &Data,rename_all: RenameRule,diff --git a/moli-webapi-declare-derive/src/expand/cross_origin.rs b/moli-webapi-declare-derive/src/expand/cross_origin.rsnew file mode 100644index 000000000..c65d2a0f4--- /dev/null+++ b/moli-webapi-declare-derive/src/expand/cross_origin.rs@@ -0,0 +1,234 @@+use super::*;++pub(crate) fn expand_webapi_cross_origin(+ input: DeriveInput,+) -> Result<proc_macro2::TokenStream, Error> {+ let name = &input.ident;+ if !input.generics.params.is_empty() {+ return Err(Error::new_spanned(+ &input.generics,+ "cross-origin declarations cannot carry runtime state",+ ));+ }+ let attrs = parse_object_attrs(&input.attrs)?;+ if !matches!(attrs.role, None | Some(ObjectRole::Plain))+ || attrs.prototype.is_some()+ || attrs.own_to_string_tag.is_some()+ || attrs.fallback_to_string_tag.is_some()+ || attrs.scope_lifetime.is_some()+ || attrs.default_data_properties+ || attrs.default_enumerable+ {+ return Err(Error::new_spanned(+ input,+ "cross-origin declarations describe stateless property tables, not object initialization",+ ));+ }+ let fields = declared_fields(+ &input.data,+ attrs.rename_all,+ FieldDefaults {+ receiver: attrs.receiver.as_ref(),+ ..FieldDefaults::default()+ },+ )?;+ let mut helpers = Vec::new();+ let mut entries = Vec::new();+ for DeclaredField { field, attrs } in fields {+ if !type_is_unit(&field.ty)+ || attrs.data.is_some()+ || attrs.setter_data.is_some()+ || attrs.returns_promise+ || attrs.symbol.is_some()+ || attrs.getter_value.is_some()+ || attrs.value.is_some()+ || attrs.init.is_some()+ || attrs.enumerable+ || attrs.dont_delete+ {+ return Err(Error::new_spanned(+ field,+ "cross-origin members must be stateless string-keyed methods or accessors",+ ));+ }+ let property_name = match attrs.name.as_ref() {+ Some(syn::Expr::Lit(syn::ExprLit {+ lit: Lit::Str(name),+ ..+ })) => name.clone(),+ _ => {+ return Err(Error::new_spanned(+ &field,+ "cross-origin member names must be string literals",+ ));+ }+ };+ let ident = field.ident.as_ref().expect("named field");+ let receiver_check = attrs.receiver.as_ref().map(|receiver| {+ quote! {+ if !#receiver(__moli_scope, __moli_receiver) {+ ::moli_webapi_declare::__private::throw_illegal_invocation(__moli_scope);+ return None;+ }+ }+ });+ let function = |suffix: &str,+ callback: proc_macro2::TokenStream,+ length: i32,+ function_name: LitStr| {+ let factory = format_ident!("__cross_origin_{}_{}_template", ident, suffix);+ let helper = quote! {+ fn #factory<'s>(+ scope: &::moli_webapi_declare::v8::PinScope<'s, '_>,+ ) -> ::moli_webapi_declare::v8::Local<'s, ::moli_webapi_declare::v8::FunctionTemplate> {+ let template = ::moli_webapi_declare::v8::FunctionTemplate::builder(#callback)+ .length(#length)+ .constructor_behavior(::moli_webapi_declare::v8::ConstructorBehavior::Throw)+ .build(scope);+ template.remove_prototype();+ template.set_class_name(::moli_webapi_declare::__private::v8str(scope, #function_name));+ template+ }+ };+ (+ helper,+ quote!(::moli_webapi_declare::CrossOriginFunction { build: Self::#factory }),+ )+ };+ match attrs.kind {+ FieldKind::Method => {+ let callback = attrs+ .callback+ .as_ref()+ .ok_or_else(|| Error::new_spanned(&field, "method requires callback"))?;+ let callback = expand_callback(callback, &attrs, false);+ let (helper, function) = function(+ "method",+ callback,+ attrs.length.unwrap_or(0),+ property_name.clone(),+ );+ helpers.push(helper);+ entries.push(quote! {+ ::moli_webapi_declare::CrossOriginProperty::Method { name: #property_name, function: #function }+ });+ }+ FieldKind::AccessorProperty => {+ if attrs.getter.is_none() && attrs.setter.is_none() {+ return Err(Error::new_spanned(+ field,+ "cross-origin accessor requires a getter or setter",+ ));+ }+ let mut accessors = Vec::new();+ for (suffix, callback, length) in [+ ("get", attrs.getter.as_ref(), 0),+ ("set", attrs.setter.as_ref(), 1),+ ] {+ let Some(callback) = callback else {+ accessors.push(quote!(None));+ continue;+ };+ let value_helper = format_ident!("__cross_origin_{}_{}", ident, suffix);+ let callback_helper =+ format_ident!("__cross_origin_{}_{}_callback", ident, suffix);+ let function_name = LitStr::new(+ &format!("{suffix} {}", property_name.value()),+ property_name.span(),+ );+ let (helper, function) = function(+ suffix,+ quote!(Self::#callback_helper),+ length,+ function_name,+ );+ helpers.push(helper);+ if length == 0 {+ helpers.push(quote! {+ fn #value_helper<'s>(+ __moli_scope: &mut ::moli_webapi_declare::v8::PinScope<'s, '_>,+ __moli_receiver: ::moli_webapi_declare::v8::Local<'s, ::moli_webapi_declare::v8::Object>,+ ) -> Option<::moli_webapi_declare::v8::Local<'s, ::moli_webapi_declare::v8::Value>> {+ #receiver_check+ #callback(__moli_scope, __moli_receiver)+ }+ fn #callback_helper<'s>(+ __moli_scope: &mut ::moli_webapi_declare::v8::PinScope<'s, '_>,+ args: ::moli_webapi_declare::v8::FunctionCallbackArguments<'s>,+ mut rv: ::moli_webapi_declare::v8::ReturnValue<'s>,+ ) {+ if let Some(value) = Self::#value_helper(__moli_scope, args.this()) { rv.set(value); }+ }+ });+ } else {+ helpers.push(quote! {+ fn #value_helper<'s>(+ __moli_scope: &mut ::moli_webapi_declare::v8::PinScope<'s, '_>,+ __moli_receiver: ::moli_webapi_declare::v8::Local<'s, ::moli_webapi_declare::v8::Object>,+ value: ::moli_webapi_declare::v8::Local<'s, ::moli_webapi_declare::v8::Value>,+ ) -> Option<()> {+ #receiver_check+ #callback(__moli_scope, __moli_receiver, value)+ }+ fn #callback_helper<'s>(+ __moli_scope: &mut ::moli_webapi_declare::v8::PinScope<'s, '_>,+ args: ::moli_webapi_declare::v8::FunctionCallbackArguments<'s>,+ _rv: ::moli_webapi_declare::v8::ReturnValue<'s>,+ ) {+ let _ = Self::#value_helper(__moli_scope, args.this(), args.get(0));+ }+ });+ }+ accessors.push(quote!(Some((Self::#value_helper, #function))));+ }+ let getter = &accessors[0];+ let setter = &accessors[1];+ entries.push(quote! {+ ::moli_webapi_declare::CrossOriginProperty::Accessor {+ name: #property_name, getter: #getter, setter: #setter,+ }+ });+ }+ _ => {+ return Err(Error::new_spanned(+ &field,+ "cross-origin declarations only support method and accessor_property",+ ));+ }+ }+ }+ Ok(quote! {+ impl #name { #(#helpers)* }+ impl ::moli_webapi_declare::WebApiCrossOriginDeclaration for #name {+ fn cross_origin_properties() -> &'static [::moli_webapi_declare::CrossOriginProperty] {+ &[#(#entries),*]+ }+ }+ })+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn rejects_declarations_that_would_capture_runtime_state() {+ let invalid: [DeriveInput; 3] = [+ syn::parse_quote! {+ #[webapi(plain)]+ struct Bad<T> { #[webapi(method, callback = callback)] operation: T }+ },+ syn::parse_quote! {+ #[webapi(plain)]+ struct Bad { #[webapi(method, callback = callback, data = self.state)] operation: (), state: usize }+ },+ syn::parse_quote! {+ #[webapi(plain)]+ struct Bad { #[webapi(method, name = runtime_name(), callback = callback)] operation: () }+ },+ ];+ for input in invalid {+ assert!(expand_webapi_cross_origin(input).is_err());+ }+ }+}diff --git a/moli-webapi-declare-derive/src/lib.rs b/moli-webapi-declare-derive/src/lib.rsindex 71f4e95a4..e1c401f15 100644--- a/moli-webapi-declare-derive/src/lib.rs+++ b/moli-webapi-declare-derive/src/lib.rs@@ -4,6 +4,17 @@ mod expand;use proc_macro::TokenStream;use syn::{DeriveInput, parse_macro_input};+/// Declares native cross-origin methods and accessors without an intermediate+/// JavaScript object. Accessor callbacks return Option<Value> / Option<()> and+/// are also adapted to realm-correct descriptor functions.+#[proc_macro_derive(WebApiCrossOrigin, attributes(webapi))]+pub fn derive_webapi_cross_origin(input: TokenStream) -> TokenStream {+ match expand::expand_webapi_cross_origin(parse_macro_input!(input as DeriveInput)) {+ Ok(tokens) => tokens.into(),+ Err(error) => error.to_compile_error().into(),+ }+}+/// Derives a Web API function-template declaration binder.////// The generated implementation creates a V8 `FunctionTemplate`, sets its classdiff --git a/moli-webapi-declare/src/cross_origin.rs b/moli-webapi-declare/src/cross_origin.rsnew file mode 100644index 000000000..b0bbc0af9--- /dev/null+++ b/moli-webapi-declare/src/cross_origin.rs@@ -0,0 +1,174 @@+//! Native cross-origin member declarations. Templates contain callback metadata+//! only; V8 owns each context's unique function instance and its lifetime.++use std::collections::HashMap;++use moli_v8_util::v8str;++pub type CrossOriginGetter = for<'s, 'i> fn(+ &mut v8::PinScope<'s, 'i>,+ v8::Local<'s, v8::Object>,+) -> Option<v8::Local<'s, v8::Value>>;+pub type CrossOriginSetter = for<'s, 'i> fn(+ &mut v8::PinScope<'s, 'i>,+ v8::Local<'s, v8::Object>,+ v8::Local<'s, v8::Value>,+) -> Option<()>;++pub struct CrossOriginFunction {+ pub build: for<'s, 'i> fn(&v8::PinScope<'s, 'i>) -> v8::Local<'s, v8::FunctionTemplate>,+}++#[derive(Default)]+struct FunctionTemplates(HashMap<usize, v8::Global<v8::FunctionTemplate>>);++impl CrossOriginFunction {+ pub fn get<'s>(+ &'static self,+ scope: &mut v8::PinScope<'s, '_>,+ ) -> Option<v8::Local<'s, v8::Function>> {+ // The key identifies an immutable declaration member, never a Window+ // or a realm. No callback data can retain a target or an observer.+ let key = self as *const Self as usize;+ let cached = scope+ .get_slot::<FunctionTemplates>()+ .and_then(|templates| templates.0.get(&key))+ .map(|template| v8::Local::new(scope, template));+ let template = match cached {+ Some(template) => template,+ None => {+ let template = (self.build)(scope);+ let retained = v8::Global::new(scope, template);+ if scope.get_slot::<FunctionTemplates>().is_none() {+ scope.set_slot(FunctionTemplates::default());+ }+ scope+ .get_slot_mut::<FunctionTemplates>()+ .expect("template store was initialized")+ .0+ .insert(key, retained);+ template+ }+ };+ template.get_function(scope)+ }+}++pub enum CrossOriginProperty {+ Method {+ name: &'static str,+ function: CrossOriginFunction,+ },+ Accessor {+ name: &'static str,+ getter: Option<(CrossOriginGetter, CrossOriginFunction)>,+ setter: Option<(CrossOriginSetter, CrossOriginFunction)>,+ },+}++impl CrossOriginProperty {+ pub const fn name(&self) -> &'static str {+ match self {+ Self::Method { name, .. } | Self::Accessor { name, .. } => name,+ }+ }++ pub fn get<'s>(+ &'static self,+ scope: &mut v8::PinScope<'s, '_>,+ receiver: v8::Local<'s, v8::Object>,+ ) -> Option<v8::Local<'s, v8::Value>> {+ match self {+ Self::Method { function, .. } => function.get(scope).map(Into::into),+ Self::Accessor {+ getter: Some((getter, _)),+ ..+ } => getter(scope, receiver),+ _ => None,+ }+ }++ pub fn set<'s>(+ &'static self,+ scope: &mut v8::PinScope<'s, '_>,+ receiver: v8::Local<'s, v8::Object>,+ value: v8::Local<'s, v8::Value>,+ ) -> Option<()> {+ match self {+ Self::Accessor {+ setter: Some((setter, _)),+ ..+ } => setter(scope, receiver, value),+ _ => None,+ }+ }++ pub const fn has_getter(&self) -> bool {+ matches!(+ self,+ Self::Method { .. }+ | Self::Accessor {+ getter: Some(_),+ ..+ }+ )+ }++ pub const fn has_setter(&self) -> bool {+ matches!(+ self,+ Self::Accessor {+ setter: Some(_),+ ..+ }+ )+ }++ pub fn descriptor<'s>(+ &'static self,+ scope: &mut v8::PinScope<'s, '_>,+ ) -> Option<v8::Local<'s, v8::Object>> {+ let descriptor = v8::Object::new(scope);+ let fields: [(&str, v8::Local<v8::Value>); 2] = match self {+ Self::Method { function, .. } => [+ ("value", function.get(scope)?.into()),+ ("writable", v8::Boolean::new(scope, false).into()),+ ],+ Self::Accessor { getter, setter, .. } => {+ let get = match getter {+ Some((_, function)) => function.get(scope)?.into(),+ None => v8::undefined(scope).into(),+ };+ let set = match setter {+ Some((_, function)) => function.get(scope)?.into(),+ None => v8::undefined(scope).into(),+ };+ [("get", get), ("set", set)]+ }+ };+ for (name, value) in fields.into_iter().chain([+ ("enumerable", v8::Boolean::new(scope, false).into()),+ ("configurable", v8::Boolean::new(scope, true).into()),+ ]) {+ descriptor+ .define_own_property(+ scope,+ v8str(scope, name).into(),+ value,+ v8::PropertyAttribute::NONE,+ )+ .filter(|defined| *defined)?;+ }+ Some(descriptor)+ }+}++pub trait WebApiCrossOriginDeclaration {+ fn cross_origin_properties() -> &'static [CrossOriginProperty];++ fn cross_origin_property(name: &str) -> Option<&'static CrossOriginProperty> {+ Self::cross_origin_properties()+ .iter()+ .find(|property| property.name() == name)+ }+}diff --git a/moli-webapi-declare/src/lib.rs b/moli-webapi-declare/src/lib.rsindex a1c8a09c3..0574a1ee7 100644--- a/moli-webapi-declare/src/lib.rs+++ b/moli-webapi-declare/src/lib.rs@@ -5,6 +5,14 @@//! `moli-webidl` and focuses on constructing V8 interface objects,//! prototypes, and branded object instances.//!+//! `#[derive(WebApiCrossOrigin)]` describes a stateless cross-origin property+//! table for native access-check handlers. Methods use ordinary V8 callbacks;+//! accessors use native value callbacks returning `Option`, with receiver+//! predicates checked before either invocation. Function templates are cached+//! per isolate and produce a unique function in each accessing context. The+//! table and templates never capture a target Window or an observer context.+//! Runtime V8 failures propagate to the script execution boundary.+//!//! # Object declaration model//!//! A `#[derive(WebApiObject)]` struct describes the JavaScript surface that must@@ -241,6 +249,7 @@ extern crate self as moli_webapi_declare;mod brand;mod callback;+mod cross_origin;mod declaration;mod error;mod interface;@@ -251,7 +260,7 @@ mod value;pub mod __private;pub use interface::WebApiInterfaceDescriptor;-pub use moli_webapi_declare_derive::{WebApiFunctionTemplate, WebApiObject};+pub use moli_webapi_declare_derive::{WebApiCrossOrigin, WebApiFunctionTemplate, WebApiObject};pub use v8;/// Adapts a manual native constructor to the same identity initialization used@@ -282,6 +291,10 @@ pub use brand::{register_web_api_proxy, web_api_object_target, web_api_object_type,};+pub use cross_origin::{+ CrossOriginFunction, CrossOriginGetter, CrossOriginProperty, CrossOriginSetter,+ WebApiCrossOriginDeclaration,+};pub use declaration::{DataPropertyDescriptorDeclaration, ObjectLiteralDeclaration, WebApiFunctionTemplateDeclaration,WebApiObjectDeclaration,diff --git a/moli-webapi-declare/tests/cross_origin.rs b/moli-webapi-declare/tests/cross_origin.rsnew file mode 100644index 000000000..595d69603--- /dev/null+++ b/moli-webapi-declare/tests/cross_origin.rs@@ -0,0 +1,182 @@+use std::pin::pin;++use moli_v8_test_util::ensure_v8;+use moli_v8_util::{get_private_value, set_private_value, v8str};+use moli_webapi_declare::{WebApiCrossOrigin, WebApiCrossOriginDeclaration};++const VALUE: &str = "__crossOriginTestValue";++fn receiver<'s>(scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>) -> bool {+ get_private_value(scope, object, VALUE).is_some()+}++fn get<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,+) -> Option<v8::Local<'s, v8::Value>> {+ get_private_value(scope, object, VALUE)+}++fn set<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,+ value: v8::Local<'s, v8::Value>,+) -> Option<()> {+ let value = value.to_string(scope)?;+ set_private_value(scope, object, VALUE, value.into());+ Some(())+}++fn method<'s>(+ _scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'s>,+) {+ rv.set(args.this().into());+}++// Fields are declaration metadata; no runtime object carries this state.+#[allow(dead_code)]+#[derive(WebApiCrossOrigin)]+#[webapi(plain, receiver = receiver)]+struct Members {+ #[webapi(method, length = 1, callback = method)]+ operation: (),+ #[webapi(accessor_property, getter = get, setter = set)]+ value: (),+ #[webapi(accessor_property, setter = set)]+ write_only: (),+}++fn eval<'s>(scope: &mut v8::PinScope<'s, '_>, source: &str) -> v8::Local<'s, v8::Value> {+ let source = v8::String::new(scope, source).unwrap();+ v8::Script::compile(scope, source, None)+ .unwrap()+ .run(scope)+ .unwrap()+}++#[test]+fn native_members_share_templates_but_keep_functions_in_the_accessing_context() {+ ensure_v8();+ let mut isolate = v8::Isolate::new(Default::default());+ let scope = pin!(v8::HandleScope::new(&mut isolate));+ let scope = &mut scope.init();+ let a = v8::Context::new(scope, Default::default());+ let b = v8::Context::new(scope, Default::default());+ let member = Members::cross_origin_property("operation").unwrap();+ let function_a = {+ let scope = &mut v8::ContextScope::new(scope, a);+ let object = v8::Object::new(scope);+ let value = v8str(scope, "initial");+ set_private_value(scope, object, VALUE, value.into());+ let function = member.get(scope, object).unwrap();+ assert!(function.strict_equals(member.get(scope, object).unwrap()));+ let global = a.global(scope);+ global+ .set(scope, v8str(scope, "object").into(), object.into())+ .unwrap();+ for (name, value) in [+ ("method", function),+ ("methodDescriptor", member.descriptor(scope).unwrap().into()),+ (+ "descriptor",+ Members::cross_origin_property("value")+ .unwrap()+ .descriptor(scope)+ .unwrap()+ .into(),+ ),+ (+ "writeOnly",+ Members::cross_origin_property("writeOnly")+ .unwrap()+ .descriptor(scope)+ .unwrap()+ .into(),+ ),+ ] {+ global.set(scope, v8str(scope, name).into(), value).unwrap();+ }+ assert!(eval(scope, r#"+ (() => {+ function throwsTypeError(callback) { try { callback(); } catch (e) { return e instanceof TypeError; } return false; }+ if (Object.getPrototypeOf(method) !== Function.prototype || method.name !== 'operation' || method.length !== 1 || Object.hasOwn(method, 'prototype')) return false;+ if (method.call(object) !== object || !throwsTypeError(() => method.call({})) || !throwsTypeError(() => new method())) return false;+ if (methodDescriptor.writable || methodDescriptor.enumerable || !methodDescriptor.configurable) return false;+ if (descriptor.get.name !== 'get value' || descriptor.get.length !== 0 || descriptor.set.name !== 'set value' || descriptor.set.length !== 1 || descriptor.enumerable || !descriptor.configurable) return false;+ if (descriptor.get.call(object) !== 'initial' || !throwsTypeError(() => descriptor.get.call({}))) return false;+ let conversions = 0;+ if (!throwsTypeError(() => descriptor.set.call({}, {toString() { conversions++; return 'bad'; }})) || conversions !== 0) return false;+ const exception = new Error('conversion');+ try { descriptor.set.call(object, {toString() { throw exception; }}); return false; } catch (e) { if (e !== exception) return false; }+ descriptor.set.call(object, 'updated');+ return descriptor.get.call(object) === 'updated' && writeOnly.get === undefined && writeOnly.set.name === 'set writeOnly';+ })()+ "#).is_true());+ v8::Global::new(scope, function)+ };+ let scope = &mut v8::ContextScope::new(scope, b);+ let object = v8::Object::new(scope);+ let function_b = member.get(scope, object).unwrap();+ let function_a = v8::Local::new(scope, &function_a);+ assert!(!function_a.strict_equals(function_b));+ let function_b = v8::Local::<v8::Object>::try_from(function_b).unwrap();+ assert!(+ function_b+ .get_prototype(scope)+ .unwrap()+ .strict_equals(eval(scope, "Function.prototype"))+ );+}++#[test]+fn native_member_failure_propagates_script_termination() {+ ensure_v8();+ let mut isolate = v8::Isolate::new(Default::default());+ let scope = pin!(v8::HandleScope::new(&mut isolate));+ let scope = &mut scope.init();+ let context = v8::Context::new(scope, Default::default());+ let scope = &mut v8::ContextScope::new(scope, context);+ let member = Members::cross_origin_property("value").unwrap();+ let object = v8::Object::new(scope);+ let value = v8str(scope, "initial");+ set_private_value(scope, object, VALUE, value.into());+ let input = v8::Object::new(scope);+ {+ v8::tc_scope!(let scope, scope);+ scope.terminate_execution();+ assert!(member.set(scope, object, input.into()).is_none());+ assert!(+ scope.has_terminated(),+ "termination must reach the execution boundary"+ );+ assert!(!scope.can_continue());+ scope.cancel_terminate_execution();+ }+ assert!(member.set(scope, object, input.into()).is_some());+}++#[test]+fn isolate_template_cache_does_not_retain_an_accessing_context() {+ ensure_v8();+ let mut isolate = v8::Isolate::new(Default::default());+ let weak = {+ let scope = pin!(v8::HandleScope::new(&mut isolate));+ let scope = &mut scope.init();+ let context = v8::Context::new(scope, Default::default());+ let scope = &mut v8::ContextScope::new(scope, context);+ let object = v8::Object::new(scope);+ assert!(+ Members::cross_origin_property("operation")+ .unwrap()+ .get(scope, object)+ .is_some()+ );+ v8::Weak::new(scope, context)+ };+ isolate.low_memory_notification();+ let scope = pin!(v8::HandleScope::new(&mut isolate));+ let scope = &mut scope.init();+ assert!(weak.to_local(scope).is_none());+}