servo: Merge #18 - Fixed warnings about implicitly copying values, but not warnings of type mismatches (from mmeyerho:copies)

Source-Repo: https://github.com/servo/servo
Source-Revision: 13f82a23bf98dca02803daefa2148572229b3d2f

servo/src/servo/content.rs

@@ -9,8 +9,8 @@ import layout::layout;
 import js::rust::methods;
 
 enum msg {
-    parse(str),
-    execute(str),
+    parse(~str),
+    execute(~str),
     exit
 }
 
@@ -37,20 +37,21 @@ fn content(to_layout: chan<layout::msg>) -> chan<msg> {
         loop {
             alt from_master.recv() {
               parse(filename) {
-                #debug["content: Received filename `%s` to parse", filename];
+                #debug["content: Received filename `%s` to parse", *filename];
 
                 // TODO actually parse where the css sheet should be
                 // Replace .html with .css and try to open a stylesheet
-                assert filename.ends_with(".html");
-                let new_file = filename.substr(0u, filename.len() - 5u)
+                assert (*filename).ends_with(".html");
+                let new_file = (*filename).substr(0u, (*filename).len() - 5u)
                     + ".css";
 
                 // Send off a task to parse the stylesheet
                 let css_port = comm::port();
                 let css_chan = comm::chan(css_port);
                 task::spawn {||
+                    let new_file <- new_file;
                     let css_stream = parser::lexer::
-                        spawn_css_lexer_task(new_file);
+                        spawn_css_lexer_task(~new_file);
                     let css_rules = parser::css_builder::
                         build_stylesheet(css_stream);
                     css_chan.send(css_rules);
@@ -81,11 +82,12 @@ fn content(to_layout: chan<layout::msg>) -> chan<msg> {
                 scope.reader_forked();
               }
               execute(filename) {
-                #debug["content: Received filename `%s` to execute", filename];
+                #debug["content: Received filename `%s` to execute",
+                       *filename];
 
-                alt io::read_whole_file(filename) {
+                alt io::read_whole_file(*filename) {
                   result::err(msg) {
-                    io::println(#fmt["Error opening %s: %s", filename, msg]);
+                    io::println(#fmt["Error opening %s: %s", *filename, msg]);
                   }
                   result::ok(bytes) {
                     let cx = rt.cx();
@@ -93,7 +95,8 @@ fn content(to_layout: chan<layout::msg>) -> chan<msg> {
                     cx.set_logging_error_reporter();
                     cx.new_compartment(js::global::global_class).chain { |comp|
                         comp.define_functions(js::global::debug_fns);
-                        cx.evaluate_script(comp.global_obj, bytes, filename, 1u)
+                        cx.evaluate_script(comp.global_obj, bytes, *filename,
+                                           1u)
                     };
                   }
                 }

servo/src/servo/dom/base.rs

@@ -19,7 +19,7 @@ class element {
     let subclass: ~element_subclass;
     let attrs: dvec<~attr>;
 
-    new(tag_name: str, -subclass: ~element_subclass) {
+    new(-tag_name: str, -subclass: ~element_subclass) {
         self.tag_name = tag_name;
         self.subclass = subclass;
         self.attrs = dvec();
@@ -29,7 +29,7 @@ class element {
         let mut i = 0u;
         while i < self.attrs.len() {
             if attr_name == self.attrs[i].name {
-                ret some(self.attrs[i].value);
+                ret some(copy self.attrs[i].value);
             }
             i += 1u;
         }
@@ -41,7 +41,7 @@ class attr {
     let name: str;
     let value: str;
 
-    new(name: str, value: str) {
+    new(-name: str, -value: str) {
         self.name = name;
         self.value = value;
     }

servo/src/servo/engine.rs

@@ -1,7 +1,7 @@
 import gfx::renderer;
 
 enum msg {
-    load_url(str),
+    load_url(~str),
     exit(comm::chan<()>)
 }
 
@@ -20,7 +20,8 @@ fn engine<S: renderer::sink send copy>(sink: S) -> comm::chan<msg> {
         loop {
             alt self_ch.recv() {
               load_url(url) {
-                if url.ends_with(".js") {
+                let url <- url;
+                if (*url).ends_with(".js") {
                     content.send(content::execute(url))
                 } else {
                     content.send(content::parse(url))

servo/src/servo/layout/style/matching.rs

@@ -207,10 +207,11 @@ mod test {
     import dvec::{dvec, extensions};
     import io::println;
 
-    fn new_node_from_attr(scope : node_scope, name : str, val : str) -> node {
+    fn new_node_from_attr(scope : node_scope, -name : str, -val : str) -> node
+    {
         let elmt = dom::base::element("div", ~es_div);
         let attr = ~attr(name, val);
-        elmt.attrs.push(copy attr);
+        elmt.attrs.push(attr);
         ret scope.new_node(nk_element(elmt));        
     }
 

servo/src/servo/layout/text.rs

@@ -8,7 +8,7 @@ class text_box {
     let text: str;
     let mut run: option<text_run>;
 
-    new(text: str) {
+    new(-text: str) {
         self.text = text;
         self.run = none;
     }
@@ -22,7 +22,7 @@ impl text_layout_methods for @box {
             _ { fail "expected text box in reflow_text!" }
         };
 
-        let run = text_run(subbox.text);
+        let run = text_run(copy subbox.text);
         subbox.run = some(copy run);
         run.shape();
 

servo/src/servo/opts.rs

@@ -25,18 +25,18 @@ fn from_cmdline_args(args: [str]) -> opts {
     ];
 
     let match = alt getopts::getopts(args, opts) {
-      result::ok(m) { m }
+      result::ok(m) { let m <- m; m }
       result::err(f) { fail getopts::fail_str(f) }
     };
 
     let urls = if match.free.is_empty() {
         fail "servo asks that you provide 1 or more URLs"
     } else {
-        match.free
+        copy match.free
     };
 
     let render_mode = alt getopts::opt_maybe_str(match, "o") {
-      some(output_file) { png(output_file) }
+      some(output_file) { let output_file <- output_file; png(output_file) }
       none { screen }
     };
 

servo/src/servo/parser/css_builder.rs

@@ -16,12 +16,12 @@ type token_reader = {stream : port<token>, mut lookahead : option<token>};
 impl methods for token_reader {
     fn get() -> token {
         alt copy self.lookahead {
-          some(tok)  { self.lookahead = none; tok }
+          some(tok)  { self.lookahead = none; let t <- tok; t }
           none       { recv(self.stream) }
         }
     }
 
-    fn unget(tok : token) {
+    fn unget(-tok : token) {
         assert is_none(self.lookahead);
         self.lookahead = some(tok);
     }
@@ -30,7 +30,7 @@ impl methods for token_reader {
 fn parse_element(reader : token_reader) -> option<~selector> {
     // Get the current element type
     let elmt_name = alt reader.get() {
-      to_elmt(tag)  { tag }
+      to_elmt(tag)  { let t <- tag; t }
       to_eof        { ret none; }
       _             { fail "Expected an element" }
     };
@@ -41,7 +41,7 @@ fn parse_element(reader : token_reader) -> option<~selector> {
     loop {
         let tok = reader.get();
         alt tok {
-          to_attr(attr)       { attr_list += [attr]; }
+          to_attr(attr)       { let a <- attr; attr_list += [a]; }
           to_start_desc | to_descendant | to_child | to_sibling 
           | to_comma {
             reader.unget(tok); 

servo/src/servo/parser/html_builder.rs

@@ -10,15 +10,15 @@ import parser::token;
 import gfx::geom;
 import dvec::extensions;
 
-fn link_up_attribute(scope: dom::node_scope, node: dom::node, key: str,
-                     value: str) {
+fn link_up_attribute(scope: dom::node_scope, node: dom::node, -key: str,
+                     -value: str) {
     // TODO: Implement atoms so that we don't always perform string
     // comparisons.
     scope.rd(node) {
         |node_contents|
         alt *node_contents.kind {
             dom::nk_element(element) {
-                element.attrs.push(~attr(key, value));
+                element.attrs.push(~attr(copy key, copy value));
                 alt *element.subclass {
                     es_img(img) if key == "width" {
                         alt int::from_str(value) {
@@ -89,6 +89,7 @@ fn build_dom(scope: dom::node_scope,
                 cur = scope.get_parent(cur).get();
             }
             parser::to_text(s) if !s.is_whitespace() {
+                let s <- s;
                 let new_node = scope.new_node(dom::nk_text(s));
                 scope.add_child(cur, new_node);
             }

servo/src/servo/parser/lexer.rs

@@ -475,31 +475,34 @@ fn parser(reader: io::reader, state : parse_state) -> parser {
     ret { mut lookahead: none, mut state: state, reader: reader };
 }
 
-fn spawn_html_parser_task(filename: str) -> port<html::token> {
+fn spawn_html_parser_task(-filename: ~str) -> port<html::token> {
     let result_port = port();
     let result_chan = chan(result_port);
     task::spawn {||
+        let filename <- *filename;
+        assert (copy filename).ends_with(".html");
         let file_data = io::read_whole_file(filename).get();
         let reader = io::bytes_reader(file_data);
         
-        assert filename.ends_with(".html");
         let parser = parser(reader, ps_html_normal);
 
         loop {
             let token = parser.parse_html();
+            let should_break = token == html::to_eof;
             result_chan.send(token);
-            if token == html::to_eof { break; }
+            if should_break { break; }
         }
     };
     ret result_port;
 }
 
-fn spawn_css_lexer_task(filename: str) -> port<css::token> {
+fn spawn_css_lexer_task(-filename: ~str) -> port<css::token> {
     let result_port = port();
     let result_chan = chan(result_port);
     task::spawn {||
-        assert filename.ends_with(".css");
+        let filename <- *filename;
 
+        assert (copy filename).ends_with(".css");
         let file_try = io::read_whole_file(filename);
 
         // Check if the given css file existed, if it does, parse it,
@@ -515,8 +518,9 @@ fn spawn_css_lexer_task(filename: str) -> port<css::token> {
 
             loop {
                 let token = parser.parse_css();
+                let should_break = token == css::to_eof;
                 result_chan.send(token);
-                if token == css::to_eof { break; }
+                if should_break { break; }
             }
         } else {
             #debug["Failed to open css sheet %s", filename];

servo/src/servo/servo.rs

@@ -41,7 +41,7 @@ fn run_pipeline_screen(urls: [str]) {
 
         for urls.each { |filename|
             #debug["master: Sending filename `%s`", filename];
-            engine.send(engine::load_url(filename));
+            engine.send(engine::load_url(~copy filename));
             #debug["master: Waiting for keypress"];
             key_ch.recv();
         }
@@ -56,7 +56,7 @@ fn run_pipeline_screen(urls: [str]) {
     osmain.send(platform::osmain::exit);
 }
 
-fn run_pipeline_png(url: str, outfile: str) {
+fn run_pipeline_png(-url: str, outfile: str) {
 
     // Use a PNG encoder as the graphics sink
     import gfx::pngsink;
@@ -65,7 +65,8 @@ fn run_pipeline_png(url: str, outfile: str) {
     listen {|pngdata|
         let sink = pngsink::pngsink(pngdata);
         let engine = engine::engine(sink);
-        engine.send(engine::load_url(url));
+        let url <- url;
+        engine.send(engine::load_url(~url));
         alt io::buffered_file_writer(outfile) {
           result::ok(writer) {
             import io::writer;

servo/src/servo/text/text_run.rs

@@ -7,7 +7,7 @@ class text_run {
     let text: str;
     let mut glyphs: option<[glyph]>;
 
-    new(text: str) {
+    new(-text: str) {
         self.text = text;
         self.glyphs = none;
     }