generic

bindings
everything compiles 👏
retep007
Unified Split

Showing 352 changed files with 11,513 additions and 9,600 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/components/dom_struct/Cargo.toml b/components/dom_struct/Cargo.toml
@@ -8,3 +8,7 @@ publish = false
 [lib]
 path = "lib.rs"
 proc-macro = true
+  
+
+  
+[dependencies]
+  
+syn = "0.13.1"
+  
+quote = "0.5.1"
diff --git a/components/dom_struct/lib.rs b/components/dom_struct/lib.rs
@@ -5,16 +5,23 @@
 #![feature(proc_macro)]
 extern crate proc_macro;
+  
+extern crate syn;
+  
+#[macro_use] extern crate quote;
-  
-use proc_macro::{TokenStream, quote};
+  
+use proc_macro::{TokenStream};
+  
+use syn::DeriveInput;
 #[proc_macro_attribute]
 pub fn dom_struct(args: TokenStream, input: TokenStream) -> TokenStream {
+  
+    let mut base = quote! {};
    if !args.is_empty() {
-  
-        panic!("#[dom_struct] takes no arguments");
+  
+        let args = args.to_string();
+  
+        let crater = args.trim_matches(&['(', ')', ' '][..]);
+  
+        base = quote! {#[base = #crater]};
    }
    let attributes = quote! {
-  
-        #[derive(DenyPublicFields, DomObject, JSTraceable, MallocSizeOf)]
+  
+        #[derive(DomObject, DenyPublicFields, JSTraceable, MallocSizeOf)]
+  
+        #base
        #[must_root]
        #[repr(C)]
    };

diff --git a/components/domobject_derive/lib.rs b/components/domobject_derive/lib.rs
@@ -3,18 +3,36 @@
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #![recursion_limit = "128"]
+  
+#![feature(log_syntax)]
 extern crate proc_macro;
 #[macro_use] extern crate quote;
 #[macro_use] extern crate syn;
-  
-#[proc_macro_derive(DomObject)]
+  
+use quote::ToTokens;
+  
+
+  
+#[proc_macro_derive(DomObject, attributes(base))]
 pub fn expand_token_stream(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = syn::parse(input).unwrap();
    expand_dom_object(input).into()
 }
 fn expand_dom_object(input: syn::DeriveInput) -> quote::Tokens {
+  
+    let attrs = input.attrs.iter().filter(|attr| match attr.interpret_meta().unwrap() {
+  
+        syn::Meta::NameValue(syn::MetaNameValue { ref ident, .. }) if ident == "base" => {
+  
+            true
+  
+        }
+  
+        _ => false,
+  
+    }).collect::<Vec<_>>();
+  
+    let mut base = quote::Tokens::new();
+  
+    let mut th = quote!{TH};
+  
+    if attrs.len() > 0 {
+  
+            if let syn::Meta::NameValue(syn::MetaNameValue { lit: syn::Lit::Str(st), .. }) = attrs[0].interpret_meta().unwrap() {
+  
+                syn::Ident::from(&st.value()[..]).to_tokens(&mut base);
+  
+                th = quote!{TypeHolder};
+  
+            }
+  
+    }
+  
+
    let fields = if let syn::Data::Struct(syn::DataStruct { ref fields, .. }) = input.data {
        fields.iter().collect::<Vec<&syn::Field>>()
    } else {
@@ -41,53 +59,83 @@ fn expand_dom_object(input: syn::DeriveInput) -> quote::Tokens {
            unsafe fn to_jsval(&self,
                                cx: *mut ::js::jsapi::JSContext,
                                rval: ::js::rust::MutableHandleValue) {
-  
-                let object = ::dom::bindings::reflector::DomObject::reflector(self).get_jsobject();
+  
+                let object = #base::dom::bindings::reflector::DomObject::reflector(self).get_jsobject();
                object.to_jsval(cx, rval)
            }
        }
-  
-        impl #impl_generics ::dom::bindings::reflector::DomObject for #name #ty_generics #where_clause {
+  
+        impl #impl_generics #base::dom::bindings::reflector::DomObject for #name #ty_generics #where_clause {
+  
+            type TypeHolder = #th;
+  
+
            #[inline]
-  
-            fn reflector(&self) -> &::dom::bindings::reflector::Reflector {
+  
+            fn reflector(&self) -> &#base::dom::bindings::reflector::Reflector<Self::TypeHolder> {
                self.#first_field_name.reflector()
            }
        }
-  
-        impl #impl_generics ::dom::bindings::reflector::MutDomObject for #name #ty_generics #where_clause {
+  
+        impl #impl_generics #base::dom::bindings::reflector::MutDomObject for #name #ty_generics #where_clause {
            fn init_reflector(&mut self, obj: *mut ::js::jsapi::JSObject) {
                self.#first_field_name.init_reflector(obj);
            }
        }
    };
+  
+    if name == "IterableIterator" {
+  
+        items = quote! {
+  
+            impl #impl_generics ::js::conversions::ToJSValConvertible for #name #ty_generics #where_clause {
+  
+                #[allow(unsafe_code)]
+  
+                unsafe fn to_jsval(&self,
+  
+                                    cx: *mut ::js::jsapi::JSContext,
+  
+                                    rval: ::js::rust::MutableHandleValue) {
+  
+                    let object = #base::dom::bindings::reflector::DomObject::reflector(self).get_jsobject();
+  
+                    object.to_jsval(cx, rval)
+  
+                }
+  
+            }
+  
+
+  
+            impl #impl_generics #base::dom::bindings::reflector::DomObject for #name #ty_generics #where_clause {
+  
+                type TypeHolder = T::TypeHolder;
+  
+
+  
+                #[inline]
+  
+                fn reflector(&self) -> &#base::dom::bindings::reflector::Reflector<Self::TypeHolder> {
+  
+                    self.#first_field_name.reflector()
+  
+                }
+  
+            }
+  
+
+  
+            impl #impl_generics #base::dom::bindings::reflector::MutDomObject for #name #ty_generics #where_clause {
+  
+                fn init_reflector(&mut self, obj: *mut ::js::jsapi::JSObject) {
+  
+                    self.#first_field_name.init_reflector(obj);
+  
+                }
+  
+            }
+  
+        };
+  
+    }
    let mut params = quote::Tokens::new();
