Merge pull request #4644 from martica/camel-case-option

Update more uses of Option, Some and None to camel case

Author: catamorphism

src/libcore/option.rs

@@ -149,7 +149,7 @@ pub pure fn chain_ref<T, U>(opt: &Option<T>,
 #[inline(always)]
 pub pure fn or<T>(opta: Option<T>, optb: Option<T>) -> Option<T> {
     /*!
-     * Returns the leftmost some() value, or none if both are none.
+     * Returns the leftmost Some() value, or None if both are None.
      */
     match move opta {
         Some(move opta) => Some(move opta),

src/librustc/middle/borrowck/mod.rs

@@ -114,10 +114,10 @@ variables from reassigned if there may be pointers to their interior)
 Finally, in some cases, both dangers can arise.  For example, something
 like the following:
 
-    let mut x = ~some(5);
+    let mut x = ~Some(5);
     match x {
-      ~some(ref y) => { ... }
-      ~none => { ... }
+      ~Some(ref y) => { ... }
+      ~None => { ... }
     }
 
 In this case, if `x` to be reassigned or `*x` were to be mutated, then

src/librustc/middle/borrowck/preserve.rs

@@ -226,8 +226,8 @@ priv impl &preserve_ctxt {
             //
             // As an example, consider this scenario:
             //
-            //    let mut x = @some(3);
-            //    match *x { Some(y) {...} none {...} }
+            //    let mut x = @Some(3);
+            //    match *x { Some(y) {...} None {...} }
             //
             // Technically, the value `x` need only be rooted
             // in the `some` arm.  However, we evaluate `x` in trans
@@ -236,8 +236,8 @@ priv impl &preserve_ctxt {
             //
             // As a second example, consider *this* scenario:
             //
-            //    let x = @mut @some(3);
-            //    match x { @@some(y) {...} @@none {...} }
+            //    let x = @mut @Some(3);
+            //    match x { @@Some(y) {...} @@None {...} }
             //
             // Here again, `x` need only be rooted in the `some` arm.
             // In this case, the value which needs to be rooted is

src/librustc/middle/trans/type_of.rs

@@ -100,8 +100,8 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
     // Replace any typedef'd types with their equivalent non-typedef
     // type. This ensures that all LLVM nominal types that contain
     // Rust types are defined as the same LLVM types.  If we don't do
-    // this then, e.g. `option<{myfield: bool}>` would be a different
-    // type than `option<myrec>`.
+    // this then, e.g. `Option<{myfield: bool}>` would be a different
+    // type than `Option<myrec>`.
     let t_norm = ty::normalize_ty(cx.tcx, t);
 
     if t != t_norm {

src/librustc/middle/typeck/check/mod.rs

@@ -2696,7 +2696,7 @@ fn check_instantiable(tcx: ty::ctxt,
     if !ty::is_instantiable(tcx, item_ty) {
         tcx.sess.span_err(sp, fmt!("this type cannot be instantiated \
                   without an instance of itself; \
-                  consider using `option<%s>`",
+                  consider using `Option<%s>`",
                                    ppaux::ty_to_str(tcx, item_ty)));
     }
 }

src/librustc/middle/typeck/infer/lattice.rs

@@ -492,13 +492,13 @@ fn lattice_var_and_t<L:LatticeDir Combine,
     match self.bnd(a_bounds) {
         Some(ref a_bnd) => {
             // If a has an upper bound, return the LUB(a.ub, b)
-            debug!("bnd=some(%s)", a_bnd.inf_str(self.infcx()));
+            debug!("bnd=Some(%s)", a_bnd.inf_str(self.infcx()));
             lattice_dir_op(a_bnd, b)
         }
         None => {
             // If a does not have an upper bound, make b the upper bound of a
             // and then return b.
-            debug!("bnd=none");
+            debug!("bnd=None");
             let a_bounds = self.with_bnd(a_bounds, *b);
             do self.combine_fields().bnds(&a_bounds.lb, &a_bounds.ub).then {
                 self.infcx().set(vb, a_id, Root(a_bounds, nde_a.rank));

src/libstd/net_tcp.rs

@@ -468,7 +468,7 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  *     }
  *     // this callback is ran when a new connection arrives
  *     {|new_conn, kill_ch|
- *     let cont_po = core::comm::port::<option<tcp_err_data>>();
+ *     let cont_po = core::comm::port::<Option<tcp_err_data>>();
  *     let cont_ch = core::comm::chan(cont_po);
  *     task::spawn {||
  *         let accept_result = net::tcp::accept(new_conn);
@@ -484,9 +484,9 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  *     };
  *     match core::comm::recv(cont_po) {
  *       // shut down listen()
- *       some(err_data) { core::comm::send(kill_chan, some(err_data)) }
+ *       Some(err_data) { core::comm::send(kill_chan, Some(err_data)) }
  *       // wait for next connection
- *       none {}
+ *       None {}
  *     }
  * };
  * ~~~~~~~~~~~
@@ -593,7 +593,7 @@ pub fn accept(new_conn: TcpNewConnection)
  * callback's arguments are:
  *     * `new_conn` - an opaque type that can be passed to
  *     `net::tcp::accept` in order to be converted to a `tcp_socket`.
- *     * `kill_ch` - channel of type `core::comm::chan<option<tcp_err_data>>`.
+ *     * `kill_ch` - channel of type `core::comm::chan<Option<tcp_err_data>>`.
  *     this channel can be used to send a message to cause `listen` to begin
  *     closing the underlying libuv data structures.
  *

src/libstd/rope.rs

@@ -893,7 +893,7 @@ pub mod node {
      * # Return value
      *
      * * `option::None` if no transformation happened
-     * * `option::some(x)` otherwise, in which case `x` has the same contents
+     * * `option::Some(x)` otherwise, in which case `x` has the same contents
      *    as `node` bot lower height and/or fragmentation.
      */
     pub fn bal(node: @Node) -> Option<@Node> {

src/libstd/timer.rs

@@ -100,11 +100,11 @@ pub fn sleep(iotask: IoTask, msecs: uint) {
 }
 
 /**
- * Receive on a port for (up to) a specified time, then return an `option<T>`
+ * Receive on a port for (up to) a specified time, then return an `Option<T>`
  *
  * This call will block to receive on the provided port for up to the
  * specified timeout. Depending on whether the provided port receives in that
- * time period, `recv_timeout` will return an `option<T>` representing the
+ * time period, `recv_timeout` will return an `Option<T>` representing the
  * result.
  *
  * # Arguments
@@ -115,9 +115,9 @@ pub fn sleep(iotask: IoTask, msecs: uint) {
  *
  * # Returns
  *
- * An `option<T>` representing the outcome of the call. If the call `recv`'d
+ * An `Option<T>` representing the outcome of the call. If the call `recv`'d
  * on the provided port in the allotted timeout period, then the result will
- * be a `some(T)`. If not, then `none` will be returned.
+ * be a `Some(T)`. If not, then `None` will be returned.
  */
 pub fn recv_timeout<T: Copy Owned>(iotask: IoTask,
                                    msecs: uint,
@@ -255,7 +255,7 @@ mod test {
             };
 
             match recv_timeout(hl_loop, 10u, test_po) {
-              some(val) => {
+              Some(val) => {
                 assert val == expected;
                 successes += 1;
               }

src/test/compile-fail/issue-2354.rs

@@ -15,9 +15,9 @@
   xfailed for now (see Issue #2354)
  */
 fn foo() { //~ ERROR this open brace is not closed
-  match some(x) {
-      some(y) { fail; }
-      none    { fail; }
+  match Some(x) {
+      Some(y) { fail; }
+      None    { fail; }
 }
 
 fn bar() {