-  
-    params.append_separated(input.generics.type_params().map(|param| param.ident), ", ");
+  
+    params.append_separated(input.generics.type_params().map(|param| param.ident), quote!(,));
+  
+
    // For each field in the struct, we implement ShouldNotImplDomObject for a
    // pair of all the type parameters of the DomObject and and the field type.
    // This allows us to support parameterized DOM objects
    // such as IteratorIterable<T>.
-  
-    items.append_all(field_types.iter().map(|ty| {
-  
-        quote! {
-  
-            impl #impl_generics ShouldNotImplDomObject for ((#params), #ty) #where_clause {}
-  
-        }
-  
-    }));
+  
+    // items.append_all(field_types.iter().map(|ty| {
+  
+    //     quote! {
+  
+    //         impl #impl_generics ShouldNotImplDomObject for ((#params), #ty) #where_clause {}
+  
+    //     }
+  
+    // }));
    let mut generics = input.generics.clone();
-  
-    generics.params.push(parse_quote!(__T: ::dom::bindings::reflector::DomObject));
+  
+    generics.params.push(parse_quote!(__T: #base::dom::bindings::reflector::DomObject));
    let (impl_generics, _, where_clause) = generics.split_for_impl();
-  
-    items.append_all(quote! {
-  
-        trait ShouldNotImplDomObject {}
-  
-        impl #impl_generics ShouldNotImplDomObject for ((#params), __T) #where_clause {}
-  
-    });
+  
+    // items.append_all(quote! {
+  
+    //     trait ShouldNotImplDomObject {}
+  
+    //     impl #impl_generics ShouldNotImplDomObject for ((#params), __T) #where_clause {}
+  
+    // });
    let dummy_const = syn::Ident::from(format!("_IMPL_DOMOBJECT_FOR_{}", name));
    let tokens = quote! {
        #[allow(non_upper_case_globals)]
        const #dummy_const: () = { #items };
    };
-  
-
    tokens
 }
diff --git a/components/jstraceable_derive/lib.rs b/components/jstraceable_derive/lib.rs
@@ -5,36 +5,48 @@
 extern crate quote;
 #[macro_use] extern crate syn;
 #[macro_use] extern crate synstructure;
+  
+use quote::ToTokens;
-  
-decl_derive!([JSTraceable] => js_traceable_derive);
+  
+decl_derive!([JSTraceable, attributes(base)] => js_traceable_derive);
 fn js_traceable_derive(s: synstructure::Structure) -> quote::Tokens {
    let match_body = s.each(|binding| {
        Some(quote!(#binding.trace(tracer);))
    });
    let ast = s.ast();
+  
+    let attrs = ast.attrs.iter().filter(|attr| match attr.interpret_meta().unwrap() {
+  
+        syn::Meta::NameValue(syn::MetaNameValue { ref ident, .. }) if ident == "base" => {
+  
+            true
+  
+        }
+  
+        _ => false,
+  
+    }).collect::<Vec<_>>();
+  
+    let mut base = quote::Tokens::new();
+  
+    if attrs.len() > 0 {
+  
+            if let syn::Meta::NameValue(syn::MetaNameValue { lit: syn::Lit::Str(st), .. }) = attrs[0].interpret_meta().unwrap() {
+  
+                syn::Ident::from(&st.value()[..]).to_tokens(&mut base);
+  
+            }
+  
+    }
    let name = ast.ident;
    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
    let mut where_clause = where_clause.unwrap_or(&parse_quote!(where)).clone();
    for param in ast.generics.type_params() {
        let ident = param.ident;
-  
-        where_clause.predicates.push(parse_quote!(#ident: ::dom::bindings::trace::JSTraceable))
+  
+        where_clause.predicates.push(parse_quote!(#ident: #base::dom::bindings::trace::JSTraceable))
    }
    let tokens = quote! {
        #[allow(unsafe_code)]
-  
-        unsafe impl #impl_generics ::dom::bindings::trace::JSTraceable for #name #ty_generics #where_clause {
+  
+        unsafe impl #impl_generics #base::dom::bindings::trace::JSTraceable for #name #ty_generics #where_clause {
            #[inline]
            #[allow(unused_variables, unused_imports)]
            unsafe fn trace(&self, tracer: *mut ::js::jsapi::JSTracer) {
-  
-                use ::dom::bindings::trace::JSTraceable;
+  
+                use #base::dom::bindings::trace::JSTraceable;
                match *self {
                    #match_body
                }
            }
        }
    };
-  
-
    tokens
 }
diff --git a/components/layout_thread/Cargo.toml b/components/layout_thread/Cargo.toml
@@ -40,6 +40,7 @@ rayon = "1"
 script = {path = "../script"}
 script_layout_interface = {path = "../script_layout_interface"}
 script_traits = {path = "../script_traits"}
+  
+script_servoparser = {path = "../script_servoparser"}
 selectors = { path = "../selectors" }
 serde_json = "1.0"
 servo_allocator = {path = "../allocator"}
@@ -51,3 +52,6 @@ servo_url = {path = "../url"}
 style = {path = "../style"}
 style_traits = {path = "../style_traits"}
 webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}
+  
+jstraceable_derive = {path = "../jstraceable_derive"}
+  
+malloc_size_of_derive = { path = "../malloc_size_of_derive" }
+  
+mozjs = { version = "0.6", features = ["promises"]}