Auto merge of #17390 - servo:untry, r=nox

Untry

<!-- Reviewable:start -->
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/17390)
<!-- Reviewable:end -->

components/bluetooth/lib.rs

@@ -436,7 +436,7 @@ impl BluetoothManager {
                              device_id: &str,
                              filters: &BluetoothScanfilterSequence)
                              -> BluetoothResult<bool> {
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
         match self.get_device(&mut adapter, device_id) {
             Some(ref device) => Ok(matches_filters(device, filters)),
             None => Ok(false),
@@ -578,7 +578,7 @@ impl BluetoothManager {
                       options: RequestDeviceoptions)
                       -> BluetoothResponseResult {
         // Step 6.
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
 
         // Step 7.
         // Note: There are no requiredServiceUUIDS, we scan for all devices.
@@ -630,7 +630,7 @@ impl BluetoothManager {
         if !self.device_is_cached(&device_id) {
             return Err(BluetoothError::Network);
         }
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
 
         // Step 5.1.1.
         match self.get_device(&mut adapter, &device_id) {
@@ -660,7 +660,7 @@ impl BluetoothManager {
 
     // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattserver-disconnect
     fn gatt_server_disconnect(&mut self, device_id: String) -> BluetoothResult<()> {
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
         match self.get_device(&mut adapter, &device_id) {
             Some(d) => {
                 // Step 2.
@@ -687,7 +687,7 @@ impl BluetoothManager {
                          single: bool,
                          child_type: GATTType)
                          -> BluetoothResponseResult {
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
         match child_type {
             GATTType::PrimaryService => {
                 // Step 5.
@@ -839,7 +839,7 @@ impl BluetoothManager {
     fn read_value(&mut self, id: String) -> BluetoothResponseResult {
         // (Characteristic) Step 5.2: Missing because it is optional.
         // (Descriptor)     Step 5.1: Missing because it is optional.
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
 
         // (Characteristic) Step 5.3.
         let mut value = self.get_gatt_characteristic(&mut adapter, &id)
@@ -871,7 +871,7 @@ impl BluetoothManager {
     fn write_value(&mut self, id: String, value: Vec<u8>) -> BluetoothResponseResult {
         // (Characteristic) Step 7.2: Missing because it is optional.
         // (Descriptor)     Step 7.1: Missing because it is optional.
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
 
         // (Characteristic) Step 7.3.
         let mut result = self.get_gatt_characteristic(&mut adapter, &id)
@@ -913,7 +913,7 @@ impl BluetoothManager {
         }
 
         // (StartNotification) TODO: Step 7: Missing because it is optional.
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
         match self.get_gatt_characteristic(&mut adapter, &id) {
             Some(c) => {
                 let result = match enable {

components/bluetooth/test.rs

@@ -129,9 +129,9 @@ fn generate_id() -> Uuid {
 
 // Set the adapter's name, is_powered and is_discoverable attributes
 fn set_adapter(adapter: &BluetoothAdapter, adapter_name: String) -> Result<(), Box<Error>> {
-    try!(adapter.set_name(adapter_name));
+    adapter.set_name(adapter_name)?;
-    try!(adapter.set_powered(true));
+    adapter.set_powered(true)?;
-    try!(adapter.set_discoverable(true));
+    adapter.set_discoverable(true)?;
     Ok(())
 }
 
@@ -140,10 +140,10 @@ fn create_device(adapter: &BluetoothAdapter,
                  name: String,
                  address: String)
                  -> Result<BluetoothDevice, Box<Error>> {
-    let device = try!(BluetoothDevice::create_mock_device(adapter.clone(), generate_id().to_string()));
+    let device = BluetoothDevice::create_mock_device(adapter.clone(), generate_id().to_string())?;
-    try!(device.set_name(Some(name)));
+    device.set_name(Some(name))?;
-    try!(device.set_address(address));
+    device.set_address(address)?;
-    try!(device.set_connectable(true));
+    device.set_connectable(true)?;
     Ok(device)
 }
 
@@ -153,8 +153,8 @@ fn create_device_with_uuids(adapter: &BluetoothAdapter,
                             address: String,
                             uuids: Vec<String>)
                             -> Result<BluetoothDevice, Box<Error>> {
-    let device = try!(create_device(adapter, name, address));
+    let device = create_device(adapter, name, address)?;
-    try!(device.set_uuids(uuids));
+    device.set_uuids(uuids)?;
     Ok(device)
 }
 
@@ -162,8 +162,8 @@ fn create_device_with_uuids(adapter: &BluetoothAdapter,
 fn create_service(device: &BluetoothDevice,
                   uuid: String)
                   -> Result<BluetoothGATTService, Box<Error>> {
-    let service = try!(BluetoothGATTService::create_mock_service(device.clone(), generate_id().to_string()));
+    let service = BluetoothGATTService::create_mock_service(device.clone(), generate_id().to_string())?;
-    try!(service.set_uuid(uuid));
+    service.set_uuid(uuid)?;
     Ok(service)
 }
 
@@ -172,8 +172,8 @@ fn create_characteristic(service: &BluetoothGATTService,
                          uuid: String)
                          -> Result<BluetoothGATTCharacteristic, Box<Error>> {
     let characteristic =
-        try!(BluetoothGATTCharacteristic::create_mock_characteristic(service.clone(), generate_id().to_string()));
+        BluetoothGATTCharacteristic::create_mock_characteristic(service.clone(), generate_id().to_string())?;
-    try!(characteristic.set_uuid(uuid));
+    characteristic.set_uuid(uuid)?;
     Ok(characteristic)
 }
 
@@ -182,8 +182,8 @@ fn create_characteristic_with_value(service: &BluetoothGATTService,
                                     uuid: String,
                                     value: Vec<u8>)
                                     -> Result<BluetoothGATTCharacteristic, Box<Error>> {
-    let characteristic = try!(create_characteristic(service, uuid));
+    let characteristic = create_characteristic(service, uuid)?;
-    try!(characteristic.set_value(value));
+    characteristic.set_value(value)?;
     Ok(characteristic)
 }
 
@@ -192,8 +192,8 @@ fn create_descriptor(characteristic: &BluetoothGATTCharacteristic,
                                      uuid: String)
                                      -> Result<BluetoothGATTDescriptor, Box<Error>> {
     let descriptor =
-        try!(BluetoothGATTDescriptor::create_mock_descriptor(characteristic.clone(), generate_id().to_string()));
+        BluetoothGATTDescriptor::create_mock_descriptor(characteristic.clone(), generate_id().to_string())?;
-    try!(descriptor.set_uuid(uuid));
+    descriptor.set_uuid(uuid)?;
     Ok(descriptor)
 }
 
@@ -202,8 +202,8 @@ fn create_descriptor_with_value(characteristic: &BluetoothGATTCharacteristic,
                                 uuid: String,
                                 value: Vec<u8>)
                                 -> Result<BluetoothGATTDescriptor, Box<Error>> {
-    let descriptor = try!(create_descriptor(characteristic, uuid));
+    let descriptor = create_descriptor(characteristic, uuid)?;
-    try!(descriptor.set_value(value));
+    descriptor.set_value(value)?;
     Ok(descriptor)
 }
 
@@ -211,7 +211,7 @@ fn create_heart_rate_service(device: &BluetoothDevice,
                              empty: bool)
                              -> Result<BluetoothGATTService, Box<Error>> {
     // Heart Rate Service
-    let heart_rate_service = try!(create_service(device, HEART_RATE_SERVICE_UUID.to_owned()));
+    let heart_rate_service = create_service(device, HEART_RATE_SERVICE_UUID.to_owned())?;
 
     if empty {
         return Ok(heart_rate_service)
@@ -219,26 +219,26 @@ fn create_heart_rate_service(device: &BluetoothDevice,
 
     // Heart Rate Measurement Characteristic
     let heart_rate_measurement_characteristic =
-        try!(create_characteristic_with_value(&heart_rate_service,
+        create_characteristic_with_value(&heart_rate_service,
                                               HEART_RATE_MEASUREMENT_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![0]));
+                                              vec![0])?;
-    try!(heart_rate_measurement_characteristic.set_flags(vec![NOTIFY_FLAG.to_string(),
+    heart_rate_measurement_characteristic.set_flags(vec![NOTIFY_FLAG.to_string(),
                                                               READ_FLAG.to_string(),
-                                                              WRITE_FLAG.to_string()]));
+                                                              WRITE_FLAG.to_string()])?;
 
     // Body Sensor Location Characteristic 1
     let body_sensor_location_characteristic_1 =
-        try!(create_characteristic_with_value(&heart_rate_service,
+        create_characteristic_with_value(&heart_rate_service,
                                               BODY_SENSOR_LOCATION_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![49]));
+                                              vec![49])?;
-    try!(body_sensor_location_characteristic_1.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+    body_sensor_location_characteristic_1.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
     // Body Sensor Location Characteristic 2
     let body_sensor_location_characteristic_2 =
-        try!(create_characteristic_with_value(&heart_rate_service,
+        create_characteristic_with_value(&heart_rate_service,
                                               BODY_SENSOR_LOCATION_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![50]));
+                                              vec![50])?;
-    try!(body_sensor_location_characteristic_2.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+    body_sensor_location_characteristic_2.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
     Ok(heart_rate_service)
 }
 
@@ -247,7 +247,7 @@ fn create_generic_access_service(device: &BluetoothDevice,
                                  -> Result<BluetoothGATTService, Box<Error>> {
     // Generic Access Service
     let generic_access_service =
-        try!(create_service(device, GENERIC_ACCESS_SERVICE_UUID.to_owned()));
+        create_service(device, GENERIC_ACCESS_SERVICE_UUID.to_owned())?;
 
     if empty {
         return Ok(generic_access_service)
@@ -255,41 +255,41 @@ fn create_generic_access_service(device: &BluetoothDevice,
 
     // Device Name Characteristic
     let device_name_characteristic =
-        try!(create_characteristic_with_value(&generic_access_service,
+        create_characteristic_with_value(&generic_access_service,
                                               DEVICE_NAME_CHARACTERISTIC_UUID.to_owned(),
-                                              HEART_RATE_DEVICE_NAME.as_bytes().to_vec()));
+                                              HEART_RATE_DEVICE_NAME.as_bytes().to_vec())?;
-    try!(device_name_characteristic.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+    device_name_characteristic.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
     // Number of Digitals descriptor
     let number_of_digitals_descriptor_1 =
-        try!(create_descriptor_with_value(&device_name_characteristic,
+        create_descriptor_with_value(&device_name_characteristic,
                                           NUMBER_OF_DIGITALS_UUID.to_owned(),
-                                          vec![49]));
+                                          vec![49])?;
-    try!(number_of_digitals_descriptor_1.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+    number_of_digitals_descriptor_1.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
     let number_of_digitals_descriptor_2 =
-        try!(create_descriptor_with_value(&device_name_characteristic,
+        create_descriptor_with_value(&device_name_characteristic,
                                           NUMBER_OF_DIGITALS_UUID.to_owned(),
-                                          vec![50]));
+                                          vec![50])?;
-    try!(number_of_digitals_descriptor_2.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+    number_of_digitals_descriptor_2.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
     // Characteristic User Description Descriptor
     let _characteristic_user_description =
-        try!(create_descriptor_with_value(&device_name_characteristic,
+        create_descriptor_with_value(&device_name_characteristic,
                                           CHARACTERISTIC_USER_DESCRIPTION_UUID.to_owned(),
-                                          HEART_RATE_DEVICE_NAME_DESCRIPTION.as_bytes().to_vec()));
+                                          HEART_RATE_DEVICE_NAME_DESCRIPTION.as_bytes().to_vec())?;
 
     // Client Characteristic Configuration descriptor
     let _client_characteristic_configuration =
-        try!(create_descriptor_with_value(&device_name_characteristic,
+        create_descriptor_with_value(&device_name_characteristic,
                                           CLIENT_CHARACTERISTIC_CONFIGURATION_UUID.to_owned(),
-                                          vec![0]));
+                                          vec![0])?;
 
     // Peripheral Privacy Flag Characteristic
     let peripheral_privacy_flag_characteristic =
-        try!(create_characteristic(&generic_access_service, PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC_UUID.to_owned()));
+        create_characteristic(&generic_access_service, PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC_UUID.to_owned())?;
-    try!(peripheral_privacy_flag_characteristic
+    peripheral_privacy_flag_characteristic
-         .set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+         .set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
     Ok(generic_access_service)
 }
 
@@ -299,149 +299,149 @@ fn create_heart_rate_device(adapter: &BluetoothAdapter,
                             -> Result<BluetoothDevice, Box<Error>> {
     // Heart Rate Device
     let heart_rate_device =
-        try!(create_device_with_uuids(adapter,
+        create_device_with_uuids(adapter,
                                       HEART_RATE_DEVICE_NAME.to_owned(),
                                       HEART_RATE_DEVICE_ADDRESS.to_owned(),
                                       vec![GENERIC_ACCESS_SERVICE_UUID.to_owned(),
-                                           HEART_RATE_SERVICE_UUID.to_owned()]));
+                                           HEART_RATE_SERVICE_UUID.to_owned()])?;
 
     if empty {
         return Ok(heart_rate_device);
     }
 
     // Generic Access Service
-    let _generic_access_service = try!(create_generic_access_service(&heart_rate_device, false));
+    let _generic_access_service = create_generic_access_service(&heart_rate_device, false)?;
 
     // Heart Rate Service
-    let _heart_rate_service = try!(create_heart_rate_service(&heart_rate_device, false));
+    let _heart_rate_service = create_heart_rate_service(&heart_rate_device, false)?;
 
     Ok(heart_rate_device)
 }
 
 fn create_missing_characterisitc_heart_rate_device(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
-    let heart_rate_device_empty = try!(create_heart_rate_device(adapter, true));
+    let heart_rate_device_empty = create_heart_rate_device(adapter, true)?;
 
-    let _generic_access_service_empty = try!(create_generic_access_service(&heart_rate_device_empty, true));
+    let _generic_access_service_empty = create_generic_access_service(&heart_rate_device_empty, true)?;
 
-    let _heart_rate_service_empty = try!(create_heart_rate_service(&heart_rate_device_empty, true));
+    let _heart_rate_service_empty = create_heart_rate_service(&heart_rate_device_empty, true)?;
 
     Ok(())
 }
 
 fn create_missing_descriptor_heart_rate_device(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
-    let heart_rate_device_empty = try!(create_heart_rate_device(adapter, true));
+    let heart_rate_device_empty = create_heart_rate_device(adapter, true)?;
 
-    let generic_access_service_empty = try!(create_generic_access_service(&heart_rate_device_empty, true));
+    let generic_access_service_empty = create_generic_access_service(&heart_rate_device_empty, true)?;
 
     let _device_name_characteristic =
-        try!(create_characteristic_with_value(&generic_access_service_empty,
+        create_characteristic_with_value(&generic_access_service_empty,
                                               DEVICE_NAME_CHARACTERISTIC_UUID.to_owned(),
-                                              HEART_RATE_DEVICE_NAME.as_bytes().to_vec()));
+                                              HEART_RATE_DEVICE_NAME.as_bytes().to_vec())?;
 
     let peripheral_privacy_flag_characteristic =
-        try!(create_characteristic(&generic_access_service_empty,
+        create_characteristic(&generic_access_service_empty,
-                                   PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC_UUID.to_owned()));
+                                   PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC_UUID.to_owned())?;
-    try!(peripheral_privacy_flag_characteristic.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+    peripheral_privacy_flag_characteristic.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
-    let _heart_rate_service = try!(create_heart_rate_service(&heart_rate_device_empty, false));
+    let _heart_rate_service = create_heart_rate_service(&heart_rate_device_empty, false)?;
 
     Ok(())
 }
 
 fn create_two_heart_rate_services_device(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
-    let heart_rate_device_empty = try!(create_heart_rate_device(adapter, true));
+    let heart_rate_device_empty = create_heart_rate_device(adapter, true)?;
 
-    try!(heart_rate_device_empty.set_uuids(vec![GENERIC_ACCESS_SERVICE_UUID.to_owned(),
+    heart_rate_device_empty.set_uuids(vec![GENERIC_ACCESS_SERVICE_UUID.to_owned(),
                                                 HEART_RATE_SERVICE_UUID.to_owned(),
-                                                HEART_RATE_SERVICE_UUID.to_owned()]));
+                                                HEART_RATE_SERVICE_UUID.to_owned()])?;
 
-    let _generic_access_service = try!(create_generic_access_service(&heart_rate_device_empty, false));
+    let _generic_access_service = create_generic_access_service(&heart_rate_device_empty, false)?;
 
-    let heart_rate_service_empty_1 = try!(create_heart_rate_service(&heart_rate_device_empty, true));
+    let heart_rate_service_empty_1 = create_heart_rate_service(&heart_rate_device_empty, true)?;
 
-    let heart_rate_service_empty_2 = try!(create_heart_rate_service(&heart_rate_device_empty, true));
+    let heart_rate_service_empty_2 = create_heart_rate_service(&heart_rate_device_empty, true)?;
 
     let heart_rate_measurement_characteristic =
-        try!(create_characteristic_with_value(&heart_rate_service_empty_1,
+        create_characteristic_with_value(&heart_rate_service_empty_1,
                                               HEART_RATE_MEASUREMENT_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![0]));
+                                              vec![0])?;
-    try!(heart_rate_measurement_characteristic.set_flags(vec![NOTIFY_FLAG.to_string()]));
+    heart_rate_measurement_characteristic.set_flags(vec![NOTIFY_FLAG.to_string()])?;
 
     let _body_sensor_location_characteristic_1 =
-        try!(create_characteristic_with_value(&heart_rate_service_empty_1,
+        create_characteristic_with_value(&heart_rate_service_empty_1,
                                               BODY_SENSOR_LOCATION_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![49]));
+                                              vec![49])?;
 
     let _body_sensor_location_characteristic_2 =
-        try!(create_characteristic_with_value(&heart_rate_service_empty_2,
+        create_characteristic_with_value(&heart_rate_service_empty_2,
                                               BODY_SENSOR_LOCATION_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![50]));
+                                              vec![50])?;
     Ok(())
 }
 
 fn create_blocklisted_device(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
     let connectable_device =
-    try!(create_device_with_uuids(adapter,
+    create_device_with_uuids(adapter,
                                  CONNECTABLE_DEVICE_NAME.to_owned(),
                                  CONNECTABLE_DEVICE_ADDRESS.to_owned(),
                                  vec![BLOCKLIST_TEST_SERVICE_UUID.to_owned(),
                                       DEVICE_INFORMATION_UUID.to_owned(),
                                       GENERIC_ACCESS_SERVICE_UUID.to_owned(),
                                       HEART_RATE_SERVICE_UUID.to_owned(),
-                                      HUMAN_INTERFACE_DEVICE_SERVICE_UUID.to_owned()]));
+                                      HUMAN_INTERFACE_DEVICE_SERVICE_UUID.to_owned()])?;
 
-    let blocklist_test_service = try!(create_service(&connectable_device, BLOCKLIST_TEST_SERVICE_UUID.to_owned()));
+    let blocklist_test_service = create_service(&connectable_device, BLOCKLIST_TEST_SERVICE_UUID.to_owned())?;
 
     let blocklist_exclude_reads_characteristic =
-        try!(create_characteristic(&blocklist_test_service,
+        create_characteristic(&blocklist_test_service,
-                                   BLOCKLIST_EXCLUDE_READS_CHARACTERISTIC_UUID.to_owned()));
+                                   BLOCKLIST_EXCLUDE_READS_CHARACTERISTIC_UUID.to_owned())?;
-    try!(blocklist_exclude_reads_characteristic
+    blocklist_exclude_reads_characteristic
-         .set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+         .set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
     let _blocklist_exclude_reads_descriptor =
-        try!(create_descriptor_with_value(&blocklist_exclude_reads_characteristic,
+        create_descriptor_with_value(&blocklist_exclude_reads_characteristic,
                                           BLOCKLIST_EXCLUDE_READS_DESCRIPTOR_UUID.to_owned(),
-                                          vec![54; 3]));
+                                          vec![54; 3])?;
 
     let _blocklist_descriptor =
-        try!(create_descriptor_with_value(&blocklist_exclude_reads_characteristic,
+        create_descriptor_with_value(&blocklist_exclude_reads_characteristic,
                                           BLOCKLIST_DESCRIPTOR_UUID.to_owned(),
-                                          vec![54; 3]));
+                                          vec![54; 3])?;
 
-    let device_information_service = try!(create_service(&connectable_device, DEVICE_INFORMATION_UUID.to_owned()));
+    let device_information_service = create_service(&connectable_device, DEVICE_INFORMATION_UUID.to_owned())?;
 
     let _serial_number_string_characteristic =
-        try!(create_characteristic(&device_information_service, SERIAL_NUMBER_STRING_UUID.to_owned()));
+        create_characteristic(&device_information_service, SERIAL_NUMBER_STRING_UUID.to_owned())?;
 
-    let _generic_access_service = try!(create_generic_access_service(&connectable_device, false));
+    let _generic_access_service = create_generic_access_service(&connectable_device, false)?;
 
-    let _heart_rate_service = try!(create_heart_rate_service(&connectable_device, false));
+    let _heart_rate_service = create_heart_rate_service(&connectable_device, false)?;
 
     let _human_interface_device_service =
-        try!(create_service(&connectable_device, HUMAN_INTERFACE_DEVICE_SERVICE_UUID.to_owned()));
+        create_service(&connectable_device, HUMAN_INTERFACE_DEVICE_SERVICE_UUID.to_owned())?;
     Ok(())
 }
 
 fn create_glucose_heart_rate_devices(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
-    let glucose_devie = try!(create_device_with_uuids(adapter,
+    let glucose_devie = create_device_with_uuids(adapter,
                                                       GLUCOSE_DEVICE_NAME.to_owned(),
                                                       GLUCOSE_DEVICE_ADDRESS.to_owned(),
                                                       vec![GLUCOSE_SERVICE_UUID.to_owned(),
-                                                           TX_POWER_SERVICE_UUID.to_owned()]));
+                                                           TX_POWER_SERVICE_UUID.to_owned()])?;
 
-    let heart_rate_device_empty = try!(create_heart_rate_device(adapter, true));
+    let heart_rate_device_empty = create_heart_rate_device(adapter, true)?;
 
     let mut manufacturer_dta = HashMap::new();
     manufacturer_dta.insert(17, vec![1, 2, 3]);
-    try!(glucose_devie.set_manufacturer_data(manufacturer_dta));
+    glucose_devie.set_manufacturer_data(manufacturer_dta)?;
 
     let mut service_data = HashMap::new();
     service_data.insert(GLUCOSE_SERVICE_UUID.to_owned(), vec![1, 2, 3]);
-    try!(glucose_devie.set_service_data(service_data));
+    glucose_devie.set_service_data(service_data)?;
 
     service_data = HashMap::new();
     service_data.insert(HEART_RATE_SERVICE_UUID.to_owned(), vec![1, 2, 3]);
-    try!(heart_rate_device_empty.set_service_data(service_data));
+    heart_rate_device_empty.set_service_data(service_data)?;
     Ok(())
 }
 
@@ -453,68 +453,68 @@ pub fn test(manager: &mut BluetoothManager, data_set_name: String) -> Result<(),
     };
     match data_set_name.as_str() {
         NOT_PRESENT_ADAPTER => {
-            try!(set_adapter(adapter, NOT_PRESENT_ADAPTER.to_owned()));
+            set_adapter(adapter, NOT_PRESENT_ADAPTER.to_owned())?;
-            try!(adapter.set_present(false));
+            adapter.set_present(false)?;
         },
         NOT_POWERED_ADAPTER => {
-            try!(set_adapter(adapter, NOT_POWERED_ADAPTER.to_owned()));
+            set_adapter(adapter, NOT_POWERED_ADAPTER.to_owned())?;
-            try!(adapter.set_powered(false));
+            adapter.set_powered(false)?;
         },
         EMPTY_ADAPTER => {
-            try!(set_adapter(adapter, EMPTY_ADAPTER.to_owned()));
+            set_adapter(adapter, EMPTY_ADAPTER.to_owned())?;
         },
         GLUCOSE_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, GLUCOSE_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, GLUCOSE_HEART_RATE_ADAPTER.to_owned())?;
-            let _ = try!(create_glucose_heart_rate_devices(adapter));
+            let _ = create_glucose_heart_rate_devices(adapter)?;
         },
         UNICODE_DEVICE_ADAPTER => {
-            try!(set_adapter(adapter, UNICODE_DEVICE_ADAPTER.to_owned()));
+            set_adapter(adapter, UNICODE_DEVICE_ADAPTER.to_owned())?;
 
-            let _unicode_device = try!(create_device(adapter,
+            let _unicode_device = create_device(adapter,
                                                      UNICODE_DEVICE_NAME.to_owned(),
-                                                     UNICODE_DEVICE_ADDRESS.to_owned()));
+                                                     UNICODE_DEVICE_ADDRESS.to_owned())?;
         },
         MISSING_SERVICE_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, MISSING_SERVICE_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, MISSING_SERVICE_HEART_RATE_ADAPTER.to_owned())?;
 
-            let _heart_rate_device_empty = try!(create_heart_rate_device(adapter, true));
+            let _heart_rate_device_empty = create_heart_rate_device(adapter, true)?;
         },
         MISSING_CHARACTERISTIC_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, MISSING_CHARACTERISTIC_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, MISSING_CHARACTERISTIC_HEART_RATE_ADAPTER.to_owned())?;
 
-            let _ = try!(create_missing_characterisitc_heart_rate_device(adapter));
+            let _ = create_missing_characterisitc_heart_rate_device(adapter)?;
         },
         MISSING_DESCRIPTOR_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, MISSING_DESCRIPTOR_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, MISSING_DESCRIPTOR_HEART_RATE_ADAPTER.to_owned())?;
 
-            let _ = try!(create_missing_descriptor_heart_rate_device(adapter));
+            let _ = create_missing_descriptor_heart_rate_device(adapter)?;
         },
         HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, HEART_RATE_ADAPTER.to_owned())?;
 
-            let _heart_rate_device = try!(create_heart_rate_device(adapter, false));
+            let _heart_rate_device = create_heart_rate_device(adapter, false)?;
         },
         EMPTY_NAME_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, EMPTY_NAME_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, EMPTY_NAME_HEART_RATE_ADAPTER.to_owned())?;
 
-            let heart_rate_device = try!(create_heart_rate_device(adapter, false));
+            let heart_rate_device = create_heart_rate_device(adapter, false)?;
-            try!(heart_rate_device.set_name(Some(EMPTY_DEVICE_NAME.to_owned())));
+            heart_rate_device.set_name(Some(EMPTY_DEVICE_NAME.to_owned()))?;
         },
         NO_NAME_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, NO_NAME_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, NO_NAME_HEART_RATE_ADAPTER.to_owned())?;
 
-            let heart_rate_device = try!(create_heart_rate_device(adapter, false));
+            let heart_rate_device = create_heart_rate_device(adapter, false)?;
-            try!(heart_rate_device.set_name(None));
+            heart_rate_device.set_name(None)?;
         },
         TWO_HEART_RATE_SERVICES_ADAPTER => {
-            try!(set_adapter(adapter, TWO_HEART_RATE_SERVICES_ADAPTER.to_owned()));
+            set_adapter(adapter, TWO_HEART_RATE_SERVICES_ADAPTER.to_owned())?;
 
-            let _ = try!(create_two_heart_rate_services_device(adapter));
+            let _ = create_two_heart_rate_services_device(adapter)?;
         },
         BLOCKLIST_TEST_ADAPTER => {
-            try!(set_adapter(adapter, BLOCKLIST_TEST_ADAPTER.to_owned()));
+            set_adapter(adapter, BLOCKLIST_TEST_ADAPTER.to_owned())?;
 
-            let _ = try!(create_blocklisted_device(adapter));
+            let _ = create_blocklisted_device(adapter)?;
         },
         _ => return Err(Box::from(WRONG_DATA_SET_ERROR.to_string())),
     }

components/canvas/webgl_paint_thread.rs

@@ -56,11 +56,11 @@ impl GLContextWrapper {
     fn resize(&mut self, size: Size2D<i32>) -> Result<Size2D<i32>, &'static str> {
         match *self {
             GLContextWrapper::Native(ref mut ctx) => {
-                try!(ctx.resize(size));
+                ctx.resize(size)?;
                 Ok(ctx.borrow_draw_buffer().unwrap().size())
             }
             GLContextWrapper::OSMesa(ref mut ctx) => {
-                try!(ctx.resize(size));
+                ctx.resize(size)?;
                 Ok(ctx.borrow_draw_buffer().unwrap().size())
             }
         }
@@ -115,7 +115,7 @@ fn create_readback_painter(size: Size2D<i32>,
                            webrender_api: webrender_traits::RenderApi,
                            gl_type: gl::GlType)
     -> Result<(WebGLPaintThread, GLLimits), String> {
-    let context = try!(GLContextWrapper::new(size, attrs, gl_type));
+    let context = GLContextWrapper::new(size, attrs, gl_type)?;
     let limits = context.get_limits();
     let painter = WebGLPaintThread {
         size: size,
@@ -294,7 +294,7 @@ impl WebGLPaintThread {
             WebGLPaintTaskData::Readback(ref mut context, ref webrender_api, ref mut image_key) => {
                 if size.width > self.size.width ||
                    size.height > self.size.height {
-                    self.size = try!(context.resize(size));
+                    self.size = context.resize(size)?;
                 } else {
                     self.size = size;
                     context.gl().scissor(0, 0, size.width, size.height);

components/config/prefs.rs

@@ -113,7 +113,7 @@ impl Pref {
     }
 
     fn from_json(data: Json) -> Result<Pref, ()> {
-        let value = try!(PrefValue::from_json(data));
+        let value = PrefValue::from_json(data)?;
         Ok(Pref::new_default(value))
     }
 
@@ -158,10 +158,10 @@ pub fn default_prefs() -> Preferences {
 
 pub fn read_prefs_from_file<T>(mut file: T)
     -> Result<HashMap<String, Pref>, ()> where T: Read {
-    let json = try!(Json::from_reader(&mut file).or_else(|e| {
+    let json = Json::from_reader(&mut file).or_else(|e| {
         println!("Ignoring invalid JSON in preferences: {:?}.", e);
         Err(())
-    }));
+    })?;
 
     let mut prefs = HashMap::new();
     if let Json::Object(obj) = json {
@@ -205,14 +205,14 @@ fn init_user_prefs(path: &mut PathBuf) {
 }
 
 fn read_prefs() -> Result<HashMap<String, Pref>, ()> {
-    let mut path = try!(resources_dir_path().map_err(|_| ()));
+    let mut path = resources_dir_path().map_err(|_| ())?;
     path.push("prefs.json");
 
-    let file = try!(File::open(path).or_else(|e| {
+    let file = File::open(path).or_else(|e| {
         writeln!(&mut stderr(), "Error opening preferences: {:?}.", e)
             .expect("failed printing to stderr");
         Err(())
-    }));
+    })?;
 
     read_prefs_from_file(file)
 }

components/config/resource_files.rs

@@ -44,9 +44,9 @@ pub fn resources_dir_path() -> io::Result<PathBuf> {
     // FIXME: Find a way to not rely on the executable being
     // under `<servo source>[/$target_triple]/target/debug`
     // or `<servo source>[/$target_triple]/target/release`.
-    let mut path = try!(env::current_exe());
+    let mut path = env::current_exe()?;
     // Follow symlink
-    path = try!(path.canonicalize());
+    path = path.canonicalize()?;
 
     while path.pop() {
         path.push("resources");
@@ -66,10 +66,10 @@ pub fn resources_dir_path() -> io::Result<PathBuf> {
 }
 
 pub fn read_resource_file<P: AsRef<Path>>(relative_path: P) -> io::Result<Vec<u8>> {
-    let mut path = try!(resources_dir_path());
+    let mut path = resources_dir_path()?;
     path.push(relative_path);
-    let mut file = try!(File::open(&path));
+    let mut file = File::open(&path)?;
     let mut data = Vec::new();
-    try!(file.read_to_end(&mut data));
+    file.read_to_end(&mut data)?;
     Ok(data)
 }

components/constellation/pipeline.rs

@@ -273,7 +273,7 @@ impl Pipeline {
                 //
                 // Yes, that's all there is to it!
                 if opts::multiprocess() {
-                    let _ = try!(unprivileged_pipeline_content.spawn_multiprocess());
+                    let _ = unprivileged_pipeline_content.spawn_multiprocess()?;
                 } else {
                     unprivileged_pipeline_content.start_all::<Message, LTF, STF>(false);
                 }
@@ -563,7 +563,7 @@ impl UnprivilegedPipelineContent {
         }
 
         let (_receiver, sender) = server.accept().expect("Server failed to accept.");
-        try!(sender.send(self));
+        sender.send(self)?;
 
         Ok(())
     }

components/devtools/actor.rs

@@ -159,7 +159,7 @@ impl ActorRegistry {
             None => debug!("message received for unknown actor \"{}\"", to),
             Some(actor) => {
                 let msg_type = msg.get("type").unwrap().as_str().unwrap();
-                if try!(actor.handle_message(self, msg_type, msg, stream))
+                if actor.handle_message(self, msg_type, msg, stream)?
                         != ActorMessageStatus::Processed {
                     debug!("unexpected message type \"{}\" found for actor \"{}\"",
                              msg_type, to);

components/devtools/actors/console.rs

@@ -115,7 +115,7 @@ impl Actor for ConsoleActor {
                 let (chan, port) = ipc::channel().unwrap();
                 self.script_chan.send(DevtoolScriptControlMsg::GetCachedMessages(
                     self.pipeline, message_types, chan)).unwrap();
-                let messages = try!(port.recv().map_err(|_| ())).into_iter().map(|message| {
+                let messages = port.recv().map_err(|_| ())?.into_iter().map(|message| {
                     let json_string = message.encode().unwrap();
                     let json = serde_json::from_str::<Value>(&json_string).unwrap();
                     json.as_object().unwrap().to_owned()
@@ -179,7 +179,7 @@ impl Actor for ConsoleActor {
                     self.pipeline, input.clone(), chan)).unwrap();
 
                 //TODO: extract conversion into protocol module or some other useful place
-                let result = match try!(port.recv().map_err(|_| ())) {
+                let result = match port.recv().map_err(|_| ())? {
                     VoidValue => {
                         let mut m = Map::new();
                         m.insert("type".to_owned(), Value::String("undefined".to_owned()));

components/devtools/actors/inspector.rs

@@ -289,7 +289,7 @@ impl Actor for WalkerActor {
             "documentElement" => {
                 let (tx, rx) = ipc::channel().unwrap();
                 self.script_chan.send(GetDocumentElement(self.pipeline, tx)).unwrap();
-                let doc_elem_info = try!(rx.recv().unwrap().ok_or(()));
+                let doc_elem_info = rx.recv().unwrap().ok_or(())?;
                 let node = doc_elem_info.encode(registry, true, self.script_chan.clone(), self.pipeline);
 
                 let msg = DocumentElementReply {
@@ -315,7 +315,7 @@ impl Actor for WalkerActor {
                                                   registry.actor_to_script(target.to_owned()),
                                                   tx))
                                 .unwrap();
-                let children = try!(rx.recv().unwrap().ok_or(()));
+                let children = rx.recv().unwrap().ok_or(())?;
 
                 let msg = ChildrenReply {
                     hasFirst: true,
@@ -489,7 +489,7 @@ impl Actor for PageStyleActor {
                     borderTopWidth, borderRightWidth, borderBottomWidth, borderLeftWidth,
                     paddingTop, paddingRight, paddingBottom, paddingLeft,
                     width, height,
-                } = try!(rx.recv().unwrap().ok_or(()));
+                } = rx.recv().unwrap().ok_or(())?;
 
                 let auto_margins = msg.get("autoMargins")
                     .and_then(&Value::as_bool).unwrap_or(false);
@@ -563,7 +563,7 @@ impl Actor for InspectorActor {
 
                 let (tx, rx) = ipc::channel().unwrap();
                 self.script_chan.send(GetRootNode(self.pipeline, tx)).unwrap();
-                let root_info = try!(rx.recv().unwrap().ok_or(()));
+                let root_info = rx.recv().unwrap().ok_or(())?;
 
                 let node = root_info.encode(registry, false, self.script_chan.clone(), self.pipeline);
 

components/gfx/font_context.rs

@@ -88,9 +88,9 @@ impl FontContext {
             font_variant_caps::T::normal => pt_size,
         };
 
-        let handle = try!(FontHandle::new_from_template(&self.platform_handle,
+        let handle = FontHandle::new_from_template(&self.platform_handle,
                                                         template,
-                                                        Some(actual_pt_size)));
+                                                        Some(actual_pt_size))?;
 
         Ok(Font::new(handle, variant, descriptor, pt_size, actual_pt_size, font_key))
     }

components/gfx/font_template.rs

@@ -80,7 +80,7 @@ impl Debug for FontTemplate {
 impl FontTemplate {
     pub fn new(identifier: Atom, maybe_bytes: Option<Vec<u8>>) -> Result<FontTemplate, IoError> {
         let maybe_data = match maybe_bytes {
-            Some(_) => Some(try!(FontTemplateData::new(identifier.clone(), maybe_bytes))),
+            Some(_) => Some(FontTemplateData::new(identifier.clone(), maybe_bytes)?),
             None => None,
         };
 
@@ -167,12 +167,12 @@ impl FontTemplate {
             return Err(())
         }
 
-        let data = try!(self.data().map_err(|_| ()));
+        let data = self.data().map_err(|_| ())?;
         let handle: Result<FontHandle, ()> = FontHandleMethods::new_from_template(font_context,
                                                                                   data,
                                                                                   None);
         self.is_valid = handle.is_ok();
-        let handle = try!(handle);
+        let handle = handle?;
         self.descriptor = Some(FontTemplateDescriptor::new(handle.boldness(),
                                                            handle.stretchiness(),
                                                            handle.is_italic()));
@@ -202,7 +202,7 @@ impl FontTemplate {
         }
 
         assert!(self.strong_ref.is_none());
-        let template_data = Arc::new(try!(FontTemplateData::new(self.identifier.clone(), None)));
+        let template_data = Arc::new(FontTemplateData::new(self.identifier.clone(), None)?);
         self.weak_ref = Some(Arc::downgrade(&template_data));
         Ok(template_data)
     }

components/gfx/platform/freetype/android/font_list.rs

@@ -235,9 +235,9 @@ impl FontList {
 
 
     fn load_file(path: &str) -> Result<String, io::Error> {
-        let mut file = try!(File::open(path));
+        let mut file = File::open(path)?;
         let mut content = String::new();
-        try!(file.read_to_string(&mut content));
+        file.read_to_string(&mut content)?;
 
         Ok(content)
     }

components/gfx/platform/freetype/font.rs

@@ -99,7 +99,7 @@ impl FontHandleMethods for FontHandle {
                     return Err(());
                 }
                 if let Some(s) = pt_size {
-                    try!(FontHandle::set_char_size(face, s).or(Err(())))
+                    FontHandle::set_char_size(face, s).or(Err(()))?
                 }
                 Ok(face)
             }

components/gfx/platform/freetype/font_template.rs

@@ -25,7 +25,7 @@ impl FontTemplateData {
             },
             None => {
                 // TODO: Handle file load failure!
-                let mut file = try!(File::open(&*identifier));
+                let mut file = File::open(&*identifier)?;
                 let mut buffer = vec![];
                 file.read_to_end(&mut buffer).unwrap();
                 buffer

components/gfx/platform/windows/font.rs

@@ -47,7 +47,7 @@ fn make_tag(tag_bytes: &[u8]) -> FontTableTag {
     unsafe { *(tag_bytes.as_ptr() as *const FontTableTag) }
 }
 
-macro_rules! try_lossy(($result:expr) => (try!($result.map_err(|_| (())))));
+macro_rules! try_lossy(($result:expr) => ($result.map_err(|_| (()))?));
 
 // Given a set of records, figure out the string indices for the family and face
 // names.  We want name_id 1 and 2, and we need to use platform_id == 1 and
@@ -262,12 +262,12 @@ impl FontHandleMethods for FontHandle {
             }
 
             let face = font_file.unwrap().create_face(0, dwrote::DWRITE_FONT_SIMULATIONS_NONE);
-            let info = try!(FontInfo::new_from_face(&face));
+            let info = FontInfo::new_from_face(&face)?;
             (info, face)
         } else {
             let font = font_from_atom(&template.identifier);
             let face = font.create_font_face();
-            let info = try!(FontInfo::new_from_font(&font));
+            let info = FontInfo::new_from_font(&font)?;
             (info, face)
         };
 

components/gfx/text/glyph.rs

@@ -665,27 +665,27 @@ impl<'a> GlyphStore {
 
 impl fmt::Debug for GlyphStore {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(formatter, "GlyphStore:\n"));
+        write!(formatter, "GlyphStore:\n")?;
         let mut detailed_buffer = self.detail_store.detail_buffer.iter();
         for entry in self.entry_buffer.iter() {
             if entry.is_simple() {
-                try!(write!(formatter,
+                write!(formatter,
                             "  simple id={:?} advance={:?}\n",
                             entry.id(),
-                            entry.advance()));
+                            entry.advance())?;
                 continue
             }
             if entry.is_initial() {
                 continue
             }
-            try!(write!(formatter, "  complex..."));
+            write!(formatter, "  complex...")?;
             if detailed_buffer.next().is_none() {
                 continue
             }
-            try!(write!(formatter,
+            write!(formatter,
                         "  detailed id={:?} advance={:?}\n",
                         entry.id(),
-                        entry.advance()));
+                        entry.advance())?;
         }
         Ok(())
     }

components/layout/floats.rs

@@ -78,9 +78,9 @@ impl FloatList {
 
 impl fmt::Debug for FloatList {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "max_block_start={:?} floats={}", self.max_block_start, self.floats.len()));
+        write!(f, "max_block_start={:?} floats={}", self.max_block_start, self.floats.len())?;
         for float in self.floats.iter() {
-            try!(write!(f, " {:?}", float));
+            write!(f, " {:?}", float)?;
         }
         Ok(())
     }

components/layout/flow.rs

@@ -1011,14 +1011,12 @@ impl fmt::Debug for BaseFlow {
 
 impl Serialize for BaseFlow {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut serializer = try!(serializer.serialize_struct("base", 5));
+        let mut serializer = serializer.serialize_struct("base", 5)?;
-        try!(serializer.serialize_field("id", &self.debug_id()));
+        serializer.serialize_field("id", &self.debug_id())?;
-        try!(serializer.serialize_field("stacking_relative_position",
+        serializer.serialize_field("stacking_relative_position", &self.stacking_relative_position)?;
-                                        &self.stacking_relative_position));
+        serializer.serialize_field("intrinsic_inline_sizes", &self.intrinsic_inline_sizes)?;
-        try!(serializer.serialize_field("intrinsic_inline_sizes",
+        serializer.serialize_field("position", &self.position)?;
-                                        &self.intrinsic_inline_sizes));
+        serializer.serialize_field("children", &self.children)?;
-        try!(serializer.serialize_field("position", &self.position));
-        try!(serializer.serialize_field("children", &self.children));
         serializer.end()
     }
 }

components/layout/flow_list.rs

@@ -24,7 +24,7 @@ pub struct FlowList {
 
 impl Serialize for FlowList {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut serializer = try!(serializer.serialize_seq(Some(self.len())));
+        let mut serializer = serializer.serialize_seq(Some(self.len()))?;
         for f in self.iter() {
             let mut flow_val = Map::new();
             flow_val.insert("class".to_owned(), to_value(f.class()).unwrap());
@@ -43,7 +43,7 @@ impl Serialize for FlowList {
                 }
             };
             flow_val.insert("data".to_owned(), data);
-            try!(serializer.serialize_element(&flow_val));
+            serializer.serialize_element(&flow_val)?;
         }
         serializer.end()
     }

components/layout/fragment.rs

@@ -143,10 +143,10 @@ pub struct Fragment {
 
 impl Serialize for Fragment {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut serializer = try!(serializer.serialize_struct("fragment", 3));
+        let mut serializer = serializer.serialize_struct("fragment", 3)?;
-        try!(serializer.serialize_field("id", &self.debug_id));
+        serializer.serialize_field("id", &self.debug_id)?;
-        try!(serializer.serialize_field("border_box", &self.border_box));
+        serializer.serialize_field("border_box", &self.border_box)?;
-        try!(serializer.serialize_field("margin", &self.margin));
+        serializer.serialize_field("margin", &self.margin)?;
         serializer.end()
     }
 }

components/layout_thread/lib.rs

@@ -1662,7 +1662,7 @@ fn get_root_flow_background_color(flow: &mut Flow) -> webrender_traits::ColorF {
 fn get_ua_stylesheets() -> Result<UserAgentStylesheets, &'static str> {
     fn parse_ua_stylesheet(shared_lock: &SharedRwLock, filename: &'static str)
                            -> Result<Stylesheet, &'static str> {
-        let res = try!(read_resource_file(filename).map_err(|_| filename));
+        let res = read_resource_file(filename).map_err(|_| filename)?;
         Ok(Stylesheet::from_bytes(
             &res,
             ServoUrl::parse(&format!("chrome://resources/{:?}", filename)).unwrap(),
@@ -1681,7 +1681,7 @@ fn get_ua_stylesheets() -> Result<UserAgentStylesheets, &'static str> {
     // FIXME: presentational-hints.css should be at author origin with zero specificity.
     //        (Does it make a difference?)
     for &filename in &["user-agent.css", "servo.css", "presentational-hints.css"] {
-        user_or_user_agent_stylesheets.push(try!(parse_ua_stylesheet(&shared_lock, filename)));
+        user_or_user_agent_stylesheets.push(parse_ua_stylesheet(&shared_lock, filename)?);
     }
     for &(ref contents, ref url) in &opts::get().user_stylesheets {
         user_or_user_agent_stylesheets.push(Stylesheet::from_bytes(
@@ -1689,7 +1689,7 @@ fn get_ua_stylesheets() -> Result<UserAgentStylesheets, &'static str> {
             shared_lock.clone(), None, &RustLogReporter, QuirksMode::NoQuirks));
     }
 
-    let quirks_mode_stylesheet = try!(parse_ua_stylesheet(&shared_lock, "quirks-mode.css"));
+    let quirks_mode_stylesheet = parse_ua_stylesheet(&shared_lock, "quirks-mode.css")?;
 
     Ok(UserAgentStylesheets {
         shared_lock: shared_lock,

components/net/connector.rs

@@ -36,7 +36,7 @@ impl NetworkConnector for HttpsConnector {
 
         // Perform host replacement when making the actual TCP connection.
         let addr = &(&*replace_host(host), port);
-        let stream = HttpStream(try!(TcpStream::connect(addr)));
+        let stream = HttpStream(TcpStream::connect(addr)?);
 
         if scheme == "http" {
             Ok(HttpsStream::Http(stream))

components/net/filemanager_thread.rs

@@ -357,14 +357,14 @@ impl FileManagerStore {
     fn create_entry(&self, file_path: &Path, origin: &str) -> Result<SelectedFile, FileManagerThreadError> {
         use net_traits::filemanager_thread::FileManagerThreadError::FileSystemError;
 
-        let file = try!(File::open(file_path).map_err(|e| FileSystemError(e.to_string())));
+        let file = File::open(file_path).map_err(|e| FileSystemError(e.to_string()))?;
-        let metadata = try!(file.metadata().map_err(|e| FileSystemError(e.to_string())));
+        let metadata = file.metadata().map_err(|e| FileSystemError(e.to_string()))?;
-        let modified = try!(metadata.modified().map_err(|e| FileSystemError(e.to_string())));
+        let modified = metadata.modified().map_err(|e| FileSystemError(e.to_string()))?;
-        let elapsed = try!(modified.elapsed().map_err(|e| FileSystemError(e.to_string())));
+        let elapsed = modified.elapsed().map_err(|e| FileSystemError(e.to_string()))?;
         // Unix Epoch: https://doc.servo.org/std/time/constant.UNIX_EPOCH.html
         let modified_epoch = elapsed.as_secs() * 1000 + elapsed.subsec_nanos() as u64 / 1000000;
         let file_size = metadata.len();
-        let file_name = try!(file_path.file_name().ok_or(FileSystemError("Invalid filepath".to_string())));
+        let file_name = file_path.file_name().ok_or(FileSystemError("Invalid filepath".to_string()))?;
 
         let file_impl = FileImpl::MetaDataOnly(FileMetaData {
             path: file_path.to_path_buf(),
@@ -400,7 +400,7 @@ impl FileManagerStore {
     fn get_blob_buf(&self, sender: &IpcSender<FileManagerResult<ReadFileProgress>>,
                     id: &Uuid, origin_in: &FileOrigin, rel_pos: RelativePos,
                     check_url_validity: bool) -> Result<(), BlobURLStoreError> {
-        let file_impl = try!(self.get_impl(id, origin_in, check_url_validity));
+        let file_impl = self.get_impl(id, origin_in, check_url_validity)?;
         match file_impl {
             FileImpl::Memory(buf) => {
                 let range = rel_pos.to_abs_range(buf.size as usize);
@@ -430,10 +430,10 @@ impl FileManagerStore {
                 let mime = guess_mime_type_opt(metadata.path.clone());
                 let range = rel_pos.to_abs_range(metadata.size as usize);
 
-                let mut file = try!(File::open(&metadata.path)
+                let mut file = File::open(&metadata.path)
-                                   .map_err(|e| BlobURLStoreError::External(e.to_string())));
+                                   .map_err(|e| BlobURLStoreError::External(e.to_string()))?;
-                let seeked_start = try!(file.seek(SeekFrom::Start(range.start as u64))
+                let seeked_start = file.seek(SeekFrom::Start(range.start as u64))
-                                       .map_err(|e| BlobURLStoreError::External(e.to_string())));
+                                       .map_err(|e| BlobURLStoreError::External(e.to_string()))?;
 
                 if seeked_start == (range.start as u64) {
                     let type_string = match mime {

components/net/http_loader.rs

@@ -317,7 +317,7 @@ impl StreamedResponse {
     fn from_http_response(response: WrappedHttpResponse) -> io::Result<StreamedResponse> {
         let decoder = match response.content_encoding() {
             Some(Encoding::Gzip) => {
-                Decoder::Gzip(try!(GzDecoder::new(response)))
+                Decoder::Gzip(GzDecoder::new(response)?)
             }
             Some(Encoding::Deflate) => {
                 Decoder::Deflate(DeflateDecoder::new(response))
@@ -1340,7 +1340,7 @@ fn cors_check(request: &Request, response: &Response) -> Result<(), ()> {
     let origin = response.headers.get::<AccessControlAllowOrigin>().cloned();
 
     // Step 2
-    let origin = try!(origin.ok_or(()));
+    let origin = origin.ok_or(())?;
 
     // Step 3
     if request.credentials_mode != CredentialsMode::Include &&

components/net/image_cache.rs

@@ -53,9 +53,9 @@ fn decode_bytes_sync(key: LoadKey, bytes: &[u8]) -> DecoderMsg {
 }
 
 fn get_placeholder_image(webrender_api: &webrender_traits::RenderApi, path: &PathBuf) -> io::Result<Arc<Image>> {
-    let mut file = try!(File::open(path));
+    let mut file = File::open(path)?;
     let mut image_data = vec![];
-    try!(file.read_to_end(&mut image_data));
+    file.read_to_end(&mut image_data)?;
     let mut image = load_from_memory(&image_data).unwrap();
     set_webrender_image_key(webrender_api, &mut image);
     Ok(Arc::new(image))

components/net/mime_classifier.rs

@@ -169,14 +169,14 @@ impl MimeClassifier {
     }
 
     pub fn validate(&self) -> Result<(), String> {
-        try!(self.image_classifier.validate());
+        self.image_classifier.validate()?;
-        try!(self.audio_video_classifier.validate());
+        self.audio_video_classifier.validate()?;
-        try!(self.scriptable_classifier.validate());
+        self.scriptable_classifier.validate()?;
-        try!(self.plaintext_classifier.validate());
+        self.plaintext_classifier.validate()?;
-        try!(self.archive_classifier.validate());
+        self.archive_classifier.validate()?;
-        try!(self.binary_or_plaintext.validate());
+        self.binary_or_plaintext.validate()?;
-        try!(self.feeds_classifier.validate());
+        self.feeds_classifier.validate()?;
-        try!(self.font_classifier.validate());
+        self.font_classifier.validate()?;
         Ok(())
     }
 
@@ -547,7 +547,7 @@ impl MIMEChecker for GroupedClassifier {
 
     fn validate(&self) -> Result<(), String> {
         for byte_matcher in &self.byte_matchers {
-            try!(byte_matcher.validate())
+            byte_matcher.validate()?
         }
         Ok(())
     }

components/net_traits/blob_url_store.rs

@@ -36,11 +36,11 @@ pub struct BlobBuf {
 /// Parse URL as Blob URL scheme's definition
 /// https://w3c.github.io/FileAPI/#DefinitionOfScheme
 pub fn parse_blob_url(url: &ServoUrl) -> Result<(Uuid, FileOrigin), ()> {
-    let url_inner = try!(Url::parse(url.path()).map_err(|_| ()));
+    let url_inner = Url::parse(url.path()).map_err(|_| ())?;
     let id = {
-        let mut segs = try!(url_inner.path_segments().ok_or(()));
+        let mut segs = url_inner.path_segments().ok_or(())?;
-        let id = try!(segs.nth(0).ok_or(()));
+        let id = segs.nth(0).ok_or(())?;
-        try!(Uuid::from_str(id).map_err(|_| ()))
+        Uuid::from_str(id).map_err(|_| ())?
     };
     Ok((id, get_blob_origin(&ServoUrl::from_url(url_inner))))
 }

components/script/body.rs

@@ -148,8 +148,8 @@ fn run_form_data_algorithm(root: &GlobalScope, bytes: Vec<u8>, mime: &[u8]) -> F
     } else {
         ""
     };
-    let mime: Mime = try!(mime_str.parse().map_err(
+    let mime: Mime = mime_str.parse().map_err(
-        |_| Error::Type("Inappropriate MIME-type for Body".to_string())));
+        |_| Error::Type("Inappropriate MIME-type for Body".to_string()))?;
     match mime {
         // TODO
         // ... Parser for Mime(TopLevel::Multipart, SubLevel::FormData, _)

components/script/dom/bindings/conversions.rs

@@ -390,7 +390,7 @@ pub unsafe fn private_from_proto_check<F>(mut obj: *mut JSObject,
                                           -> Result<*const libc::c_void, ()>
     where F: Fn(&'static DOMClass) -> bool
 {
-    let dom_class = try!(get_dom_class(obj).or_else(|_| {
+    let dom_class = get_dom_class(obj).or_else(|_| {
         if IsWrapper(obj) {
             trace!("found wrapper");
             obj = UnwrapObject(obj, /* stopAtWindowProxy = */ 0);
@@ -406,7 +406,7 @@ pub unsafe fn private_from_proto_check<F>(mut obj: *mut JSObject,
             trace!("not a dom wrapper");
             Err(())
         }
-    }));
+    })?;
 
     if proto_check(dom_class) {
         trace!("good prototype");

components/script/dom/bindings/mozmap.rs

@@ -69,7 +69,7 @@ impl<T, C> FromJSValConvertible for MozMap<T>
                 return Err(());
             }
 
-            let property = match try!(T::from_jsval(cx, property.handle(), config.clone())) {
+            let property = match T::from_jsval(cx, property.handle(), config.clone())? {
                 ConversionResult::Success(property) => property,
                 ConversionResult::Failure(message) => return Ok(ConversionResult::Failure(message)),
             };

components/script/dom/bindings/structuredclone.rs

@@ -114,7 +114,7 @@ unsafe fn write_blob(blob: Root<Blob>,
                      w: *mut JSStructuredCloneWriter)
                      -> Result<(), ()> {
     let structured_writer = StructuredCloneWriter { w: w };
-    let blob_vec = try!(blob.get_bytes());
+    let blob_vec = blob.get_bytes()?;
     assert!(JS_WriteUint32Pair(w, StructuredCloneTags::DomBlob as u32, 0));
     structured_writer.write_slice(&blob_vec);
     structured_writer.write_str(&blob.type_string());

components/script/dom/bindings/xmlname.rs

@@ -32,7 +32,7 @@ pub fn validate_and_extract(namespace: Option<DOMString>,
     let namespace = namespace_from_domstring(namespace);
 
     // Step 2.
-    try!(validate_qualified_name(qualified_name));
+    validate_qualified_name(qualified_name)?;
 
     let colon = ':';
 

components/script/dom/bluetooth.rs

@@ -328,7 +328,7 @@ fn canonicalize_filter(filter: &BluetoothLEScanFilterInit) -> Fallible<Bluetooth
 
             for service in services {
                 // Step 3.2 - 3.3.
-                let uuid = try!(BluetoothUUID::service(service.clone())).to_string();
+                let uuid = BluetoothUUID::service(service.clone())?.to_string();
 
                 // Step 3.4.
                 if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
@@ -393,7 +393,7 @@ fn canonicalize_filter(filter: &BluetoothLEScanFilterInit) -> Fallible<Bluetooth
                 // Step 7.3: No need to convert to IDL values since this is only used by native code.
 
                 // Step 7.4 - 7.5.
-                map.insert(manufacturer_id, try!(canonicalize_bluetooth_data_filter_init(bdfi)));
+                map.insert(manufacturer_id, canonicalize_bluetooth_data_filter_init(bdfi)?);
             }
             Some(map)
         },
@@ -417,7 +417,7 @@ fn canonicalize_filter(filter: &BluetoothLEScanFilterInit) -> Fallible<Bluetooth
                 };
 
                 // Step 9.3 - 9.4.
-                let service = try!(BluetoothUUID::service(service_name)).to_string();
+                let service = BluetoothUUID::service(service_name)?.to_string();
 
                 // Step 9.5.
                 if uuid_is_blocklisted(service.as_ref(), Blocklist::All) {
@@ -427,7 +427,7 @@ fn canonicalize_filter(filter: &BluetoothLEScanFilterInit) -> Fallible<Bluetooth
                 // Step 9.6: No need to convert to IDL values since this is only used by native code.
 
                 // Step 9.7 - 9.8.
-                map.insert(service, try!(canonicalize_bluetooth_data_filter_init(bdfi)));
+                map.insert(service, canonicalize_bluetooth_data_filter_init(bdfi)?);
             }
             Some(map)
         },

components/script/dom/canvasrenderingcontext2d.rs

@@ -1137,18 +1137,18 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
                 // https://html.spec.whatwg.org/multipage/#img-error
                 // If the image argument is an HTMLImageElement object that is in the broken state,
                 // then throw an InvalidStateError exception
-                try!(self.fetch_image_data(image).ok_or(Error::InvalidState))
+                self.fetch_image_data(image).ok_or(Error::InvalidState)?
             },
             HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D::HTMLCanvasElement(ref canvas) => {
                 let _ = canvas.get_or_init_2d_context();
 
-                try!(canvas.fetch_all_data().ok_or(Error::InvalidState))
+                canvas.fetch_all_data().ok_or(Error::InvalidState)?
             },
             HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D::CanvasRenderingContext2D(ref context) => {
                 let canvas = context.Canvas();
                 let _ = canvas.get_or_init_2d_context();
 
-                try!(canvas.fetch_all_data().ok_or(Error::InvalidState))
+                canvas.fetch_all_data().ok_or(Error::InvalidState)?
             }
         };
 

components/script/dom/dedicatedworkerglobalscope.rs

@@ -293,11 +293,11 @@ impl DedicatedWorkerGlobalScope {
         }
         let ret = sel.wait();
         if ret == worker_handle.id() {
-            Ok(MixedMessage::FromWorker(try!(worker_port.recv())))
+            Ok(MixedMessage::FromWorker(worker_port.recv()?))
         } else if ret == timer_event_handle.id() {
-            Ok(MixedMessage::FromScheduler(try!(timer_event_port.recv())))
+            Ok(MixedMessage::FromScheduler(timer_event_port.recv()?))
         } else if ret == devtools_handle.id() {
-            Ok(MixedMessage::FromDevtools(try!(devtools_port.recv())))
+            Ok(MixedMessage::FromDevtools(devtools_port.recv()?))
         } else {
             panic!("unexpected select result!")
         }
@@ -384,7 +384,7 @@ impl DedicatedWorkerGlobalScopeMethods for DedicatedWorkerGlobalScope {
     #[allow(unsafe_code)]
     // https://html.spec.whatwg.org/multipage/#dom-dedicatedworkerglobalscope-postmessage
     unsafe fn PostMessage(&self, cx: *mut JSContext, message: HandleValue) -> ErrorResult {
-        let data = try!(StructuredCloneData::write(cx, message));
+        let data = StructuredCloneData::write(cx, message)?;
         let worker = self.worker.borrow().as_ref().unwrap().clone();
         self.parent_sender
             .send(CommonScriptMsg::RunnableMsg(WorkerEvent,

components/script/dom/dissimilaroriginwindow.rs

@@ -146,7 +146,7 @@ impl DissimilarOriginWindowMethods for DissimilarOriginWindow {
 
         // Step 1-2, 6-8.
         // TODO(#12717): Should implement the `transfer` argument.
-        let data = try!(StructuredCloneData::write(cx, message));
+        let data = StructuredCloneData::write(cx, message)?;
 
         // Step 9.
         self.post_message(origin, data);

components/script/dom/document.rs

@@ -1454,7 +1454,7 @@ impl Document {
             for node in nodes {
                 match node {
                     NodeOrString::Node(node) => {
-                        try!(fragment.AppendChild(&node));
+                        fragment.AppendChild(&node)?;
                     },
                     NodeOrString::String(string) => {
                         let node = Root::upcast::<Node>(self.CreateTextNode(string));
@@ -2819,8 +2819,8 @@ impl DocumentMethods for Document {
                        namespace: Option<DOMString>,
                        qualified_name: DOMString)
                        -> Fallible<Root<Element>> {
-        let (namespace, prefix, local_name) = try!(validate_and_extract(namespace,
+        let (namespace, prefix, local_name) = validate_and_extract(namespace,
-                                                                        &qualified_name));
+                                                                        &qualified_name)?;
         let name = QualName::new(prefix, namespace, local_name);
         Ok(Element::create(name, self, ElementCreator::ScriptCreated))
     }
@@ -2845,8 +2845,8 @@ impl DocumentMethods for Document {
                          namespace: Option<DOMString>,
                          qualified_name: DOMString)
                          -> Fallible<Root<Attr>> {
-        let (namespace, prefix, local_name) = try!(validate_and_extract(namespace,
+        let (namespace, prefix, local_name) = validate_and_extract(namespace,
-                                                                        &qualified_name));
+                                                                        &qualified_name)?;
         let value = AttrValue::String("".to_owned());
         let qualified_name = LocalName::from(qualified_name);
         Ok(Attr::new(&self.window,

components/script/dom/domimplementation.rs

@@ -57,7 +57,7 @@ impl DOMImplementationMethods for DOMImplementation {
                           pubid: DOMString,
                           sysid: DOMString)
                           -> Fallible<Root<DocumentType>> {
-        try!(validate_qualified_name(&qualified_name));
+        validate_qualified_name(&qualified_name)?;
         Ok(DocumentType::new(qualified_name, Some(pubid), Some(sysid), &self.document))
     }
 

components/script/dom/domtokenlist.rs

@@ -84,7 +84,7 @@ impl DOMTokenListMethods for DOMTokenList {
     fn Add(&self, tokens: Vec<DOMString>) -> ErrorResult {
         let mut atoms = self.element.get_tokenlist_attribute(&self.local_name);
         for token in &tokens {
-            let token = try!(self.check_token_exceptions(&token));
+            let token = self.check_token_exceptions(&token)?;
             if !atoms.iter().any(|atom| *atom == token) {
                 atoms.push(token);
             }
@@ -97,7 +97,7 @@ impl DOMTokenListMethods for DOMTokenList {
     fn Remove(&self, tokens: Vec<DOMString>) -> ErrorResult {
         let mut atoms = self.element.get_tokenlist_attribute(&self.local_name);
         for token in &tokens {
-            let token = try!(self.check_token_exceptions(&token));
+            let token = self.check_token_exceptions(&token)?;
             atoms.iter().position(|atom| *atom == token).map(|index| atoms.remove(index));
         }
         self.element.set_atomic_tokenlist_attribute(&self.local_name, atoms);
@@ -107,7 +107,7 @@ impl DOMTokenListMethods for DOMTokenList {
     // https://dom.spec.whatwg.org/#dom-domtokenlist-toggle
     fn Toggle(&self, token: DOMString, force: Option<bool>) -> Fallible<bool> {
         let mut atoms = self.element.get_tokenlist_attribute(&self.local_name);
-        let token = try!(self.check_token_exceptions(&token));
+        let token = self.check_token_exceptions(&token)?;
         match atoms.iter().position(|atom| *atom == token) {
             Some(index) => match force {
                 Some(true) => Ok(true),

components/script/dom/element.rs

@@ -144,9 +144,9 @@ pub struct Element {
 
 impl fmt::Debug for Element {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "<{}", self.local_name));
+        write!(f, "<{}", self.local_name)?;
         if let Some(ref id) = *self.id_attribute.borrow() {
-            try!(write!(f, " id={}", id));
+            write!(f, " id={}", id)?;
         }
         write!(f, ">")
     }
@@ -1532,7 +1532,7 @@ impl ElementMethods for Element {
                       qualified_name: DOMString,
                       value: DOMString) -> ErrorResult {
         let (namespace, prefix, local_name) =
-            try!(validate_and_extract(namespace, &qualified_name));
+            validate_and_extract(namespace, &qualified_name)?;
         let qualified_name = LocalName::from(qualified_name);
         let value = self.parse_attribute(&namespace, &local_name, value);
         self.set_first_matching_attribute(
@@ -1929,7 +1929,7 @@ impl ElementMethods for Element {
     /// https://w3c.github.io/DOM-Parsing/#widl-Element-innerHTML
     fn SetInnerHTML(&self, value: DOMString) -> ErrorResult {
         // Step 1.
-        let frag = try!(self.parse_fragment(value));
+        let frag = self.parse_fragment(value)?;
         // Step 2.
         // https://github.com/w3c/DOM-Parsing/issues/1
         let target = if let Some(template) = self.downcast::<HTMLTemplateElement>() {
@@ -1974,9 +1974,9 @@ impl ElementMethods for Element {
         };
 
         // Step 5.
-        let frag = try!(parent.parse_fragment(value));
+        let frag = parent.parse_fragment(value)?;
         // Step 6.
-        try!(context_parent.ReplaceChild(frag.upcast(), context_node));
+        context_parent.ReplaceChild(frag.upcast(), context_node)?;
         Ok(())
     }
 
@@ -2095,8 +2095,8 @@ impl ElementMethods for Element {
     // https://dom.spec.whatwg.org/#dom-element-insertadjacentelement
     fn InsertAdjacentElement(&self, where_: DOMString, element: &Element)
                              -> Fallible<Option<Root<Element>>> {
-        let where_ = try!(AdjacentPosition::try_from(&*where_));
+        let where_ = AdjacentPosition::try_from(&*where_)?;
-        let inserted_node = try!(self.insert_adjacent(where_, element.upcast()));
+        let inserted_node = self.insert_adjacent(where_, element.upcast())?;
         Ok(inserted_node.map(|node| Root::downcast(node).unwrap()))
     }
 
@@ -2107,7 +2107,7 @@ impl ElementMethods for Element {
         let text = Text::new(data, &document_from_node(self));
 
         // Step 2.
-        let where_ = try!(AdjacentPosition::try_from(&*where_));
+        let where_ = AdjacentPosition::try_from(&*where_)?;
         self.insert_adjacent(where_, text.upcast()).map(|_| ())
     }
 
@@ -2115,7 +2115,7 @@ impl ElementMethods for Element {
     fn InsertAdjacentHTML(&self, position: DOMString, text: DOMString)
                           -> ErrorResult {
         // Step 1.
-        let position = try!(AdjacentPosition::try_from(&*position));
+        let position = AdjacentPosition::try_from(&*position)?;
 
         let context = match position {
             AdjacentPosition::BeforeBegin | AdjacentPosition::AfterEnd => {
@@ -2137,7 +2137,7 @@ impl ElementMethods for Element {
             &context.owner_doc(), context.downcast::<Element>());
 
         // Step 3.
-        let fragment = try!(context.parse_fragment(text));
+        let fragment = context.parse_fragment(text)?;
 
         // Step 4.
         self.insert_adjacent(position, fragment.upcast()).map(|_| ())

components/script/dom/headers.rs

@@ -52,7 +52,7 @@ impl Headers {
     pub fn Constructor(global: &GlobalScope, init: Option<HeadersInit>)
                        -> Fallible<Root<Headers>> {
         let dom_headers_new = Headers::new(global);
-        try!(dom_headers_new.fill(init));
+        dom_headers_new.fill(init)?;
         Ok(dom_headers_new)
     }
 }
@@ -63,7 +63,7 @@ impl HeadersMethods for Headers {
         // Step 1
         let value = normalize_value(value);
         // Step 2
-        let (mut valid_name, valid_value) = try!(validate_name_and_value(name, value));
+        let (mut valid_name, valid_value) = validate_name_and_value(name, value)?;
         valid_name = valid_name.to_lowercase();
         // Step 3
         if self.guard.get() == Guard::Immutable {
@@ -95,7 +95,7 @@ impl HeadersMethods for Headers {
     // https://fetch.spec.whatwg.org/#dom-headers-delete
     fn Delete(&self, name: ByteString) -> ErrorResult {
         // Step 1
-        let valid_name = try!(validate_name(name));
+        let valid_name = validate_name(name)?;
         // Step 2
         if self.guard.get() == Guard::Immutable {
             return Err(Error::Type("Guard is immutable".to_string()));
@@ -121,7 +121,7 @@ impl HeadersMethods for Headers {
     // https://fetch.spec.whatwg.org/#dom-headers-get
     fn Get(&self, name: ByteString) -> Fallible<Option<ByteString>> {
         // Step 1
-        let valid_name = &try!(validate_name(name));
+        let valid_name = &validate_name(name)?;
         Ok(self.header_list.borrow().get_raw(&valid_name).map(|v| {
             ByteString::new(v[0].clone())
         }))
@@ -130,7 +130,7 @@ impl HeadersMethods for Headers {
     // https://fetch.spec.whatwg.org/#dom-headers-has
     fn Has(&self, name: ByteString) -> Fallible<bool> {
         // Step 1
-        let valid_name = try!(validate_name(name));
+        let valid_name = validate_name(name)?;
         // Step 2
         Ok(self.header_list.borrow_mut().get_raw(&valid_name).is_some())
     }
@@ -140,7 +140,7 @@ impl HeadersMethods for Headers {
         // Step 1
         let value = normalize_value(value);
         // Step 2
-        let (mut valid_name, valid_value) = try!(validate_name_and_value(name, value));
+        let (mut valid_name, valid_value) = validate_name_and_value(name, value)?;
         valid_name = valid_name.to_lowercase();
         // Step 3
         if self.guard.get() == Guard::Immutable {
@@ -172,10 +172,10 @@ impl Headers {
             // Step 1
             Some(HeadersInit::Headers(h)) => {
                 for header in h.header_list.borrow().iter() {
-                    try!(self.Append(
+                    self.Append(
                         ByteString::new(Vec::from(header.name())),
                         ByteString::new(Vec::from(header.value_string().into_bytes()))
-                    ));
+                    )?;
                 }
                 Ok(())
             },
@@ -185,7 +185,7 @@ impl Headers {
                     if seq.len() == 2 {
                         let val = seq.pop().unwrap();
                         let name = seq.pop().unwrap();
-                        try!(self.Append(name, val));
+                        self.Append(name, val)?;
                     } else {
                         return Err(Error::Type(
                             format!("Each header object must be a sequence of length 2 - found one with length {}",
@@ -198,7 +198,7 @@ impl Headers {
                 for (key, value) in m.iter() {
                     let key_vec = key.as_ref().to_string().into();
                     let headers_key = ByteString::new(key_vec);
-                    try!(self.Append(headers_key, value.clone()));
+                    self.Append(headers_key, value.clone())?;
                 }
                 Ok(())
             },
@@ -360,7 +360,7 @@ pub fn is_forbidden_header_name(name: &str) -> bool {
 // [4] https://www.rfc-editor.org/errata_search.php?rfc=7230
 fn validate_name_and_value(name: ByteString, value: ByteString)
                            -> Fallible<(String, Vec<u8>)> {
-    let valid_name = try!(validate_name(name));
+    let valid_name = validate_name(name)?;
     if !is_field_content(&value) {
         return Err(Error::Type("Value is not valid".to_string()));
     }

components/script/dom/htmlcanvaselement.rs

@@ -297,9 +297,9 @@ impl HTMLCanvasElementMethods for HTMLCanvasElement {
         // Step 3.
         let raw_data = match *self.context.borrow() {
             Some(CanvasContext::Context2d(ref context)) => {
-                let image_data = try!(context.GetImageData(Finite::wrap(0f64), Finite::wrap(0f64),
+                let image_data = context.GetImageData(Finite::wrap(0f64), Finite::wrap(0f64),
                                                            Finite::wrap(self.Width() as f64),
-                                                           Finite::wrap(self.Height() as f64)));
+                                                           Finite::wrap(self.Height() as f64))?;
                 image_data.get_data_array()
             }
             None => {

components/script/dom/htmloptionscollection.rs

@@ -49,7 +49,7 @@ impl HTMLOptionsCollection {
         for _ in 0..count {
             let element = HTMLOptionElement::new(local_name!("option"), None, &document);
             let node = element.upcast::<Node>();
-            try!(root.AppendChild(node));
+            root.AppendChild(node)?;
         };
         Ok(())
     }
@@ -90,7 +90,7 @@ impl HTMLOptionsCollectionMethods for HTMLOptionsCollection {
 
             // Step 4
             if n > 0 {
-                try!(self.add_new_elements(n as u32));
+                self.add_new_elements(n as u32)?;
             }
 
             // Step 5

components/script/dom/htmltableelement.rs

@@ -103,7 +103,7 @@ impl HTMLTableElement {
             let reference_element = node.child_elements().find(reference_predicate);
             let reference_node = reference_element.r().map(|e| e.upcast());
 
-            try!(node.InsertBefore(section.upcast(), reference_node));
+            node.InsertBefore(section.upcast(), reference_node)?;
         }
 
         Ok(())

components/script/dom/imagedata.rs

@@ -65,8 +65,8 @@ impl ImageData {
         if let Some(jsobject) = opt_jsobject {
             let cx = global.get_cx();
             typedarray!(in(cx) let array_res: Uint8ClampedArray = jsobject);
-            let mut array = try!(array_res
+            let mut array = array_res
-                .map_err(|_| Error::Type("Argument to Image data is not an Uint8ClampedArray".to_owned())));
+                .map_err(|_| Error::Type("Argument to Image data is not an Uint8ClampedArray".to_owned()))?;
 
             let byte_len = array.as_slice().len() as u32;
             if byte_len % 4 != 0 {

components/script/dom/location.rs

@@ -70,7 +70,7 @@ impl Location {
 impl LocationMethods for Location {
     // https://html.spec.whatwg.org/multipage/#dom-location-assign
     fn Assign(&self, url: USVString) -> ErrorResult {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         // TODO: per spec, we should use the _API base URL_ specified by the
         //       _entry settings object_.
         let base_url = self.window.get_url();
@@ -84,7 +84,7 @@ impl LocationMethods for Location {
 
     // https://html.spec.whatwg.org/multipage/#dom-location-reload
     fn Reload(&self) -> ErrorResult {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         self.window.load_url(self.get_url(), true, true, None);
         Ok(())
     }
@@ -105,7 +105,7 @@ impl LocationMethods for Location {
 
     // https://html.spec.whatwg.org/multipage/#dom-location-hash
     fn GetHash(&self) -> Fallible<USVString> {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         Ok(UrlHelper::Hash(&self.get_url()))
     }
 
@@ -114,46 +114,46 @@ impl LocationMethods for Location {
         if value.0.is_empty() {
             value = USVString("#".to_owned());
         }
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         self.set_url_component(value, UrlHelper::SetHash);
         Ok(())
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-host
     fn GetHost(&self) -> Fallible<USVString> {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         Ok(UrlHelper::Host(&self.get_url()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-host
     fn SetHost(&self, value: USVString) -> ErrorResult {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         self.set_url_component(value, UrlHelper::SetHost);
         Ok(())
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-origin
     fn GetOrigin(&self) -> Fallible<USVString> {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         Ok(UrlHelper::Origin(&self.get_url()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-hostname
     fn GetHostname(&self) -> Fallible<USVString> {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         Ok(UrlHelper::Hostname(&self.get_url()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-hostname
     fn SetHostname(&self, value: USVString) -> ErrorResult {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         self.set_url_component(value, UrlHelper::SetHostname);
         Ok(())
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-href
     fn GetHref(&self) -> Fallible<USVString> {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         Ok(UrlHelper::Href(&self.get_url()))
     }
 
@@ -170,57 +170,57 @@ impl LocationMethods for Location {
 
     // https://html.spec.whatwg.org/multipage/#dom-location-pathname
     fn GetPathname(&self) -> Fallible<USVString> {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         Ok(UrlHelper::Pathname(&self.get_url()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-pathname
     fn SetPathname(&self, value: USVString) -> ErrorResult {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         self.set_url_component(value, UrlHelper::SetPathname);
         Ok(())
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-port
     fn GetPort(&self) -> Fallible<USVString> {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         Ok(UrlHelper::Port(&self.get_url()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-port
     fn SetPort(&self, value: USVString) -> ErrorResult {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         self.set_url_component(value, UrlHelper::SetPort);
         Ok(())
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-protocol
     fn GetProtocol(&self) -> Fallible<USVString> {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         Ok(UrlHelper::Protocol(&self.get_url()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-protocol
     fn SetProtocol(&self, value: USVString) -> ErrorResult {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         self.set_url_component(value, UrlHelper::SetProtocol);
         Ok(())
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-href
     fn Stringifier(&self) -> Fallible<DOMString> {
-        Ok(DOMString::from(try!(self.GetHref()).0))
+        Ok(DOMString::from(self.GetHref()?.0))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-search
     fn GetSearch(&self) -> Fallible<USVString> {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         Ok(UrlHelper::Search(&self.get_url()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-location-search
     fn SetSearch(&self, value: USVString) -> ErrorResult {
-        try!(self.check_same_origin_domain());
+        self.check_same_origin_domain()?;
         self.set_url_component(value, UrlHelper::SetSearch);
         Ok(())
     }

components/script/dom/node.rs

@@ -631,7 +631,7 @@ impl Node {
         let viable_previous_sibling = first_node_not_in(self.preceding_siblings(), &nodes);
 
         // Step 4.
-        let node = try!(self.owner_doc().node_from_nodes_and_strings(nodes));
+        let node = self.owner_doc().node_from_nodes_and_strings(nodes)?;
 
         // Step 5.
         let viable_previous_sibling = match viable_previous_sibling {
@@ -640,7 +640,7 @@ impl Node {
         };
 
         // Step 6.
-        try!(Node::pre_insert(&node, &parent, viable_previous_sibling.r()));
+        Node::pre_insert(&node, &parent, viable_previous_sibling.r())?;
 
         Ok(())
     }
@@ -660,10 +660,10 @@ impl Node {
         let viable_next_sibling = first_node_not_in(self.following_siblings(), &nodes);
 
         // Step 4.
-        let node = try!(self.owner_doc().node_from_nodes_and_strings(nodes));
+        let node = self.owner_doc().node_from_nodes_and_strings(nodes)?;
 
         // Step 5.
-        try!(Node::pre_insert(&node, &parent, viable_next_sibling.r()));
+        Node::pre_insert(&node, &parent, viable_next_sibling.r())?;
 
         Ok(())
     }
@@ -680,13 +680,13 @@ impl Node {
         // Step 3.
         let viable_next_sibling = first_node_not_in(self.following_siblings(), &nodes);
         // Step 4.
-        let node = try!(self.owner_doc().node_from_nodes_and_strings(nodes));
+        let node = self.owner_doc().node_from_nodes_and_strings(nodes)?;
         if self.parent_node == Some(&*parent) {
             // Step 5.
-            try!(parent.ReplaceChild(&node, self));
+            parent.ReplaceChild(&node, self)?;
         } else {
             // Step 6.
-            try!(Node::pre_insert(&node, &parent, viable_next_sibling.r()));
+            Node::pre_insert(&node, &parent, viable_next_sibling.r())?;
         }
         Ok(())
     }
@@ -695,7 +695,7 @@ impl Node {
     pub fn prepend(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
         // Step 1.
         let doc = self.owner_doc();
-        let node = try!(doc.node_from_nodes_and_strings(nodes));
+        let node = doc.node_from_nodes_and_strings(nodes)?;
         // Step 2.
         let first_child = self.first_child.get();
         Node::pre_insert(&node, self, first_child.r()).map(|_| ())
@@ -705,7 +705,7 @@ impl Node {
     pub fn append(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
         // Step 1.
         let doc = self.owner_doc();
-        let node = try!(doc.node_from_nodes_and_strings(nodes));
+        let node = doc.node_from_nodes_and_strings(nodes)?;
         // Step 2.
         self.AppendChild(&node).map(|_| ())
     }
@@ -751,7 +751,7 @@ impl Node {
     #[allow(unsafe_code)]
     pub fn query_selector_all(&self, selectors: DOMString) -> Fallible<Root<NodeList>> {
         let window = window_from_node(self);
-        let iter = try!(self.query_selector_iter(selectors));
+        let iter = self.query_selector_iter(selectors)?;
         Ok(NodeList::new_simple_list(&window, iter))
     }
 
@@ -852,7 +852,7 @@ impl Node {
         {
             let tr_node = tr.upcast::<Node>();
             if index == -1 {
-                try!(self.InsertBefore(tr_node, None));
+                self.InsertBefore(tr_node, None)?;
             } else {
                 let items = get_items();
                 let node = match items.elements_iter()
@@ -863,7 +863,7 @@ impl Node {
                     None => return Err(Error::IndexSize),
                     Some(node) => node,
                 };
-                try!(self.InsertBefore(tr_node, node.r()));
+                self.InsertBefore(tr_node, node.r())?;
             }
         }
 
@@ -1566,7 +1566,7 @@ impl Node {
     pub fn pre_insert(node: &Node, parent: &Node, child: Option<&Node>)
                       -> Fallible<Root<Node>> {
         // Step 1.
-        try!(Node::ensure_pre_insertion_validity(node, parent, child));
+        Node::ensure_pre_insertion_validity(node, parent, child)?;
 
         // Steps 2-3.
         let reference_child_root;

components/script/dom/nodeiterator.rs

@@ -107,7 +107,7 @@ impl NodeIteratorMethods for NodeIterator {
             before_node = false;
 
             // Step 3-2.
-            let result = try!(self.accept_node(&node));
+            let result = self.accept_node(&node)?;
 
             // Step 3-3.
             if result == NodeFilterConstants::FILTER_ACCEPT {
@@ -122,7 +122,7 @@ impl NodeIteratorMethods for NodeIterator {
         // Step 3-1.
         for following_node in node.following_nodes(&self.root_node) {
             // Step 3-2.
-            let result = try!(self.accept_node(&following_node));
+            let result = self.accept_node(&following_node)?;
 
             // Step 3-3.
             if result == NodeFilterConstants::FILTER_ACCEPT {
@@ -151,7 +151,7 @@ impl NodeIteratorMethods for NodeIterator {
             before_node = true;
 
             // Step 3-2.
-            let result = try!(self.accept_node(&node));
+            let result = self.accept_node(&node)?;
 
             // Step 3-3.
             if result == NodeFilterConstants::FILTER_ACCEPT {
@@ -166,7 +166,7 @@ impl NodeIteratorMethods for NodeIterator {
         // Step 3-1.
         for preceding_node in node.preceding_nodes(&self.root_node) {
             // Step 3-2.
-            let result = try!(self.accept_node(&preceding_node));
+            let result = self.accept_node(&preceding_node)?;
 
             // Step 3-3.
             if result == NodeFilterConstants::FILTER_ACCEPT {

components/script/dom/range.rs

@@ -269,25 +269,25 @@ impl RangeMethods for Range {
 
     // https://dom.spec.whatwg.org/#dom-range-setstartbefore
     fn SetStartBefore(&self, node: &Node) -> ErrorResult {
-        let parent = try!(node.GetParentNode().ok_or(Error::InvalidNodeType));
+        let parent = node.GetParentNode().ok_or(Error::InvalidNodeType)?;
         self.SetStart(&parent, node.index())
     }
 
     // https://dom.spec.whatwg.org/#dom-range-setstartafter
     fn SetStartAfter(&self, node: &Node) -> ErrorResult {
-        let parent = try!(node.GetParentNode().ok_or(Error::InvalidNodeType));
+        let parent = node.GetParentNode().ok_or(Error::InvalidNodeType)?;
         self.SetStart(&parent, node.index() + 1)
     }
 
     // https://dom.spec.whatwg.org/#dom-range-setendbefore
     fn SetEndBefore(&self, node: &Node) -> ErrorResult {
-        let parent = try!(node.GetParentNode().ok_or(Error::InvalidNodeType));
+        let parent = node.GetParentNode().ok_or(Error::InvalidNodeType)?;
         self.SetEnd(&parent, node.index())
     }
 
     // https://dom.spec.whatwg.org/#dom-range-setendafter
     fn SetEndAfter(&self, node: &Node) -> ErrorResult {
-        let parent = try!(node.GetParentNode().ok_or(Error::InvalidNodeType));
+        let parent = node.GetParentNode().ok_or(Error::InvalidNodeType)?;
         self.SetEnd(&parent, node.index() + 1)
     }
 
@@ -303,7 +303,7 @@ impl RangeMethods for Range {
     // https://dom.spec.whatwg.org/#dom-range-selectnode
     fn SelectNode(&self, node: &Node) -> ErrorResult {
         // Steps 1, 2.
-        let parent = try!(node.GetParentNode().ok_or(Error::InvalidNodeType));
+        let parent = node.GetParentNode().ok_or(Error::InvalidNodeType)?;
         // Step 3.
         let index = node.index();
         // Step 4.
@@ -446,7 +446,7 @@ impl RangeMethods for Range {
                 let data = cdata.SubstringData(start_offset, end_offset - start_offset).unwrap();
                 let clone = cdata.clone_with_data(data, &start_node.owner_doc());
                 // Step 4.3.
-                try!(fragment.upcast::<Node>().AppendChild(&clone));
+                fragment.upcast::<Node>().AppendChild(&clone)?;
                 // Step 4.4
                 return Ok(fragment);
             }
@@ -454,7 +454,7 @@ impl RangeMethods for Range {
 
         // Steps 5-12.
         let (first_contained_child, last_contained_child, contained_children) =
-            try!(self.contained_children());
+            self.contained_children()?;
 
         if let Some(child) = first_contained_child {
             // Step 13.
@@ -464,12 +464,12 @@ impl RangeMethods for Range {
                 let data = cdata.SubstringData(start_offset, start_node.len() - start_offset).unwrap();
                 let clone = cdata.clone_with_data(data, &start_node.owner_doc());
                 // Step 13.3.
-                try!(fragment.upcast::<Node>().AppendChild(&clone));
+                fragment.upcast::<Node>().AppendChild(&clone)?;
             } else {
                 // Step 14.1.
                 let clone = child.CloneNode(false);
                 // Step 14.2.
-                try!(fragment.upcast::<Node>().AppendChild(&clone));
+                fragment.upcast::<Node>().AppendChild(&clone)?;
                 // Step 14.3.
                 let subrange = Range::new(&clone.owner_doc(),
                                           &start_node,
@@ -477,9 +477,9 @@ impl RangeMethods for Range {
                                           &child,
                                           child.len());
                 // Step 14.4.
-                let subfragment = try!(subrange.CloneContents());
+                let subfragment = subrange.CloneContents()?;
                 // Step 14.5.
-                try!(clone.AppendChild(subfragment.upcast()));
+                clone.AppendChild(subfragment.upcast())?;
             }
         }
 
@@ -488,7 +488,7 @@ impl RangeMethods for Range {
             // Step 15.1.
             let clone = child.CloneNode(true);
             // Step 15.2.
-            try!(fragment.upcast::<Node>().AppendChild(&clone));
+            fragment.upcast::<Node>().AppendChild(&clone)?;
         }
 
         if let Some(child) = last_contained_child {
@@ -499,12 +499,12 @@ impl RangeMethods for Range {
                 let data = cdata.SubstringData(0, end_offset).unwrap();
                 let clone = cdata.clone_with_data(data, &start_node.owner_doc());
                 // Step 16.3.
-                try!(fragment.upcast::<Node>().AppendChild(&clone));
+                fragment.upcast::<Node>().AppendChild(&clone)?;
             } else {
                 // Step 17.1.
                 let clone = child.CloneNode(false);
                 // Step 17.2.
-                try!(fragment.upcast::<Node>().AppendChild(&clone));
+                fragment.upcast::<Node>().AppendChild(&clone)?;
                 // Step 17.3.
                 let subrange = Range::new(&clone.owner_doc(),
                                           &child,
@@ -512,9 +512,9 @@ impl RangeMethods for Range {
                                           &end_node,
                                           end_offset);
                 // Step 17.4.
-                let subfragment = try!(subrange.CloneContents());
+                let subfragment = subrange.CloneContents()?;
                 // Step 17.5.
-                try!(clone.AppendChild(subfragment.upcast()));
+                clone.AppendChild(subfragment.upcast())?;
             }
         }
 
@@ -547,11 +547,11 @@ impl RangeMethods for Range {
                 let text = end_data.SubstringData(start_offset, end_offset - start_offset);
                 clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 4.3.
-                try!(fragment.upcast::<Node>().AppendChild(&clone));
+                fragment.upcast::<Node>().AppendChild(&clone)?;
                 // Step 4.4.
-                try!(end_data.ReplaceData(start_offset,
+                end_data.ReplaceData(start_offset,
                                           end_offset - start_offset,
-                                          DOMString::new()));
+                                          DOMString::new())?;
                 // Step 4.5.
                 return Ok(fragment);
             }
@@ -559,7 +559,7 @@ impl RangeMethods for Range {
 
         // Steps 5-12.
         let (first_contained_child, last_contained_child, contained_children) =
-            try!(self.contained_children());
+            self.contained_children()?;
 
         let (new_node, new_offset) = if start_node.is_inclusive_ancestor_of(&end_node) {
             // Step 13.
@@ -584,16 +584,16 @@ impl RangeMethods for Range {
                                                     start_node.len() - start_offset);
                 clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 15.3.
-                try!(fragment.upcast::<Node>().AppendChild(&clone));
+                fragment.upcast::<Node>().AppendChild(&clone)?;
                 // Step 15.4.
-                try!(start_data.ReplaceData(start_offset,
+                start_data.ReplaceData(start_offset,
                                             start_node.len() - start_offset,
-                                            DOMString::new()));
+                                            DOMString::new())?;
             } else {
                 // Step 16.1.
                 let clone = child.CloneNode(false);
                 // Step 16.2.
-                try!(fragment.upcast::<Node>().AppendChild(&clone));
+                fragment.upcast::<Node>().AppendChild(&clone)?;
                 // Step 16.3.
                 let subrange = Range::new(&clone.owner_doc(),
                                           &start_node,
@@ -601,15 +601,15 @@ impl RangeMethods for Range {
                                           &child,
                                           child.len());
                 // Step 16.4.
-                let subfragment = try!(subrange.ExtractContents());
+                let subfragment = subrange.ExtractContents()?;
                 // Step 16.5.
-                try!(clone.AppendChild(subfragment.upcast()));
+                clone.AppendChild(subfragment.upcast())?;
             }
         }
 
         // Step 17.
         for child in contained_children {
-            try!(fragment.upcast::<Node>().AppendChild(&child));
+            fragment.upcast::<Node>().AppendChild(&child)?;
         }
 
         if let Some(child) = last_contained_child {
@@ -621,14 +621,14 @@ impl RangeMethods for Range {
                 let text = end_data.SubstringData(0, end_offset);
                 clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 18.3.
-                try!(fragment.upcast::<Node>().AppendChild(&clone));
+                fragment.upcast::<Node>().AppendChild(&clone)?;
                 // Step 18.4.
-                try!(end_data.ReplaceData(0, end_offset, DOMString::new()));
+                end_data.ReplaceData(0, end_offset, DOMString::new())?;
             } else {
                 // Step 19.1.
                 let clone = child.CloneNode(false);
                 // Step 19.2.
-                try!(fragment.upcast::<Node>().AppendChild(&clone));
+                fragment.upcast::<Node>().AppendChild(&clone)?;
                 // Step 19.3.
                 let subrange = Range::new(&clone.owner_doc(),
                                           &child,
@@ -636,15 +636,15 @@ impl RangeMethods for Range {
                                           &end_node,
                                           end_offset);
                 // Step 19.4.
-                let subfragment = try!(subrange.ExtractContents());
+                let subfragment = subrange.ExtractContents()?;
                 // Step 19.5.
-                try!(clone.AppendChild(subfragment.upcast()));
+                clone.AppendChild(subfragment.upcast())?;
             }
         }
 
         // Step 20.
-        try!(self.SetStart(&new_node, new_offset));
+        self.SetStart(&new_node, new_offset)?;
-        try!(self.SetEnd(&new_node, new_offset));
+        self.SetEnd(&new_node, new_offset)?;
 
         // Step 21.
         Ok(fragment)
@@ -690,16 +690,16 @@ impl RangeMethods for Range {
             };
 
         // Step 6.
-        try!(Node::ensure_pre_insertion_validity(node,
+        Node::ensure_pre_insertion_validity(node,
                                                  &parent,
-                                                 reference_node.r()));
+                                                 reference_node.r())?;
 
         // Step 7.
         let split_text;
         let reference_node =
             match start_node.downcast::<Text>() {
                 Some(text) => {
-                    split_text = try!(text.SplitText(start_offset));
+                    split_text = text.SplitText(start_offset)?;
                     let new_reference = Root::upcast::<Node>(split_text);
                     assert!(new_reference.GetParentNode().r() == Some(&parent));
                     Some(new_reference)
@@ -729,7 +729,7 @@ impl RangeMethods for Range {
         };
 
         // Step 12.
-        try!(Node::pre_insert(node, &parent, reference_node.r()));
+        Node::pre_insert(node, &parent, reference_node.r())?;
 
         // Step 13.
         if self.Collapsed() {
@@ -839,16 +839,16 @@ impl RangeMethods for Range {
         }
 
         // Step 3.
-        let fragment = try!(self.ExtractContents());
+        let fragment = self.ExtractContents()?;
 
         // Step 4.
         Node::replace_all(None, new_parent);
 
         // Step 5.
-        try!(self.InsertNode(new_parent));
+        self.InsertNode(new_parent)?;
 
         // Step 6.
-        try!(new_parent.AppendChild(fragment.upcast()));
+        new_parent.AppendChild(fragment.upcast())?;
 
         // Step 7.
         self.SelectNode(new_parent)
@@ -915,7 +915,7 @@ impl RangeMethods for Range {
         let element = Element::fragment_parsing_context(&owner_doc, element.r());
 
         // Step 3.
-        let fragment_node = try!(element.parse_fragment(fragment));
+        let fragment_node = element.parse_fragment(fragment)?;
 
         // Step 4.
         for node in fragment_node.upcast::<Node>().traverse_preorder() {

components/script/dom/request.rs

@@ -308,12 +308,12 @@ impl Request {
                     headers_copy = Root::from_ref(&*init_headers);
                 }
                 &HeadersInit::ByteStringSequenceSequence(ref init_sequence) => {
-                    try!(headers_copy.fill(Some(
+                    headers_copy.fill(Some(
-                        HeadersInit::ByteStringSequenceSequence(init_sequence.clone()))));
+                        HeadersInit::ByteStringSequenceSequence(init_sequence.clone())))?;
                 },
                 &HeadersInit::StringByteStringRecord(ref init_map) => {
-                    try!(headers_copy.fill(Some(
+                    headers_copy.fill(Some(
-                        HeadersInit::StringByteStringRecord(init_map.clone()))));
+                        HeadersInit::StringByteStringRecord(init_map.clone())))?;
                 },
             }
         }
@@ -351,10 +351,10 @@ impl Request {
                 // but an input with headers is given, set request's
                 // headers as the input's Headers.
                 if let RequestInfo::Request(ref input_request) = input {
-                    try!(r.Headers().fill(Some(HeadersInit::Headers(input_request.Headers()))));
+                    r.Headers().fill(Some(HeadersInit::Headers(input_request.Headers())))?;
                 }
             },
-            Some(HeadersInit::Headers(_)) => try!(r.Headers().fill(Some(HeadersInit::Headers(headers_copy)))),
+            Some(HeadersInit::Headers(_)) => r.Headers().fill(Some(HeadersInit::Headers(headers_copy)))?,
             _ => {},
         }
 
@@ -391,8 +391,8 @@ impl Request {
             // Step 34.3
             if let Some(contents) = content_type {
                 if !r.Headers().Has(ByteString::new(b"Content-Type".to_vec())).unwrap() {
-                    try!(r.Headers().Append(ByteString::new(b"Content-Type".to_vec()),
+                    r.Headers().Append(ByteString::new(b"Content-Type".to_vec()),
-                                            ByteString::new(contents.as_bytes().to_vec())));
+                                            ByteString::new(contents.as_bytes().to_vec()))?;
                 }
             }
         }
@@ -446,7 +446,7 @@ impl Request {
         *r_clone.request.borrow_mut() = req.clone();
         r_clone.body_used.set(body_used);
         *r_clone.mime_type.borrow_mut() = mime_type;
-        try!(r_clone.Headers().fill(Some(HeadersInit::Headers(r.Headers()))));
+        r_clone.Headers().fill(Some(HeadersInit::Headers(r.Headers())))?;
         r_clone.Headers().set_guard(headers_guard);
         Ok(r_clone)
     }

components/script/dom/response.rs

@@ -101,7 +101,7 @@ impl Response {
             r.Headers().empty_header_list();
 
             // Step 6.2
-            try!(r.Headers().fill(Some(headers_member.clone())));
+            r.Headers().fill(Some(headers_member.clone()))?;
         }
 
         // Step 7
@@ -119,8 +119,8 @@ impl Response {
             // Step 7.4
             if let Some(content_type_contents) = content_type {
                 if !r.Headers().Has(ByteString::new(b"Content-Type".to_vec())).unwrap() {
-                    try!(r.Headers().Append(ByteString::new(b"Content-Type".to_vec()),
+                    r.Headers().Append(ByteString::new(b"Content-Type".to_vec()),
-                                            ByteString::new(content_type_contents.as_bytes().to_vec())));
+                                            ByteString::new(content_type_contents.as_bytes().to_vec()))?;
                 }
             };
         }
@@ -174,7 +174,7 @@ impl Response {
 
         // Step 6
         let url_bytestring = ByteString::from_str(url.as_str()).unwrap_or(ByteString::new(b"".to_vec()));
-        try!(r.Headers().Set(ByteString::new(b"Location".to_vec()), url_bytestring));
+        r.Headers().Set(ByteString::new(b"Location".to_vec()), url_bytestring)?;
 
         // Step 4 continued
         // Headers Guard is set to Immutable here to prevent error in Step 6
@@ -305,7 +305,7 @@ impl ResponseMethods for Response {
         // Step 2
         let new_response = Response::new(&self.global());
         new_response.Headers().set_guard(self.Headers().get_guard());
-        try!(new_response.Headers().fill(Some(HeadersInit::Headers(self.Headers()))));
+        new_response.Headers().fill(Some(HeadersInit::Headers(self.Headers())))?;
 
         // https://fetch.spec.whatwg.org/#concept-response-clone
         // Instead of storing a net_traits::Response internally, we

components/script/dom/serviceworker.rs

@@ -89,7 +89,7 @@ impl ServiceWorkerMethods for ServiceWorker {
             return Err(Error::InvalidState);
         }
         // Step 7
-        let data = try!(StructuredCloneData::write(cx, message));
+        let data = StructuredCloneData::write(cx, message)?;
         let msg_vec = DOMMessage(data.move_to_arraybuffer());
         let _ =
             self.global()

components/script/dom/serviceworkerglobalscope.rs

@@ -303,11 +303,11 @@ impl ServiceWorkerGlobalScope {
 
         let ret = sel.wait();
         if ret == worker_handle.id() {
-            Ok(MixedMessage::FromServiceWorker(try!(worker_port.recv())))
+            Ok(MixedMessage::FromServiceWorker(worker_port.recv()?))
         }else if ret == devtools_handle.id() {
-            Ok(MixedMessage::FromDevtools(try!(devtools_port.recv())))
+            Ok(MixedMessage::FromDevtools(devtools_port.recv()?))
         } else if ret == timer_port_handle.id() {
-            Ok(MixedMessage::FromTimeoutThread(try!(timer_event_port.recv())))
+            Ok(MixedMessage::FromTimeoutThread(timer_event_port.recv()?))
         } else {
             panic!("unexpected select result!")
         }

components/script/dom/servoparser/html.rs

@@ -135,7 +135,7 @@ impl<'a> Serialize for &'a Node {
                         let ar: AttrRef = (&qname, &**value);
                         ar
                     });
-                    try!(serializer.start_elem(name.clone(), attr_refs));
+                    serializer.start_elem(name.clone(), attr_refs)?;
                 }
 
                 let children = if let Some(tpl) = node.downcast::<HTMLTemplateElement>() {
@@ -146,18 +146,18 @@ impl<'a> Serialize for &'a Node {
                 };
 
                 for handle in children {
-                    try!((&*handle).serialize(serializer, IncludeNode));
+                    (&*handle).serialize(serializer, IncludeNode)?;
                 }
 
                 if traversal_scope == IncludeNode {
-                    try!(serializer.end_elem(name.clone()));
+                    serializer.end_elem(name.clone())?;
                 }
                 Ok(())
             },
 
             (ChildrenOnly, NodeTypeId::Document(_)) => {
                 for handle in node.children() {
-                    try!((&*handle).serialize(serializer, IncludeNode));
+                    (&*handle).serialize(serializer, IncludeNode)?;
                 }
                 Ok(())
             },

components/script/dom/treewalker.rs

@@ -104,7 +104,7 @@ impl TreeWalkerMethods for TreeWalker {
                     node = n;
                     // "2. If node is not null and filtering node returns FILTER_ACCEPT,
                     //     then set the currentNode attribute to node, return node."
-                    if NodeFilterConstants::FILTER_ACCEPT == try!(self.accept_node(&node)) {
+                    if NodeFilterConstants::FILTER_ACCEPT == self.accept_node(&node)? {
                         self.current_node.set(&node);
                         return Ok(Some(node))
                     }
@@ -163,7 +163,7 @@ impl TreeWalkerMethods for TreeWalker {
                 // "4. If result is FILTER_ACCEPT, then
                 //     set the currentNode attribute to node and return node."
                 loop {
-                    let result = try!(self.accept_node(&node));
+                    let result = self.accept_node(&node)?;
                     match result {
                         NodeFilterConstants::FILTER_REJECT => break,
                         _ if node.GetFirstChild().is_some() =>
@@ -192,7 +192,7 @@ impl TreeWalkerMethods for TreeWalker {
             }
             // "5. Filter node and if the return value is FILTER_ACCEPT, then
             //     set the currentNode attribute to node and return node."
-            if NodeFilterConstants::FILTER_ACCEPT == try!(self.accept_node(&node)) {
+            if NodeFilterConstants::FILTER_ACCEPT == self.accept_node(&node)? {
                 self.current_node.set(&node);
                 return Ok(Some(node))
             }
@@ -220,7 +220,7 @@ impl TreeWalkerMethods for TreeWalker {
                         // "1. Set node to its first child."
                         node = child;
                         // "2. Filter node and set result to the return value."
-                        result = try!(self.accept_node(&node));
+                        result = self.accept_node(&node)?;
                         // "3. If result is FILTER_ACCEPT, then
                         //     set the currentNode attribute to node and return node."
                         if NodeFilterConstants::FILTER_ACCEPT == result {
@@ -238,7 +238,7 @@ impl TreeWalkerMethods for TreeWalker {
                 Some(n) => {
                     node = n;
                     // "3. Filter node and set result to the return value."
-                    result = try!(self.accept_node(&node));
+                    result = self.accept_node(&node)?;
                     // "4. If result is FILTER_ACCEPT, then
                     //     set the currentNode attribute to node and return node."
                     if NodeFilterConstants::FILTER_ACCEPT == result {
@@ -275,7 +275,7 @@ impl TreeWalker {
         // 4. Main: Repeat these substeps:
         'main: loop {
             // "1. Filter node and let result be the return value."
-            let result = try!(self.accept_node(&node));
+            let result = self.accept_node(&node)?;
             match result {
                 // "2. If result is FILTER_ACCEPT, then set the currentNode
                 //     attribute to node and return node."
@@ -350,7 +350,7 @@ impl TreeWalker {
                 // "1. Set node to sibling."
                 node = sibling_op.unwrap();
                 // "2. Filter node and let result be the return value."
-                let result = try!(self.accept_node(&node));
+                let result = self.accept_node(&node)?;
                 // "3. If result is FILTER_ACCEPT, then set the currentNode
                 //     attribute to node and return node."
                 if NodeFilterConstants::FILTER_ACCEPT == result {
@@ -378,7 +378,7 @@ impl TreeWalker {
                 // "5. Filter node and if the return value is FILTER_ACCEPT, then return null."
                 Some(n) => {
                     node = n;
-                    if NodeFilterConstants::FILTER_ACCEPT == try!(self.accept_node(&node)) {
+                    if NodeFilterConstants::FILTER_ACCEPT == self.accept_node(&node)? {
                         return Ok(None)
                     }
                 }

components/script/dom/vrdisplay.rs

@@ -636,8 +636,8 @@ fn validate_layer(cx: *mut JSContext,
     let ctx = layer.source.as_ref().map(|ref s| s.get_or_init_webgl_context(cx, None)).unwrap_or(None);
     if let Some(ctx) = ctx {
         let mut data = WebVRLayer::default();
-        try!(parse_bounds(&layer.leftBounds, &mut data.left_bounds));
+        parse_bounds(&layer.leftBounds, &mut data.left_bounds)?;
-        try!(parse_bounds(&layer.rightBounds, &mut data.right_bounds));
+        parse_bounds(&layer.rightBounds, &mut data.right_bounds)?;
         Ok((data, ctx))
     } else {
         Err("VRLayer source must be a WebGL Context")

components/script/dom/webgl_validations/tex_image_2d.rs

@@ -285,7 +285,7 @@ impl<'a> WebGLValidator for TexImage2DValidator<'a> {
             width,
             height,
             border,
-        } = try!(self.common_validator.validate());
+        } = self.common_validator.validate()?;
 
         // GL_INVALID_VALUE is generated if target is one of the six cube map 2D
         // image targets and the width and height parameters are not equal.

components/script/dom/webglrenderingcontext.rs

@@ -1496,7 +1496,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         typedarray!(in(cx) let array_buffer: ArrayBuffer = data);
         let data_vec = match array_buffer {
             Ok(mut data) => data.as_slice().to_vec(),
-            Err(_) => try!(fallible_array_buffer_view_to_vec(cx, data)),
+            Err(_) => fallible_array_buffer_view_to_vec(cx, data)?,
         };
 
         let bound_buffer = match target {
@@ -1564,7 +1564,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         typedarray!(in(cx) let array_buffer: ArrayBuffer = data);
         let data_vec = match array_buffer {
             Ok(mut data) => data.as_slice().to_vec(),
-            Err(_) => try!(fallible_array_buffer_view_to_vec(cx, data)),
+            Err(_) => fallible_array_buffer_view_to_vec(cx, data)?,
         };
 
         let bound_buffer = match target {
@@ -1596,7 +1596,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
     unsafe fn CompressedTexImage2D(&self, cx: *mut JSContext, _target: u32, _level: i32, _internal_format: u32,
                             _width: i32, _height: i32, _border: i32, pixels: *mut JSObject) -> Fallible<()> {
-        let _data = try!(fallible_array_buffer_view_to_vec(cx, pixels) );
+        let _data = fallible_array_buffer_view_to_vec(cx, pixels)?;
         // FIXME: No compressed texture format is currently supported, so error out as per
         // https://www.khronos.org/registry/webgl/specs/latest/1.0/#COMPRESSED_TEXTURE_SUPPORT
         self.webgl_error(InvalidEnum);
@@ -1608,7 +1608,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     unsafe fn CompressedTexSubImage2D(&self, cx: *mut JSContext, _target: u32, _level: i32,
                                _xoffset: i32, _yoffset: i32, _width: i32, _height: i32,
                                _format: u32, pixels: *mut JSObject) -> Fallible<()> {
-        let _data = try!(fallible_array_buffer_view_to_vec(cx, pixels));
+        let _data = fallible_array_buffer_view_to_vec(cx, pixels)?;
         // FIXME: No compressed texture format is currently supported, so error out as per
         // https://www.khronos.org/registry/webgl/specs/latest/1.0/#COMPRESSED_TEXTURE_SUPPORT
         self.webgl_error(InvalidEnum);
@@ -2682,7 +2682,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                   uniform: Option<&WebGLUniformLocation>,
                   data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Int32>(cx, data, ConversionBehavior::Default));
+        let data_vec = typed_array_or_sequence_to_vec::<Int32>(cx, data, ConversionBehavior::Default)?;
 
         if self.validate_uniform_parameters(uniform, UniformSetterType::Int, &data_vec) {
             self.ipc_renderer
@@ -2700,7 +2700,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                   uniform: Option<&WebGLUniformLocation>,
                   data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
 
         if self.validate_uniform_parameters(uniform, UniformSetterType::Float, &data_vec) {
             self.ipc_renderer
@@ -2729,7 +2729,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                   uniform: Option<&WebGLUniformLocation>,
                   data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
 
         if self.validate_uniform_parameters(uniform,
                                             UniformSetterType::FloatVec2,
@@ -2762,7 +2762,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                   uniform: Option<&WebGLUniformLocation>,
                   data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Int32>(cx, data, ConversionBehavior::Default));
+        let data_vec = typed_array_or_sequence_to_vec::<Int32>(cx, data, ConversionBehavior::Default)?;
 
         if self.validate_uniform_parameters(uniform,
                                             UniformSetterType::IntVec2,
@@ -2795,7 +2795,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                   uniform: Option<&WebGLUniformLocation>,
                   data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
 
         if self.validate_uniform_parameters(uniform,
                                             UniformSetterType::FloatVec3,
@@ -2828,7 +2828,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                   uniform: Option<&WebGLUniformLocation>,
                   data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Int32>(cx, data, ConversionBehavior::Default));
+        let data_vec = typed_array_or_sequence_to_vec::<Int32>(cx, data, ConversionBehavior::Default)?;
 
         if self.validate_uniform_parameters(uniform,
                                             UniformSetterType::IntVec3,
@@ -2862,7 +2862,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                   uniform: Option<&WebGLUniformLocation>,
                   data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Int32>(cx, data, ConversionBehavior::Default));
+        let data_vec = typed_array_or_sequence_to_vec::<Int32>(cx, data, ConversionBehavior::Default)?;
 
         if self.validate_uniform_parameters(uniform,
                                             UniformSetterType::IntVec4,
@@ -2895,7 +2895,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                   uniform: Option<&WebGLUniformLocation>,
                   data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
 
         if self.validate_uniform_parameters(uniform,
                                             UniformSetterType::FloatVec4,
@@ -2916,7 +2916,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                         transpose: bool,
                         data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
         if self.validate_uniform_parameters(uniform,
                                             UniformSetterType::FloatMat2,
                                             &data_vec) {
@@ -2936,7 +2936,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                         transpose: bool,
                         data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
         if self.validate_uniform_parameters(uniform,
                                             UniformSetterType::FloatMat3,
                                             &data_vec) {
@@ -2956,7 +2956,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                         transpose: bool,
                         data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
         if self.validate_uniform_parameters(uniform,
                                             UniformSetterType::FloatMat4,
                                             &data_vec) {
@@ -2996,7 +2996,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     #[allow(unsafe_code)]
     unsafe fn VertexAttrib1fv(&self, cx: *mut JSContext, indx: u32, data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
         if data_vec.len() < 1 {
             return Ok(self.webgl_error(InvalidOperation));
         }
@@ -3013,7 +3013,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     #[allow(unsafe_code)]
     unsafe fn VertexAttrib2fv(&self, cx: *mut JSContext, indx: u32, data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
         if data_vec.len() < 2 {
             return Ok(self.webgl_error(InvalidOperation));
         }
@@ -3030,7 +3030,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     #[allow(unsafe_code)]
     unsafe fn VertexAttrib3fv(&self, cx: *mut JSContext, indx: u32, data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
         if data_vec.len() < 3 {
             return Ok(self.webgl_error(InvalidOperation));
         }
@@ -3047,7 +3047,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     #[allow(unsafe_code)]
     unsafe fn VertexAttrib4fv(&self, cx: *mut JSContext, indx: u32, data: *mut JSObject) -> Fallible<()> {
         assert!(!data.is_null());
-        let data_vec = try!(typed_array_or_sequence_to_vec::<Float32>(cx, data, ()));
+        let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?;
         if data_vec.len() < 4 {
             return Ok(self.webgl_error(InvalidOperation));
         }
@@ -3134,7 +3134,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         let data = if data_ptr.is_null() {
             None
         } else {
-            Some(try!(fallible_array_buffer_view_to_vec(cx, data_ptr)))
+            Some(fallible_array_buffer_view_to_vec(cx, data_ptr)?)
         };
 
         let validator = TexImage2DValidator::new(self, target, level,
@@ -3261,7 +3261,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         let data = if data_ptr.is_null() {
             None
         } else {
-            Some(try!(fallible_array_buffer_view_to_vec(cx, data_ptr)))
+            Some(fallible_array_buffer_view_to_vec(cx, data_ptr)?)
         };
 
         let validator = TexImage2DValidator::new(self, target, level,

components/script/dom/websocket.rs

@@ -316,7 +316,7 @@ impl WebSocketMethods for WebSocket {
     // https://html.spec.whatwg.org/multipage/#dom-websocket-send
     fn Send(&self, data: USVString) -> ErrorResult {
         let data_byte_len = data.0.as_bytes().len() as u64;
-        let send_data = try!(self.send_impl(data_byte_len));
+        let send_data = self.send_impl(data_byte_len)?;
 
         if send_data {
             let mut other_sender = self.sender.borrow_mut();
@@ -334,7 +334,7 @@ impl WebSocketMethods for WebSocket {
            If the buffer limit is reached in the first place, there are likely other major problems
         */
         let data_byte_len = blob.Size();
-        let send_data = try!(self.send_impl(data_byte_len));
+        let send_data = self.send_impl(data_byte_len)?;
 
         if send_data {
             let mut other_sender = self.sender.borrow_mut();

components/script/dom/window.rs

@@ -765,7 +765,7 @@ impl WindowMethods for Window {
 
         // Step 1-2, 6-8.
         // TODO(#12717): Should implement the `transfer` argument.
-        let data = try!(StructuredCloneData::write(cx, message));
+        let data = StructuredCloneData::write(cx, message)?;
 
         // Step 9.
         self.post_message(origin, data);
@@ -993,9 +993,9 @@ impl WindowMethods for Window {
 
     // check-tidy: no specs after this line
     fn OpenURLInDefaultBrowser(&self, href: DOMString) -> ErrorResult {
-        let url = try!(ServoUrl::parse(&href).map_err(|e| {
+        let url = ServoUrl::parse(&href).map_err(|e| {
             Error::Type(format!("Couldn't parse URL: {}", e))
-        }));
+        })?;
         match open::that(url.as_str()) {
             Ok(_) => Ok(()),
             Err(e) => Err(Error::Type(format!("Couldn't open URL: {}", e))),

components/script/dom/worker.rs

@@ -167,7 +167,7 @@ impl WorkerMethods for Worker {
     #[allow(unsafe_code)]
     // https://html.spec.whatwg.org/multipage/#dom-worker-postmessage
     unsafe fn PostMessage(&self, cx: *mut JSContext, message: HandleValue) -> ErrorResult {
-        let data = try!(StructuredCloneData::write(cx, message));
+        let data = StructuredCloneData::write(cx, message)?;
         let address = Trusted::new(self);
 
         // NOTE: step 9 of https://html.spec.whatwg.org/multipage/#dom-messageport-postmessage

components/script/dom/xmlhttprequest.rs

@@ -501,7 +501,7 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
         // Step 4 (first half)
         let extracted_or_serialized = match data {
             Some(DocumentOrBodyInit::Document(ref doc)) => {
-                let data = Vec::from(try!(serialize_document(&doc)).as_ref());
+                let data = Vec::from(serialize_document(&doc)?.as_ref());
                 let content_type = if doc.is_html_document() {
                     "text/html;charset=UTF-8"
                 } else {
@@ -719,7 +719,7 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
             _ => {},
         }
         // Step 2
-        let override_mime = try!(mime.parse::<Mime>().map_err(|_| Error::Syntax));
+        let override_mime = mime.parse::<Mime>().map_err(|_| Error::Syntax)?;
         // Step 3
         let mime_no_params = Mime(override_mime.clone().0, override_mime.clone().1, vec![]);
         *self.override_mime_type.borrow_mut() = Some(mime_no_params);

components/script/layout_wrapper.rs

@@ -371,9 +371,9 @@ pub struct ServoLayoutElement<'le> {
 
 impl<'le> fmt::Debug for ServoLayoutElement<'le> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "<{}", self.element.local_name()));
+        write!(f, "<{}", self.element.local_name())?;
         if let &Some(ref id) = unsafe { &*self.element.id_attribute() } {
-            try!(write!(f, " id={}", id));
+            write!(f, " id={}", id)?;
         }
         write!(f, "> ({:#x})", self.as_node().opaque().0)
     }

components/script_traits/lib.rs

@@ -96,7 +96,7 @@ impl Serialize for UntrustedNodeAddress {
 
 impl<'de> Deserialize<'de> for UntrustedNodeAddress {
     fn deserialize<D: Deserializer<'de>>(d: D) -> Result<UntrustedNodeAddress, D::Error> {
-        let value: usize = try!(Deserialize::deserialize(d));
+        let value: usize = Deserialize::deserialize(d)?;
         Ok(UntrustedNodeAddress::from_id(value))
     }
 }

components/selectors/parser.rs

@@ -1819,7 +1819,7 @@ pub mod tests {
                                                     -> Result<PseudoClass,
                                                               ParseError<'i, SelectorParseError<'i, ()>>> {
             match_ignore_ascii_case! { &name,
-                "lang" => Ok(PseudoClass::Lang(try!(parser.expect_ident_or_string()).into_owned())),
+                "lang" => Ok(PseudoClass::Lang(parser.expect_ident_or_string()?.into_owned())),
                 _ => Err(SelectorParseError::Custom(()).into())
             }
         }

components/style/attr.rs

@@ -512,8 +512,8 @@ pub fn parse_legacy_color(mut input: &str) -> Result<RGBA, ()> {
             0 => Err(()),
             1 => hex(string[0] as char),
             _ => {
-                let upper = try!(hex(string[0] as char));
+                let upper = hex(string[0] as char)?;
-                let lower = try!(hex(string[1] as char));
+                let lower = hex(string[1] as char)?;
                 Ok((upper << 4) | lower)
             }
         }

components/style/context.rs

@@ -220,22 +220,22 @@ impl<'a> Add for &'a TraversalStatistics {
 impl fmt::Display for TraversalStatistics {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         debug_assert!(self.traversal_time_ms != 0.0, "should have set traversal time");
-        try!(writeln!(f, "[PERF] perf block start"));
+        writeln!(f, "[PERF] perf block start")?;
-        try!(writeln!(f, "[PERF],traversal,{}", if self.is_parallel.unwrap() {
+        writeln!(f, "[PERF],traversal,{}", if self.is_parallel.unwrap() {
             "parallel"
         } else {
             "sequential"
-        }));
+        })?;
-        try!(writeln!(f, "[PERF],elements_traversed,{}", self.elements_traversed));
+        writeln!(f, "[PERF],elements_traversed,{}", self.elements_traversed)?;
-        try!(writeln!(f, "[PERF],elements_styled,{}", self.elements_styled));
+        writeln!(f, "[PERF],elements_styled,{}", self.elements_styled)?;
-        try!(writeln!(f, "[PERF],elements_matched,{}", self.elements_matched));
+        writeln!(f, "[PERF],elements_matched,{}", self.elements_matched)?;
-        try!(writeln!(f, "[PERF],styles_shared,{}", self.styles_shared));
+        writeln!(f, "[PERF],styles_shared,{}", self.styles_shared)?;
-        try!(writeln!(f, "[PERF],selectors,{}", self.selectors));
+        writeln!(f, "[PERF],selectors,{}", self.selectors)?;
-        try!(writeln!(f, "[PERF],revalidation_selectors,{}", self.revalidation_selectors));
+        writeln!(f, "[PERF],revalidation_selectors,{}", self.revalidation_selectors)?;
-        try!(writeln!(f, "[PERF],dependency_selectors,{}", self.dependency_selectors));
+        writeln!(f, "[PERF],dependency_selectors,{}", self.dependency_selectors)?;
-        try!(writeln!(f, "[PERF],declarations,{}", self.declarations));
+        writeln!(f, "[PERF],declarations,{}", self.declarations)?;
-        try!(writeln!(f, "[PERF],stylist_rebuilds,{}", self.stylist_rebuilds));
+        writeln!(f, "[PERF],stylist_rebuilds,{}", self.stylist_rebuilds)?;
-        try!(writeln!(f, "[PERF],traversal_time_ms,{}", self.traversal_time_ms));
+        writeln!(f, "[PERF],traversal_time_ms,{}", self.traversal_time_ms)?;
         writeln!(f, "[PERF] perf block end")
     }
 }

components/style/custom_properties.rs

@@ -135,7 +135,7 @@ impl SpecifiedValue {
     pub fn parse<'i, 't>(_context: &ParserContext, input: &mut Parser<'i, 't>)
                          -> Result<Box<Self>, ParseError<'i>> {
         let mut references = Some(HashSet::new());
-        let (first, css, last) = try!(parse_self_contained_declaration_value(input, &mut references));
+        let (first, css, last) = parse_self_contained_declaration_value(input, &mut references)?;
         Ok(Box::new(SpecifiedValue {
             css: css.into_owned(),
             first_token_type: first,
@@ -149,7 +149,7 @@ impl SpecifiedValue {
 pub fn parse_non_custom_with_var<'i, 't>
                                 (input: &mut Parser<'i, 't>)
                                 -> Result<(TokenSerializationType, Cow<'i, str>), ParseError<'i>> {
-    let (first_token_type, css, _) = try!(parse_self_contained_declaration_value(input, &mut None));
+    let (first_token_type, css, _) = parse_self_contained_declaration_value(input, &mut None)?;
     Ok((first_token_type, css))
 }
 
@@ -163,8 +163,7 @@ fn parse_self_contained_declaration_value<'i, 't>
                                           ), ParseError<'i>> {
     let start_position = input.position();
     let mut missing_closing_characters = String::new();
-    let (first, last) = try!(
+    let (first, last) = parse_declaration_value(input, references, &mut missing_closing_characters)?;
-        parse_declaration_value(input, references, &mut missing_closing_characters));
     let mut css: Cow<str> = input.slice_from(start_position).into();
     if !missing_closing_characters.is_empty() {
         // Unescaped backslash at EOF in a quoted string is ignored.
@@ -185,7 +184,7 @@ fn parse_declaration_value<'i, 't>
     input.parse_until_before(Delimiter::Bang | Delimiter::Semicolon, |input| {
         // Need at least one token
         let start_position = input.position();
-        try!(input.next_including_whitespace());
+        input.next_including_whitespace()?;
         input.reset(start_position);
 
         parse_declaration_value_block(input, references, missing_closing_characters)
@@ -209,9 +208,9 @@ fn parse_declaration_value_block<'i, 't>
     loop {
         macro_rules! nested {
             () => {
-                try!(input.parse_nested_block(|input| {
+                input.parse_nested_block(|input| {
                     parse_declaration_value_block(input, references, missing_closing_characters)
-                }))
+                })?
             }
         }
         macro_rules! check_closed {
@@ -243,9 +242,9 @@ fn parse_declaration_value_block<'i, 't>
             Token::Function(ref name) => {
                 if name.eq_ignore_ascii_case("var") {
                     let position = input.position();
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
                         parse_var_function(input, references)
-                    }));
+                    })?;
                     input.reset(position);
                 }
                 nested!();
@@ -311,21 +310,21 @@ fn parse_declaration_value_block<'i, 't>
 fn parse_var_function<'i, 't>(input: &mut Parser<'i, 't>,
                               references: &mut Option<HashSet<Name>>)
                               -> Result<(), ParseError<'i>> {
-    let name = try!(input.expect_ident());
+    let name = input.expect_ident()?;
     let name: Result<_, ParseError> =
         parse_name(&name)
         .map_err(|()| SelectorParseError::UnexpectedIdent(name.clone()).into());
-    let name = try!(name);
+    let name = name?;
     if input.try(|input| input.expect_comma()).is_ok() {
         // Exclude `!` and `;` at the top level
         // https://drafts.csswg.org/css-syntax/#typedef-declaration-value
-        try!(input.parse_until_before(Delimiter::Bang | Delimiter::Semicolon, |input| {
+        input.parse_until_before(Delimiter::Bang | Delimiter::Semicolon, |input| {
             // At least one non-comment token.
-            try!(input.next_including_whitespace());
+            input.next_including_whitespace()?;
             // Skip until the end.
             while let Ok(_) = input.next_including_whitespace_and_comments() {}
             Ok(())
-        }));
+        })?;
     }
     if let Some(ref mut refs) = *references {
         refs.insert(Atom::from(name));
@@ -562,7 +561,7 @@ fn substitute_block<'i, 't, F>(input: &mut Parser<'i, 't>,
             Token::Function(ref name) if name.eq_ignore_ascii_case("var") => {
                 partial_computed_value.push(
                     input.slice(position.0..before_this_token), position.1, last_token_type);
-                try!(input.parse_nested_block(|input| {
+                input.parse_nested_block(|input| {
                     // parse_var_function() ensures neither .unwrap() will fail.
                     let name = input.expect_ident().unwrap();
                     let name = Atom::from(parse_name(&name).unwrap());
@@ -574,7 +573,7 @@ fn substitute_block<'i, 't, F>(input: &mut Parser<'i, 't>,
                         // FIXME: Add a specialized method to cssparser to do this with less work.
                         while let Ok(_) = input.next() {}
                     } else {
-                        try!(input.expect_comma());
+                        input.expect_comma()?;
                         let position = input.position();
                         let first_token_type = input.next_including_whitespace_and_comments()
                             // parse_var_function() ensures that .unwrap() will not fail.
@@ -582,12 +581,12 @@ fn substitute_block<'i, 't, F>(input: &mut Parser<'i, 't>,
                             .serialization_type();
                         input.reset(position);
                         let mut position = (position, first_token_type);
-                        last_token_type = try!(substitute_block(
+                        last_token_type = substitute_block(
-                            input, &mut position, partial_computed_value, substitute_one));
+                            input, &mut position, partial_computed_value, substitute_one)?;
                         partial_computed_value.push_from(position, input, last_token_type);
                     }
                     Ok(())
-                }));
+                })?;
                 set_position_at_next_iteration = true
             }
 
@@ -595,9 +594,9 @@ fn substitute_block<'i, 't, F>(input: &mut Parser<'i, 't>,
             Token::ParenthesisBlock |
             Token::CurlyBracketBlock |
             Token::SquareBracketBlock => {
-                try!(input.parse_nested_block(|input| {
+                input.parse_nested_block(|input| {
                     substitute_block(input, position, partial_computed_value, substitute_one)
-                }));
+                })?;
                 // It’s the same type for CloseCurlyBracket and CloseSquareBracket.
                 last_token_type = Token::CloseParenthesis.serialization_type();
             }
@@ -623,7 +622,7 @@ pub fn substitute<'i>(input: &'i str, first_token_type: TokenSerializationType,
     let mut input = ParserInput::new(input);
     let mut input = Parser::new(&mut input);
     let mut position = (input.position(), first_token_type);
-    let last_token_type = try!(substitute_block(
+    let last_token_type = substitute_block(
         &mut input, &mut position, &mut substituted, &mut |name, substituted| {
             if let Some(value) = computed_values_map.as_ref().and_then(|map| map.get(name)) {
                 substituted.push_variable(value);
@@ -632,7 +631,7 @@ pub fn substitute<'i>(input: &'i str, first_token_type: TokenSerializationType,
                 Err(())
             }
         }
-    ));
+    )?;
     substituted.push_from(position, &input, last_token_type);
     Ok(substituted.css)
 }

components/style/dom.rs

@@ -180,7 +180,7 @@ impl<N: TNode> Debug for ShowDataAndPrimaryValues<N> {
 pub struct ShowSubtree<N: TNode>(pub N);
 impl<N: TNode> Debug for ShowSubtree<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(writeln!(f, "DOM Subtree:"));
+        writeln!(f, "DOM Subtree:")?;
         fmt_subtree(f, &|f, n| write!(f, "{:?}", n), self.0, 1)
     }
 }
@@ -190,7 +190,7 @@ impl<N: TNode> Debug for ShowSubtree<N> {
 pub struct ShowSubtreeData<N: TNode>(pub N);
 impl<N: TNode> Debug for ShowSubtreeData<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(writeln!(f, "DOM Subtree:"));
+        writeln!(f, "DOM Subtree:")?;
         fmt_subtree(f, &|f, n| fmt_with_data(f, n), self.0, 1)
     }
 }
@@ -200,7 +200,7 @@ impl<N: TNode> Debug for ShowSubtreeData<N> {
 pub struct ShowSubtreeDataAndPrimaryValues<N: TNode>(pub N);
 impl<N: TNode> Debug for ShowSubtreeDataAndPrimaryValues<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(writeln!(f, "DOM Subtree:"));
+        writeln!(f, "DOM Subtree:")?;
         fmt_subtree(f, &|f, n| fmt_with_data_and_primary_values(f, n), self.0, 1)
     }
 }
@@ -230,12 +230,12 @@ fn fmt_subtree<F, N: TNode>(f: &mut fmt::Formatter, stringify: &F, n: N, indent:
     where F: Fn(&mut fmt::Formatter, N) -> fmt::Result
 {
     for _ in 0..indent {
-        try!(write!(f, "  "));
+        write!(f, "  ")?;
     }
-    try!(stringify(f, n));
+    stringify(f, n)?;
     for kid in n.traversal_children() {
-        try!(writeln!(f, ""));
+        writeln!(f, "")?;
-        try!(fmt_subtree(f, stringify, kid, indent + 1));
+        fmt_subtree(f, stringify, kid, indent + 1)?;
     }
 
     Ok(())

components/style/gecko/media_queries.rs

@@ -230,7 +230,7 @@ impl Resolution {
     }
 
     fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
-        let (value, unit) = match try!(input.next()) {
+        let (value, unit) = match input.next()? {
             Token::Dimension { value, unit, .. } => {
                 (value, unit)
             },
@@ -462,9 +462,9 @@ impl Expression {
     /// ```
     pub fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                          -> Result<Self, ParseError<'i>> {
-        try!(input.expect_parenthesis_block());
+        input.expect_parenthesis_block()?;
         input.parse_nested_block(|input| {
-            let ident = try!(input.expect_ident());
+            let ident = input.expect_ident()?;
 
             let mut flags = 0;
             let result = {

components/style/gecko/wrapper.rs

@@ -407,9 +407,9 @@ pub struct GeckoElement<'le>(pub &'le RawGeckoElement);
 
 impl<'le> fmt::Debug for GeckoElement<'le> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "<{}", self.get_local_name()));
+        write!(f, "<{}", self.get_local_name())?;
         if let Some(id) = self.get_id() {
-            try!(write!(f, " id={}", id));
+            write!(f, " id={}", id)?;
         }
 
         let mut first = true;

components/style/gecko_string_cache/mod.rs

@@ -235,7 +235,7 @@ impl fmt::Debug for WeakAtom {
 impl fmt::Display for WeakAtom {
     fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
         for c in self.chars() {
-            try!(w.write_char(c.unwrap_or(char::REPLACEMENT_CHARACTER)))
+            w.write_char(c.unwrap_or(char::REPLACEMENT_CHARACTER))?
         }
         Ok(())
     }

components/style/lib.rs

@@ -207,11 +207,11 @@ pub fn serialize_comma_separated_list<W, T>(dest: &mut W,
         return Ok(());
     }
 
-    try!(list[0].to_css(dest));
+    list[0].to_css(dest)?;
 
     for item in list.iter().skip(1) {
-        try!(write!(dest, ", "));
+        write!(dest, ", ")?;
-        try!(item.to_css(dest));
+        item.to_css(dest)?;
     }
 
     Ok(())

components/style/logical_geometry.rs

@@ -144,20 +144,20 @@ impl WritingMode {
 impl fmt::Display for WritingMode {
     fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error> {
         if self.is_vertical() {
-            try!(write!(formatter, "V"));
+            write!(formatter, "V")?;
             if self.is_vertical_lr() {
-                try!(write!(formatter, " LR"));
+                write!(formatter, " LR")?;
             } else {
-                try!(write!(formatter, " RL"));
+                write!(formatter, " RL")?;
             }
             if self.intersects(FLAG_SIDEWAYS) {
-                try!(write!(formatter, " Sideways"));
+                write!(formatter, " Sideways")?;
             }
             if self.intersects(FLAG_LINE_INVERTED) {
-                try!(write!(formatter, " Inverted"));
+                write!(formatter, " Inverted")?;
             }
         } else {
-            try!(write!(formatter, "H"));
+            write!(formatter, "H")?;
         }
         if self.is_bidi_ltr() {
             write!(formatter, " LTR")

components/style/media_queries.rs

@@ -94,8 +94,8 @@ impl ToCss for MediaQuery {
         where W: fmt::Write,
     {
         if let Some(qual) = self.qualifier {
-            try!(qual.to_css(dest));
+            qual.to_css(dest)?;
-            try!(write!(dest, " "));
+            write!(dest, " ")?;
         }
 
         match self.media_type {
@@ -106,12 +106,12 @@ impl ToCss for MediaQuery {
                 // Otherwise, we'd serialize media queries like "(min-width:
                 // 40px)" in "all (min-width: 40px)", which is unexpected.
                 if self.qualifier.is_some() || self.expressions.is_empty() {
-                    try!(write!(dest, "all"));
+                    write!(dest, "all")?;
                 }
             },
-            MediaQueryType::Known(MediaType::Screen) => try!(write!(dest, "screen")),
+            MediaQueryType::Known(MediaType::Screen) => write!(dest, "screen")?,
-            MediaQueryType::Known(MediaType::Print) => try!(write!(dest, "print")),
+            MediaQueryType::Known(MediaType::Print) => write!(dest, "print")?,
-            MediaQueryType::Unknown(ref desc) => try!(write!(dest, "{}", desc)),
+            MediaQueryType::Unknown(ref desc) => write!(dest, "{}", desc)?,
         }
 
         if self.expressions.is_empty() {
@@ -119,14 +119,14 @@ impl ToCss for MediaQuery {
         }
 
         if self.media_type != MediaQueryType::All || self.qualifier.is_some() {
-            try!(write!(dest, " and "));
+            write!(dest, " and ")?;
         }
 
-        try!(self.expressions[0].to_css(dest));
+        self.expressions[0].to_css(dest)?;
 
         for expr in self.expressions.iter().skip(1) {
-            try!(write!(dest, " and "));
+            write!(dest, " and ")?;
-            try!(expr.to_css(dest));
+            expr.to_css(dest)?;
         }
         Ok(())
     }
@@ -215,7 +215,7 @@ impl MediaQuery {
             Ok(ident) => {
                 let result: Result<_, ParseError> = MediaQueryType::parse(&*ident)
                     .map_err(|()| SelectorParseError::UnexpectedIdent(ident).into());
-                try!(result)
+                result?
             }
             Err(_) => {
                 // Media type is only optional if qualifier is not specified.
@@ -224,7 +224,7 @@ impl MediaQuery {
                 }
 
                 // Without a media type, require at least one expression.
-                expressions.push(try!(Expression::parse(context, input)));
+                expressions.push(Expression::parse(context, input)?);
 
                 MediaQueryType::All
             }
@@ -235,7 +235,7 @@ impl MediaQuery {
             if input.try(|input| input.expect_ident_matching("and")).is_err() {
                 return Ok(MediaQuery::new(qualifier, media_type, expressions))
             }
-            expressions.push(try!(Expression::parse(context, input)))
+            expressions.push(Expression::parse(context, input)?)
         }
     }
 }

components/style/properties/declaration_block.rs

@@ -840,10 +840,10 @@ pub fn append_serialization<'a, W, I, N>(dest: &mut W,
           I: Iterator<Item=&'a PropertyDeclaration>,
           N: ToCss,
 {
-    try!(handle_first_serialization(dest, is_first_serialization));
+    handle_first_serialization(dest, is_first_serialization)?;
 
-    try!(property_name.to_css(dest));
+    property_name.to_css(dest)?;
-    try!(dest.write_char(':'));
+    dest.write_char(':')?;
 
     // for normal parsed values, add a space between key: and value
     match appendable_value {
@@ -863,10 +863,10 @@ pub fn append_serialization<'a, W, I, N>(dest: &mut W,
         AppendableValue::DeclarationsForShorthand(..) => unreachable!(),
     }
 
-    try!(append_declaration_value(dest, appendable_value));
+    append_declaration_value(dest, appendable_value)?;
 
     if importance.important() {
-        try!(dest.write_str(" !important"));
+        dest.write_str(" !important")?;
     }
 
     dest.write_char(';')
@@ -934,7 +934,7 @@ impl<'a, 'b, 'i> DeclarationParser<'i> for PropertyDeclarationParser<'a, 'b> {
 
     fn parse_value<'t>(&mut self, name: CompactCowStr<'i>, input: &mut Parser<'i, 't>)
                        -> Result<Importance, ParseError<'i>> {
-        let id = try!(PropertyId::parse(name));
+        let id = PropertyId::parse(name)?;
         input.parse_until_before(Delimiter::Bang, |input| {
             PropertyDeclaration::parse_into(self.declarations, id, self.context, input)
                 .map_err(|e| e.into())

components/style/properties/helpers.mako.rs

@@ -158,17 +158,17 @@
                 {
                     let mut iter = self.0.iter();
                     if let Some(val) = iter.next() {
-                        try!(val.to_css(dest));
+                        val.to_css(dest)?;
                     } else {
                         % if allow_empty:
-                            try!(dest.write_str("none"));
+                            dest.write_str("none")?;
                         % else:
                             warn!("Found empty value for property ${name}");
                         % endif
                     }
                     for i in iter {
-                        try!(dest.write_str(", "));
+                        dest.write_str(", ")?;
-                        try!(i.to_css(dest));
+                        i.to_css(dest)?;
                     }
                     Ok(())
                 }
@@ -185,17 +185,17 @@
                 {
                     let mut iter = self.0.iter();
                     if let Some(val) = iter.next() {
-                        try!(val.to_css(dest));
+                        val.to_css(dest)?;
                     } else {
                         % if allow_empty:
-                            try!(dest.write_str("none"));
+                            dest.write_str("none")?;
                         % else:
                             warn!("Found empty value for property ${name}");
                         % endif
                     }
                     for i in iter {
-                        try!(dest.write_str(", "));
+                        dest.write_str(", ")?;
-                        try!(i.to_css(dest));
+                        i.to_css(dest)?;
                     }
                     Ok(())
                 }
@@ -462,8 +462,8 @@
                         let var = input.seen_var_functions();
                         if specified.is_err() && var {
                             input.reset(start);
-                            let (first_token_type, css) = try!(
+                            let (first_token_type, css) =
-                                ::custom_properties::parse_non_custom_with_var(input));
+                                ::custom_properties::parse_non_custom_with_var(input)?;
                             return Ok(PropertyDeclaration::WithVariables(LonghandId::${property.camel_case},
                                                                          Arc::new(UnparsedValue {
                                 css: css.into_owned(),
@@ -876,8 +876,8 @@
                 Ok(())
             } else if var {
                 input.reset(start);
-                let (first_token_type, css) = try!(
+                let (first_token_type, css) =
-                    ::custom_properties::parse_non_custom_with_var(input));
+                    ::custom_properties::parse_non_custom_with_var(input)?;
                 let unparsed = Arc::new(UnparsedValue {
                     css: css.into_owned(),
                     first_token_type: first_token_type,

components/style/properties/helpers/animated_properties.mako.rs

@@ -223,7 +223,7 @@ impl TransitionProperty {
 
     /// Parse a transition-property value.
     pub fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
-        let ident = try!(input.expect_ident());
+        let ident = input.expect_ident()?;
         let supported = match_ignore_ascii_case! { &ident,
             "all" => Ok(Some(TransitionProperty::All)),
             % for prop in data.longhands + data.shorthands_except_all():
@@ -986,8 +986,8 @@ impl Animatable for Visibility {
 impl<T: Animatable + Copy> Animatable for Size2D<T> {
     #[inline]
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
-        let width = try!(self.width.add_weighted(&other.width, self_portion, other_portion));
+        let width = self.width.add_weighted(&other.width, self_portion, other_portion)?;
-        let height = try!(self.height.add_weighted(&other.height, self_portion, other_portion));
+        let height = self.height.add_weighted(&other.height, self_portion, other_portion)?;
 
         Ok(Size2D::new(width, height))
     }
@@ -996,8 +996,8 @@ impl<T: Animatable + Copy> Animatable for Size2D<T> {
 impl<T: Animatable + Copy> Animatable for Point2D<T> {
     #[inline]
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
-        let x = try!(self.x.add_weighted(&other.x, self_portion, other_portion));
+        let x = self.x.add_weighted(&other.x, self_portion, other_portion)?;
-        let y = try!(self.y.add_weighted(&other.y, self_portion, other_portion));
+        let y = self.y.add_weighted(&other.y, self_portion, other_portion)?;
 
         Ok(Point2D::new(x, y))
     }
@@ -1016,8 +1016,8 @@ impl Animatable for BorderCornerRadius {
 
     #[inline]
     fn compute_squared_distance(&self, other: &Self) -> Result<f64, ()> {
-        Ok(try!(self.0.width.compute_squared_distance(&other.0.width)) +
+        Ok(self.0.width.compute_squared_distance(&other.0.width)? +
-           try!(self.0.height.compute_squared_distance(&other.0.height)))
+           self.0.height.compute_squared_distance(&other.0.height)?)
     }
 }
 
@@ -1487,10 +1487,8 @@ impl<H: Animatable, V: Animatable> Animatable for generic_position::Position<H,
     #[inline]
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
         Ok(generic_position::Position {
-            horizontal: try!(self.horizontal.add_weighted(&other.horizontal,
+            horizontal: self.horizontal.add_weighted(&other.horizontal, self_portion, other_portion)?,
-                                                          self_portion, other_portion)),
+            vertical: self.vertical.add_weighted(&other.vertical, self_portion, other_portion)?,
-            vertical: try!(self.vertical.add_weighted(&other.vertical,
-                                                      self_portion, other_portion)),
         })
     }
 
@@ -1509,8 +1507,8 @@ impl<H: Animatable, V: Animatable> Animatable for generic_position::Position<H,
 
     #[inline]
     fn compute_squared_distance(&self, other: &Self) -> Result<f64, ()> {
-        Ok(try!(self.horizontal.compute_squared_distance(&other.horizontal)) +
+        Ok(self.horizontal.compute_squared_distance(&other.horizontal)? +
-           try!(self.vertical.compute_squared_distance(&other.vertical)))
+           self.vertical.compute_squared_distance(&other.vertical)?)
     }
 }
 
@@ -1523,10 +1521,10 @@ impl Animatable for ClipRect {
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64)
         -> Result<Self, ()> {
         Ok(ClipRect {
-            top: try!(self.top.add_weighted(&other.top, self_portion, other_portion)),
+            top: self.top.add_weighted(&other.top, self_portion, other_portion)?,
-            right: try!(self.right.add_weighted(&other.right, self_portion, other_portion)),
+            right: self.right.add_weighted(&other.right, self_portion, other_portion)?,
-            bottom: try!(self.bottom.add_weighted(&other.bottom, self_portion, other_portion)),
+            bottom: self.bottom.add_weighted(&other.bottom, self_portion, other_portion)?,
-            left: try!(self.left.add_weighted(&other.left, self_portion, other_portion)),
+            left: self.left.add_weighted(&other.left, self_portion, other_portion)?,
         })
     }
 
@@ -1537,10 +1535,12 @@ impl Animatable for ClipRect {
 
     #[inline]
     fn compute_squared_distance(&self, other: &Self) -> Result<f64, ()> {
-        let list = [ try!(self.top.compute_distance(&other.top)),
+        let list = [
-                     try!(self.right.compute_distance(&other.right)),
+            self.top.compute_distance(&other.top)?,
-                     try!(self.bottom.compute_distance(&other.bottom)),
+            self.right.compute_distance(&other.right)?,
-                     try!(self.left.compute_distance(&other.left)) ];
+            self.bottom.compute_distance(&other.bottom)?,
+            self.left.compute_distance(&other.left)?
+        ];
         Ok(list.iter().fold(0.0f64, |sum, diff| sum + diff * diff))
     }
 }
@@ -1630,9 +1630,9 @@ fn add_weighted_with_initial_val<T: Animatable>(a: &T,
                                                 a_portion: f64,
                                                 b_portion: f64,
                                                 initial_val: &T) -> Result<T, ()> {
-    let a = try!(a.add_weighted(&initial_val, 1.0, -1.0));
+    let a = a.add_weighted(&initial_val, 1.0, -1.0)?;
-    let b = try!(b.add_weighted(&initial_val, 1.0, -1.0));
+    let b = b.add_weighted(&initial_val, 1.0, -1.0)?;
-    let result = try!(a.add_weighted(&b, a_portion, b_portion));
+    let result = a.add_weighted(&b, a_portion, b_portion)?;
     result.add_weighted(&initial_val, 1.0, 1.0)
 }
 
@@ -1793,12 +1793,12 @@ pub struct MatrixDecomposed2D {
 impl Animatable for InnerMatrix2D {
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
         Ok(InnerMatrix2D {
-            m11: try!(add_weighted_with_initial_val(&self.m11, &other.m11,
+            m11: add_weighted_with_initial_val(&self.m11, &other.m11,
-                                                    self_portion, other_portion, &1.0)),
+                                               self_portion, other_portion, &1.0)?,
-            m12: try!(self.m12.add_weighted(&other.m12, self_portion, other_portion)),
+            m12: self.m12.add_weighted(&other.m12, self_portion, other_portion)?,
-            m21: try!(self.m21.add_weighted(&other.m21, self_portion, other_portion)),
+            m21: self.m21.add_weighted(&other.m21, self_portion, other_portion)?,
-            m22: try!(add_weighted_with_initial_val(&self.m22, &other.m22,
+            m22: add_weighted_with_initial_val(&self.m22, &other.m22,
-                                                    self_portion, other_portion, &1.0)),
+                                               self_portion, other_portion, &1.0)?,
         })
     }
 }
@@ -1806,8 +1806,8 @@ impl Animatable for InnerMatrix2D {
 impl Animatable for Translate2D {
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
         Ok(Translate2D(
-            try!(self.0.add_weighted(&other.0, self_portion, other_portion)),
+            self.0.add_weighted(&other.0, self_portion, other_portion)?,
-            try!(self.1.add_weighted(&other.1, self_portion, other_portion))
+            self.1.add_weighted(&other.1, self_portion, other_portion)?,
         ))
     }
 }
@@ -1815,8 +1815,8 @@ impl Animatable for Translate2D {
 impl Animatable for Scale2D {
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
         Ok(Scale2D(
-            try!(add_weighted_with_initial_val(&self.0, &other.0, self_portion, other_portion, &1.0)),
+            add_weighted_with_initial_val(&self.0, &other.0, self_portion, other_portion, &1.0)?,
-            try!(add_weighted_with_initial_val(&self.1, &other.1, self_portion, other_portion, &1.0))
+            add_weighted_with_initial_val(&self.1, &other.1, self_portion, other_portion, &1.0)?,
         ))
     }
 }
@@ -1853,11 +1853,10 @@ impl Animatable for MatrixDecomposed2D {
         }
 
         // Interpolate all values.
-        let translate = try!(self.translate.add_weighted(&other.translate,
+        let translate = self.translate.add_weighted(&other.translate, self_portion, other_portion)?;
-                                                         self_portion, other_portion));
+        let scale = scale.add_weighted(&other.scale, self_portion, other_portion)?;
-        let scale = try!(scale.add_weighted(&other.scale, self_portion, other_portion));
+        let angle = angle.add_weighted(&other_angle, self_portion, other_portion)?;
-        let angle = try!(angle.add_weighted(&other_angle, self_portion, other_portion));
+        let matrix = self.matrix.add_weighted(&other.matrix, self_portion, other_portion)?;
-        let matrix = try!(self.matrix.add_weighted(&other.matrix, self_portion, other_portion));
 
         Ok(MatrixDecomposed2D {
             translate: translate,
@@ -1875,7 +1874,7 @@ impl Animatable for ComputedMatrix {
             let decomposed_to = decompose_3d_matrix(*other);
             match (decomposed_from, decomposed_to) {
                 (Ok(from), Ok(to)) => {
-                    let sum = try!(from.add_weighted(&to, self_portion, other_portion));
+                    let sum = from.add_weighted(&to, self_portion, other_portion)?;
                     Ok(ComputedMatrix::from(sum))
                 },
                 _ => {
@@ -1886,8 +1885,7 @@ impl Animatable for ComputedMatrix {
         } else {
             let decomposed_from = MatrixDecomposed2D::from(*self);
             let decomposed_to = MatrixDecomposed2D::from(*other);
-            let sum = try!(decomposed_from.add_weighted(&decomposed_to,
+            let sum = decomposed_from.add_weighted(&decomposed_to, self_portion, other_portion)?;
-                                                        self_portion, other_portion));
             Ok(ComputedMatrix::from(sum))
         }
     }
@@ -2228,9 +2226,9 @@ fn cross(row1: [f32; 3], row2: [f32; 3]) -> [f32; 3] {
 impl Animatable for Translate3D {
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
         Ok(Translate3D(
-            try!(self.0.add_weighted(&other.0, self_portion, other_portion)),
+            self.0.add_weighted(&other.0, self_portion, other_portion)?,
-            try!(self.1.add_weighted(&other.1, self_portion, other_portion)),
+            self.1.add_weighted(&other.1, self_portion, other_portion)?,
-            try!(self.2.add_weighted(&other.2, self_portion, other_portion))
+            self.2.add_weighted(&other.2, self_portion, other_portion)?,
         ))
     }
 }
@@ -2238,9 +2236,9 @@ impl Animatable for Translate3D {
 impl Animatable for Scale3D {
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
         Ok(Scale3D(
-            try!(add_weighted_with_initial_val(&self.0, &other.0, self_portion, other_portion, &1.0)),
+            add_weighted_with_initial_val(&self.0, &other.0, self_portion, other_portion, &1.0)?,
-            try!(add_weighted_with_initial_val(&self.1, &other.1, self_portion, other_portion, &1.0)),
+            add_weighted_with_initial_val(&self.1, &other.1, self_portion, other_portion, &1.0)?,
-            try!(add_weighted_with_initial_val(&self.2, &other.2, self_portion, other_portion, &1.0))
+            add_weighted_with_initial_val(&self.2, &other.2, self_portion, other_portion, &1.0)?,
         ))
     }
 }
@@ -2248,9 +2246,9 @@ impl Animatable for Scale3D {
 impl Animatable for Skew {
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
         Ok(Skew(
-            try!(self.0.add_weighted(&other.0, self_portion, other_portion)),
+            self.0.add_weighted(&other.0, self_portion, other_portion)?,
-            try!(self.1.add_weighted(&other.1, self_portion, other_portion)),
+            self.1.add_weighted(&other.1, self_portion, other_portion)?,
-            try!(self.2.add_weighted(&other.2, self_portion, other_portion))
+            self.2.add_weighted(&other.2, self_portion, other_portion)?,
         ))
     }
 }
@@ -2258,10 +2256,10 @@ impl Animatable for Skew {
 impl Animatable for Perspective {
     fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
         Ok(Perspective(
-            try!(self.0.add_weighted(&other.0, self_portion, other_portion)),
+            self.0.add_weighted(&other.0, self_portion, other_portion)?,
-            try!(self.1.add_weighted(&other.1, self_portion, other_portion)),
+            self.1.add_weighted(&other.1, self_portion, other_portion)?,
-            try!(self.2.add_weighted(&other.2, self_portion, other_portion)),
+            self.2.add_weighted(&other.2, self_portion, other_portion)?,
-            try!(add_weighted_with_initial_val(&self.3, &other.3, self_portion, other_portion, &1.0))
+            add_weighted_with_initial_val(&self.3, &other.3, self_portion, other_portion, &1.0)?,
         ))
     }
 }
@@ -2277,12 +2275,10 @@ impl Animatable for MatrixDecomposed3D {
         let mut sum = *self;
 
         // Add translate, scale, skew and perspective components.
-        sum.translate = try!(self.translate.add_weighted(&other.translate,
+        sum.translate = self.translate.add_weighted(&other.translate, self_portion, other_portion)?;
-                                                         self_portion, other_portion));
+        sum.scale = self.scale.add_weighted(&other.scale, self_portion, other_portion)?;
-        sum.scale = try!(self.scale.add_weighted(&other.scale, self_portion, other_portion));
+        sum.skew = self.skew.add_weighted(&other.skew, self_portion, other_portion)?;
-        sum.skew = try!(self.skew.add_weighted(&other.skew, self_portion, other_portion));
+        sum.perspective = self.perspective.add_weighted(&other.perspective, self_portion, other_portion)?;
-        sum.perspective = try!(self.perspective.add_weighted(&other.perspective,
-                                                             self_portion, other_portion));
 
         // Add quaternions using spherical linear interpolation (Slerp).
         //
@@ -2734,25 +2730,22 @@ impl Animatable for IntermediateRGBA {
     #[inline]
     fn add_weighted(&self, other: &IntermediateRGBA, self_portion: f64, other_portion: f64)
         -> Result<Self, ()> {
-        let mut alpha = try!(self.alpha.add_weighted(&other.alpha, self_portion, other_portion));
+        let mut alpha = self.alpha.add_weighted(&other.alpha, self_portion, other_portion)?;
         if alpha <= 0. {
             // Ideally we should return color value that only alpha component is
             // 0, but this is what current gecko does.
             Ok(IntermediateRGBA::transparent())
         } else {
             alpha = alpha.min(1.);
-            let red = try!((self.red * self.alpha)
+            let red = (self.red * self.alpha).add_weighted(
-                            .add_weighted(&(other.red * other.alpha),
+                &(other.red * other.alpha), self_portion, other_portion
-                                          self_portion, other_portion))
+            )? * 1. / alpha;
-                            * 1. / alpha;
+            let green = (self.green * self.alpha).add_weighted(
-            let green = try!((self.green * self.alpha)
+                &(other.green * other.alpha), self_portion, other_portion
-                             .add_weighted(&(other.green * other.alpha),
+            )? * 1. / alpha;
-                                           self_portion, other_portion))
+            let blue = (self.blue * self.alpha).add_weighted(
-                             * 1. / alpha;
+                &(other.blue * other.alpha), self_portion, other_portion
-            let blue = try!((self.blue * self.alpha)
+            )? * 1. / alpha;
-                             .add_weighted(&(other.blue * other.alpha),
-                                           self_portion, other_portion))
-                             * 1. / alpha;
             Ok(IntermediateRGBA::new(red, green, blue, alpha))
         }
     }
@@ -3093,13 +3086,11 @@ impl Animatable for IntermediateShadow {
             return Err(());
         }
 
-        let x = try!(self.offset_x.add_weighted(&other.offset_x, self_portion, other_portion));
+        let x = self.offset_x.add_weighted(&other.offset_x, self_portion, other_portion)?;
-        let y = try!(self.offset_y.add_weighted(&other.offset_y, self_portion, other_portion));
+        let y = self.offset_y.add_weighted(&other.offset_y, self_portion, other_portion)?;
-        let color = try!(self.color.add_weighted(&other.color, self_portion, other_portion));
+        let color = self.color.add_weighted(&other.color, self_portion, other_portion)?;
-        let blur = try!(self.blur_radius.add_weighted(&other.blur_radius,
+        let blur = self.blur_radius.add_weighted(&other.blur_radius, self_portion, other_portion)?;
-                                                      self_portion, other_portion));
+        let spread = self.spread_radius.add_weighted(&other.spread_radius, self_portion, other_portion)?;
-        let spread = try!(self.spread_radius.add_weighted(&other.spread_radius,
-                                                          self_portion, other_portion));
 
         Ok(IntermediateShadow {
             offset_x: x,
@@ -3121,11 +3112,12 @@ impl Animatable for IntermediateShadow {
         if self.inset != other.inset {
             return Err(());
         }
-        let list = [ try!(self.offset_x.compute_distance(&other.offset_x)),
+        let list = [
-                     try!(self.offset_y.compute_distance(&other.offset_y)),
+            self.offset_x.compute_distance(&other.offset_x)?,
-                     try!(self.blur_radius.compute_distance(&other.blur_radius)),
+            self.offset_y.compute_distance(&other.offset_y)?,
-                     try!(self.color.compute_distance(&other.color)),
+            self.blur_radius.compute_distance(&other.blur_radius)?,
-                     try!(self.spread_radius.compute_distance(&other.spread_radius)),
+            self.color.compute_distance(&other.color)?,
+            self.spread_radius.compute_distance(&other.spread_radius)?,
         ];
         Ok(list.iter().fold(0.0f64, |sum, diff| sum + diff * diff))
     }
@@ -3155,8 +3147,9 @@ impl Animatable for IntermediateShadowList {
 
         for i in 0..max_len {
             let shadow = match (self.0.get(i), other.0.get(i)) {
-                (Some(shadow), Some(other)) =>
+                (Some(shadow), Some(other)) => {
-                    try!(shadow.add_weighted(other, self_portion, other_portion)),
+                    shadow.add_weighted(other, self_portion, other_portion)?
+                }
                 (Some(shadow), None) => {
                         zero.inset = shadow.inset;
                         shadow.add_weighted(&zero, self_portion, other_portion).unwrap()

components/style/properties/longhand/background.mako.rs

@@ -66,10 +66,10 @@ ${helpers.predefined_type("background-image", "ImageLayer",
                 (RepeatKeyword::Repeat, RepeatKeyword::NoRepeat) => dest.write_str("repeat-x"),
                 (RepeatKeyword::NoRepeat, RepeatKeyword::Repeat) => dest.write_str("repeat-y"),
                 (horizontal, vertical) => {
-                    try!(horizontal.to_css(dest));
+                    horizontal.to_css(dest)?;
                     if horizontal != vertical {
-                        try!(dest.write_str(" "));
+                        dest.write_str(" ")?;
-                        try!(vertical.to_css(dest));
+                        vertical.to_css(dest)?;
                     }
                     Ok(())
                 },
@@ -82,10 +82,10 @@ ${helpers.predefined_type("background-image", "ImageLayer",
                 SpecifiedValue::RepeatX => dest.write_str("repeat-x"),
                 SpecifiedValue::RepeatY => dest.write_str("repeat-y"),
                 SpecifiedValue::Other(horizontal, vertical) => {
-                    try!(horizontal.to_css(dest));
+                    horizontal.to_css(dest)?;
                     if let Some(vertical) = vertical {
-                        try!(dest.write_str(" "));
+                        dest.write_str(" ")?;
-                        try!(vertical.to_css(dest));
+                        vertical.to_css(dest)?;
                     }
                     Ok(())
                 }
@@ -138,7 +138,7 @@ ${helpers.predefined_type("background-image", "ImageLayer",
         }).or_else(|()| {
             let horizontal: Result<_, ParseError> = RepeatKeyword::from_ident(&ident)
                 .map_err(|()| SelectorParseError::UnexpectedIdent(ident).into());
-            let horizontal = try!(horizontal);
+            let horizontal = horizontal?;
             let vertical = input.try(RepeatKeyword::parse).ok();
             Ok(SpecifiedValue::Other(horizontal, vertical))
         })

components/style/properties/longhand/border.mako.rs

@@ -91,10 +91,10 @@ ${helpers.gecko_keyword_conversion(Keyword('border-style',
                         let mut first = true;
                         for ref color in vec {
                             if !first {
-                                try!(dest.write_str(" "));
+                                dest.write_str(" ")?;
                             }
                             first = false;
-                            try!(color.to_css(dest))
+                            color.to_css(dest)?
                         }
                         Ok(())
                     }
@@ -110,10 +110,10 @@ ${helpers.gecko_keyword_conversion(Keyword('border-style',
                         let mut first = true;
                         for ref color in vec {
                             if !first {
-                                try!(dest.write_str(" "));
+                                dest.write_str(" ")?;
                             }
                             first = false;
-                            try!(color.to_css(dest))
+                            color.to_css(dest)?
                         }
                         Ok(())
                     }
@@ -240,10 +240,10 @@ ${helpers.predefined_type("border-image-outset", "LengthOrNumberRect",
 
     impl ToCss for SpecifiedValue {
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-            try!(self.0.to_css(dest));
+            self.0.to_css(dest)?;
             if let Some(second) = self.1 {
-                try!(dest.write_str(" "));
+                dest.write_str(" ")?;
-                try!(second.to_css(dest));
+                second.to_css(dest)?;
             }
             Ok(())
         }
@@ -274,7 +274,7 @@ ${helpers.predefined_type("border-image-outset", "LengthOrNumberRect",
 
     pub fn parse<'i, 't>(_context: &ParserContext, input: &mut Parser<'i, 't>)
                          -> Result<SpecifiedValue, ParseError<'i>> {
-        let first = try!(RepeatKeyword::parse(input));
+        let first = RepeatKeyword::parse(input)?;
         let second = input.try(RepeatKeyword::parse).ok();
 
         Ok(SpecifiedValue(first, second))

components/style/properties/longhand/box.mako.rs

@@ -567,7 +567,7 @@ ${helpers.predefined_type("animation-timing-function",
                 return Ok(SpecifiedValue::Infinite)
             }
 
-            let number = try!(input.expect_number());
+            let number = input.expect_number()?;
             if number < 0.0 {
                 return Err(StyleParseError::UnspecifiedError.into());
             }
@@ -936,10 +936,10 @@ ${helpers.predefined_type("scroll-snap-coordinate",
             let mut first = true;
             for operation in &self.0 {
                 if !first {
-                    try!(dest.write_str(" "));
+                    dest.write_str(" ")?;
                 }
                 first = false;
-                try!(operation.to_css(dest))
+                operation.to_css(dest)?
             }
             Ok(())
         }
@@ -966,12 +966,12 @@ ${helpers.predefined_type("scroll-snap-coordinate",
             let valid_fn = match_ignore_ascii_case! {
                 &name,
                 "matrix" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
                         // Standard matrix parsing.
                         if !prefixed {
-                            let values = try!(input.parse_comma_separated(|input| {
+                            let values = input.parse_comma_separated(|input| {
                                 specified::parse_number(context, input)
-                            }));
+                            })?;
                             if values.len() != 6 {
                                 return Err(StyleParseError::UnspecifiedError.into())
                             }
@@ -1018,13 +1018,13 @@ ${helpers.predefined_type("scroll-snap-coordinate",
                             f: lengths[1].clone(),
                         });
                         Ok(true)
-                    }))
+                    })?
                 },
                 "matrix3d" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
                         // Standard matrix3d parsing.
                         if !prefixed {
-                            let values = try!(input.parse_comma_separated(|i| specified::parse_number(context, i)));
+                            let values = input.parse_comma_separated(|i| specified::parse_number(context, i))?;
                             if values.len() != 16 {
                                 return Err(StyleParseError::UnspecifiedError.into())
                             }
@@ -1073,170 +1073,170 @@ ${helpers.predefined_type("scroll-snap-coordinate",
                             m44: values[12]
                         });
                         Ok(true)
-                    }))
+                    })?
                 },
                 "translate" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let sx = try!(specified::LengthOrPercentage::parse(context, input));
+                        let sx = specified::LengthOrPercentage::parse(context, input)?;
                         if input.try(|input| input.expect_comma()).is_ok() {
-                            let sy = try!(specified::LengthOrPercentage::parse(context, input));
+                            let sy = specified::LengthOrPercentage::parse(context, input)?;
                             result.push(SpecifiedOperation::Translate(sx, Some(sy)));
                         } else {
                             result.push(SpecifiedOperation::Translate(sx, None));
                         }
                         Ok(true)
-                    }))
+                    })?
                 },
                 "translatex" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let tx = try!(specified::LengthOrPercentage::parse(context, input));
+                        let tx = specified::LengthOrPercentage::parse(context, input)?;
                         result.push(SpecifiedOperation::TranslateX(tx));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "translatey" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let ty = try!(specified::LengthOrPercentage::parse(context, input));
+                        let ty = specified::LengthOrPercentage::parse(context, input)?;
                         result.push(SpecifiedOperation::TranslateY(ty));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "translatez" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let tz = try!(specified::Length::parse(context, input));
+                        let tz = specified::Length::parse(context, input)?;
                         result.push(SpecifiedOperation::TranslateZ(tz));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "translate3d" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let tx = try!(specified::LengthOrPercentage::parse(context, input));
+                        let tx = specified::LengthOrPercentage::parse(context, input)?;
-                        try!(input.expect_comma());
+                        input.expect_comma()?;
-                        let ty = try!(specified::LengthOrPercentage::parse(context, input));
+                        let ty = specified::LengthOrPercentage::parse(context, input)?;
-                        try!(input.expect_comma());
+                        input.expect_comma()?;
-                        let tz = try!(specified::Length::parse(context, input));
+                        let tz = specified::Length::parse(context, input)?;
                         result.push(SpecifiedOperation::Translate3D(tx, ty, tz));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "scale" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let sx = try!(specified::parse_number(context, input));
+                        let sx = specified::parse_number(context, input)?;
                         if input.try(|input| input.expect_comma()).is_ok() {
-                            let sy = try!(specified::parse_number(context, input));
+                            let sy = specified::parse_number(context, input)?;
                             result.push(SpecifiedOperation::Scale(sx, Some(sy)));
                         } else {
                             result.push(SpecifiedOperation::Scale(sx, None));
                         }
                         Ok(true)
-                    }))
+                    })?
                 },
                 "scalex" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let sx = try!(specified::parse_number(context, input));
+                        let sx = specified::parse_number(context, input)?;
                         result.push(SpecifiedOperation::ScaleX(sx));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "scaley" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let sy = try!(specified::parse_number(context, input));
+                        let sy = specified::parse_number(context, input)?;
                         result.push(SpecifiedOperation::ScaleY(sy));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "scalez" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let sz = try!(specified::parse_number(context, input));
+                        let sz = specified::parse_number(context, input)?;
                         result.push(SpecifiedOperation::ScaleZ(sz));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "scale3d" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let sx = try!(specified::parse_number(context, input));
+                        let sx = specified::parse_number(context, input)?;
-                        try!(input.expect_comma());
+                        input.expect_comma()?;
-                        let sy = try!(specified::parse_number(context, input));
+                        let sy = specified::parse_number(context, input)?;
-                        try!(input.expect_comma());
+                        input.expect_comma()?;
-                        let sz = try!(specified::parse_number(context, input));
+                        let sz = specified::parse_number(context, input)?;
                         result.push(SpecifiedOperation::Scale3D(sx, sy, sz));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "rotate" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let theta = try!(specified::Angle::parse_with_unitless(context, input));
+                        let theta = specified::Angle::parse_with_unitless(context, input)?;
                         result.push(SpecifiedOperation::Rotate(theta));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "rotatex" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let theta = try!(specified::Angle::parse_with_unitless(context, input));
+                        let theta = specified::Angle::parse_with_unitless(context, input)?;
                         result.push(SpecifiedOperation::RotateX(theta));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "rotatey" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let theta = try!(specified::Angle::parse_with_unitless(context, input));
+                        let theta = specified::Angle::parse_with_unitless(context, input)?;
                         result.push(SpecifiedOperation::RotateY(theta));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "rotatez" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let theta = try!(specified::Angle::parse_with_unitless(context, input));
+                        let theta = specified::Angle::parse_with_unitless(context, input)?;
                         result.push(SpecifiedOperation::RotateZ(theta));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "rotate3d" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let ax = try!(specified::parse_number(context, input));
+                        let ax = specified::parse_number(context, input)?;
-                        try!(input.expect_comma());
+                        input.expect_comma()?;
-                        let ay = try!(specified::parse_number(context, input));
+                        let ay = specified::parse_number(context, input)?;
-                        try!(input.expect_comma());
+                        input.expect_comma()?;
-                        let az = try!(specified::parse_number(context, input));
+                        let az = specified::parse_number(context, input)?;
-                        try!(input.expect_comma());
+                        input.expect_comma()?;
-                        let theta = try!(specified::Angle::parse_with_unitless(context, input));
+                        let theta = specified::Angle::parse_with_unitless(context, input)?;
                         // TODO(gw): Check the axis can be normalized!!
                         result.push(SpecifiedOperation::Rotate3D(ax, ay, az, theta));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "skew" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let theta_x = try!(specified::Angle::parse_with_unitless(context, input));
+                        let theta_x = specified::Angle::parse_with_unitless(context, input)?;
                         if input.try(|input| input.expect_comma()).is_ok() {
-                            let theta_y = try!(specified::Angle::parse_with_unitless(context, input));
+                            let theta_y = specified::Angle::parse_with_unitless(context, input)?;
                             result.push(SpecifiedOperation::Skew(theta_x, Some(theta_y)));
                         } else {
                             result.push(SpecifiedOperation::Skew(theta_x, None));
                         }
                         Ok(true)
-                    }))
+                    })?
                 },
                 "skewx" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let theta_x = try!(specified::Angle::parse_with_unitless(context, input));
+                        let theta_x = specified::Angle::parse_with_unitless(context, input)?;
                         result.push(SpecifiedOperation::SkewX(theta_x));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "skewy" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let theta_y = try!(specified::Angle::parse_with_unitless(context, input));
+                        let theta_y = specified::Angle::parse_with_unitless(context, input)?;
                         result.push(SpecifiedOperation::SkewY(theta_y));
                         Ok(true)
-                    }))
+                    })?
                 },
                 "perspective" => {
-                    try!(input.parse_nested_block(|input| {
+                    input.parse_nested_block(|input| {
-                        let d = try!(specified::Length::parse_non_negative(context, input));
+                        let d = specified::Length::parse_non_negative(context, input)?;
                         result.push(SpecifiedOperation::Perspective(d));
                         Ok(true)
-                    }))
+                    })?
                 },
                 _ => false
             };
@@ -1757,10 +1757,10 @@ ${helpers.predefined_type("transform-origin",
                 ($ident:ident => $str:expr) => {
                     if self.contains($ident) {
                         if has_any {
-                            try!(dest.write_str(" "));
+                            dest.write_str(" ")?;
                         }
                         has_any = true;
-                        try!(dest.write_str($str));
+                        dest.write_str($str)?;
                     }
                 }
             }

components/style/properties/longhand/counters.mako.rs

@@ -71,18 +71,18 @@
                 match *self {
                     ContentItem::String(ref s) => s.to_css(dest),
                     ContentItem::Counter(ref s, ref counter_style) => {
-                        try!(dest.write_str("counter("));
+                        dest.write_str("counter(")?;
-                        try!(cssparser::serialize_identifier(&**s, dest));
+                        cssparser::serialize_identifier(&**s, dest)?;
-                        try!(dest.write_str(", "));
+                        dest.write_str(", ")?;
-                        try!(counter_style.to_css(dest));
+                        counter_style.to_css(dest)?;
                         dest.write_str(")")
                     }
                     ContentItem::Counters(ref s, ref separator, ref counter_style) => {
-                        try!(dest.write_str("counters("));
+                        dest.write_str("counters(")?;
-                        try!(cssparser::serialize_identifier(&**s, dest));
+                        cssparser::serialize_identifier(&**s, dest)?;
-                        try!(dest.write_str(", "));
+                        dest.write_str(", ")?;
                         separator.to_css(dest)?;
-                        try!(dest.write_str(", "));
+                        dest.write_str(", ")?;
                         counter_style.to_css(dest)?;
                         dest.write_str(")")
                     }
@@ -121,10 +121,10 @@
                     % endif
                     T::Items(ref content) => {
                         let mut iter = content.iter();
-                        try!(iter.next().unwrap().to_css(dest));
+                        iter.next().unwrap().to_css(dest)?;
                         for c in iter {
-                            try!(dest.write_str(" "));
+                            dest.write_str(" ")?;
-                            try!(c.to_css(dest));
+                            c.to_css(dest)?;
                         }
                         Ok(())
                     }
@@ -186,14 +186,14 @@
                 Ok(Token::Function(name)) => {
                     let result = match_ignore_ascii_case! { &name,
                         "counter" => Some(input.parse_nested_block(|input| {
-                            let name = try!(input.expect_ident()).into_owned();
+                            let name = input.expect_ident()?.into_owned();
                             let style = parse_counter_style(context, input);
                             Ok(ContentItem::Counter(name, style))
                         })),
                         "counters" => Some(input.parse_nested_block(|input| {
-                            let name = try!(input.expect_ident()).into_owned();
+                            let name = input.expect_ident()?.into_owned();
-                            try!(input.expect_comma());
+                            input.expect_comma()?;
-                            let separator = try!(input.expect_string()).into_owned();
+                            let separator = input.expect_string()?.into_owned();
                             let style = parse_counter_style(context, input);
                             Ok(ContentItem::Counters(name, separator, style))
                         })),
@@ -205,7 +205,7 @@
                         _ => None
                     };
                     match result {
-                        Some(result) => content.push(try!(result)),
+                        Some(result) => content.push(result?),
                         None => return Err(StyleParseError::UnexpectedFunction(name).into())
                     }
                 }

components/style/properties/longhand/effects.mako.rs

@@ -159,14 +159,14 @@ ${helpers.predefined_type("clip",
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             let mut iter = self.filters.iter();
             if let Some(filter) = iter.next() {
-                try!(filter.to_css(dest));
+                filter.to_css(dest)?;
             } else {
-                try!(dest.write_str("none"));
+                dest.write_str("none")?;
                 return Ok(())
             }
             for filter in iter {
-                try!(dest.write_str(" "));
+                dest.write_str(" ")?;
-                try!(filter.to_css(dest));
+                filter.to_css(dest)?;
             }
             Ok(())
         }
@@ -176,14 +176,14 @@ ${helpers.predefined_type("clip",
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             let mut iter = self.0.iter();
             if let Some(filter) = iter.next() {
-                try!(filter.to_css(dest));
+                filter.to_css(dest)?;
             } else {
-                try!(dest.write_str("none"));
+                dest.write_str("none")?;
                 return Ok(())
             }
             for filter in iter {
-                try!(dest.write_str(" "));
+                dest.write_str(" ")?;
-                try!(filter.to_css(dest));
+                filter.to_css(dest)?;
             }
             Ok(())
         }
@@ -193,22 +193,22 @@ ${helpers.predefined_type("clip",
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             match *self {
                 computed_value::Filter::Blur(ref value) => {
-                    try!(dest.write_str("blur("));
+                    dest.write_str("blur(")?;
-                    try!(value.to_css(dest));
+                    value.to_css(dest)?;
-                    try!(dest.write_str(")"));
+                    dest.write_str(")")?;
                 }
-                computed_value::Filter::Brightness(value) => try!(write!(dest, "brightness({})", value)),
+                computed_value::Filter::Brightness(value) => write!(dest, "brightness({})", value)?,
-                computed_value::Filter::Contrast(value) => try!(write!(dest, "contrast({})", value)),
+                computed_value::Filter::Contrast(value) => write!(dest, "contrast({})", value)?,
-                computed_value::Filter::Grayscale(value) => try!(write!(dest, "grayscale({})", value)),
+                computed_value::Filter::Grayscale(value) => write!(dest, "grayscale({})", value)?,
                 computed_value::Filter::HueRotate(value) => {
-                    try!(dest.write_str("hue-rotate("));
+                    dest.write_str("hue-rotate(")?;
-                    try!(value.to_css(dest));
+                    value.to_css(dest)?;
-                    try!(dest.write_str(")"));
+                    dest.write_str(")")?;
                 }
-                computed_value::Filter::Invert(value) => try!(write!(dest, "invert({})", value)),
+                computed_value::Filter::Invert(value) => write!(dest, "invert({})", value)?,
-                computed_value::Filter::Opacity(value) => try!(write!(dest, "opacity({})", value)),
+                computed_value::Filter::Opacity(value) => write!(dest, "opacity({})", value)?,
-                computed_value::Filter::Saturate(value) => try!(write!(dest, "saturate({})", value)),
+                computed_value::Filter::Saturate(value) => write!(dest, "saturate({})", value)?,
-                computed_value::Filter::Sepia(value) => try!(write!(dest, "sepia({})", value)),
+                computed_value::Filter::Sepia(value) => write!(dest, "sepia({})", value)?,
                 % if product == "gecko":
                 computed_value::Filter::DropShadow(shadow) => {
                     dest.write_str("drop-shadow(")?;
@@ -228,22 +228,22 @@ ${helpers.predefined_type("clip",
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             match *self {
                 SpecifiedFilter::Blur(ref value) => {
-                    try!(dest.write_str("blur("));
+                    dest.write_str("blur(")?;
-                    try!(value.to_css(dest));
+                    value.to_css(dest)?;
-                    try!(dest.write_str(")"));
+                    dest.write_str(")")?;
                 }
-                SpecifiedFilter::Brightness(value) => try!(write!(dest, "brightness({})", value)),
+                SpecifiedFilter::Brightness(value) => write!(dest, "brightness({})", value)?,
-                SpecifiedFilter::Contrast(value) => try!(write!(dest, "contrast({})", value)),
+                SpecifiedFilter::Contrast(value) => write!(dest, "contrast({})", value)?,
-                SpecifiedFilter::Grayscale(value) => try!(write!(dest, "grayscale({})", value)),
+                SpecifiedFilter::Grayscale(value) => write!(dest, "grayscale({})", value)?,
                 SpecifiedFilter::HueRotate(value) => {
-                    try!(dest.write_str("hue-rotate("));
+                    dest.write_str("hue-rotate(")?;
-                    try!(value.to_css(dest));
+                    value.to_css(dest)?;
-                    try!(dest.write_str(")"));
+                    dest.write_str(")")?;
                 }
-                SpecifiedFilter::Invert(value) => try!(write!(dest, "invert({})", value)),
+                SpecifiedFilter::Invert(value) => write!(dest, "invert({})", value)?,
-                SpecifiedFilter::Opacity(value) => try!(write!(dest, "opacity({})", value)),
+                SpecifiedFilter::Opacity(value) => write!(dest, "opacity({})", value)?,
-                SpecifiedFilter::Saturate(value) => try!(write!(dest, "saturate({})", value)),
+                SpecifiedFilter::Saturate(value) => write!(dest, "saturate({})", value)?,
-                SpecifiedFilter::Sepia(value) => try!(write!(dest, "sepia({})", value)),
+                SpecifiedFilter::Sepia(value) => write!(dest, "sepia({})", value)?,
                 % if product == "gecko":
                 SpecifiedFilter::DropShadow(ref shadow) => {
                     dest.write_str("drop-shadow(")?;
@@ -277,7 +277,7 @@ ${helpers.predefined_type("clip",
                 } else
             % endif
             if let Ok(function_name) = input.try(|input| input.expect_function()) {
-                filters.push(try!(input.parse_nested_block(|input| {
+                filters.push(input.parse_nested_block(|input| {
                     match_ignore_ascii_case! { &function_name,
                         "blur" => specified::Length::parse_non_negative(context, input).map(SpecifiedFilter::Blur),
                         "brightness" => parse_factor(input).map(SpecifiedFilter::Brightness),
@@ -294,7 +294,7 @@ ${helpers.predefined_type("clip",
                         % endif
                         _ => Err(StyleParseError::UnexpectedFunction(function_name.clone()).into())
                     }
-                })));
+                })?);
             } else if filters.is_empty() {
                 return Err(StyleParseError::UnspecifiedError.into())
             } else {

components/style/properties/longhand/font.mako.rs

@@ -160,7 +160,7 @@ macro_rules! impl_gecko_keyword_from_trait {
                         quoted: true,
                     }))
                 }
-                let first_ident = try!(input.expect_ident());
+                let first_ident = input.expect_ident()?;
 
                 // FIXME(bholley): The fast thing to do here would be to look up the
                 // string (as lowercase) in the static atoms table. We don't have an
@@ -271,10 +271,10 @@ macro_rules! impl_gecko_keyword_from_trait {
         impl ToCss for T {
             fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
                 let mut iter = self.0.iter();
-                try!(iter.next().unwrap().to_css(dest));
+                iter.next().unwrap().to_css(dest)?;
                 for family in iter {
-                    try!(dest.write_str(", "));
+                    dest.write_str(", ")?;
-                    try!(family.to_css(dest));
+                    family.to_css(dest)?;
                 }
                 Ok(())
             }
@@ -1125,8 +1125,7 @@ ${helpers.single_keyword_system("font-variant-caps",
                 -> Result<Self, ()> {
                 match (*self, *other) {
                     (T::Number(ref number), T::Number(ref other)) =>
-                        Ok(T::Number(try!(number.add_weighted(other,
+                        Ok(T::Number(number.add_weighted(other, self_portion, other_portion)?)),
-                                                              self_portion, other_portion)))),
                     _ => Err(()),
                 }
             }
@@ -1161,7 +1160,7 @@ ${helpers.single_keyword_system("font-variant-caps",
             return Ok(SpecifiedValue::None);
         }
 
-        Ok(SpecifiedValue::Number(try!(Number::parse_non_negative(context, input))))
+        Ok(SpecifiedValue::Number(Number::parse_non_negative(context, input)?))
     }
 </%helpers:longhand>
 
@@ -1327,10 +1326,10 @@ ${helpers.single_keyword_system("font-kerning",
                 ($ident:ident => $str:expr) => {
                     if self.intersects($ident) {
                         if has_any {
-                            try!(dest.write_str(" "));
+                            dest.write_str(" ")?;
                         }
                         has_any = true;
-                        try!(dest.write_str($str));
+                        dest.write_str($str)?;
                     }
                 }
             }
@@ -1473,10 +1472,10 @@ macro_rules! exclusive_value {
                 ($ident:ident => $str:expr) => {
                     if self.intersects($ident) {
                         if has_any {
-                            try!(dest.write_str(" "));
+                            dest.write_str(" ")?;
                         }
                         has_any = true;
-                        try!(dest.write_str($str));
+                        dest.write_str($str)?;
                     }
                 }
             }
@@ -1620,10 +1619,10 @@ macro_rules! exclusive_value {
                 ($ident:ident => $str:expr) => {
                     if self.intersects($ident) {
                         if has_any {
-                            try!(dest.write_str(" "));
+                            dest.write_str(" ")?;
                         }
                         has_any = true;
-                        try!(dest.write_str($str));
+                        dest.write_str($str)?;
                     }
                 }
             }
@@ -1776,10 +1775,10 @@ macro_rules! exclusive_value {
                 ($ident:ident => $str:expr) => {
                     if self.intersects($ident) {
                         if has_any {
-                            try!(dest.write_str(" "));
+                            dest.write_str(" ")?;
                         }
                         has_any = true;
-                        try!(dest.write_str($str));
+                        dest.write_str($str)?;
                     }
                 }
             }

components/style/properties/longhand/inherited_box.mako.rs

@@ -82,7 +82,7 @@ ${helpers.single_keyword("image-rendering",
     impl ToCss for SpecifiedValue {
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             if let Some(angle) = self.angle {
-                try!(angle.to_css(dest));
+                angle.to_css(dest)?;
                 if self.flipped {
                     dest.write_str(" flip")
                 } else {
@@ -163,9 +163,9 @@ ${helpers.single_keyword("image-rendering",
             match *self {
                 computed_value::T::FromImage => dest.write_str("from-image"),
                 computed_value::T::AngleWithFlipped(angle, flipped) => {
-                    try!(angle.to_css(dest));
+                    angle.to_css(dest)?;
                     if flipped {
-                        try!(dest.write_str(" flip"));
+                        dest.write_str(" flip")?;
                     }
                     Ok(())
                 },

components/style/properties/longhand/inherited_table.mako.rs

@@ -44,10 +44,10 @@ ${helpers.single_keyword("caption-side", "top bottom",
             fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64)
                 -> Result<Self, ()> {
                 Ok(T {
-                    horizontal: try!(self.horizontal.add_weighted(&other.horizontal,
+                    horizontal: self.horizontal.add_weighted(&other.horizontal,
-                                                                  self_portion, other_portion)),
+                                                             self_portion, other_portion)?,
-                    vertical: try!(self.vertical.add_weighted(&other.vertical,
+                    vertical: self.vertical.add_weighted(&other.vertical,
-                                                              self_portion, other_portion)),
+                                                         self_portion, other_portion)?,
                 })
             }
 
@@ -58,8 +58,8 @@ ${helpers.single_keyword("caption-side", "top bottom",
 
             #[inline]
             fn compute_squared_distance(&self, other: &Self) -> Result<f64, ()> {
-                Ok(try!(self.horizontal.compute_squared_distance(&other.horizontal)) +
+                Ok(self.horizontal.compute_squared_distance(&other.horizontal)? +
-                   try!(self.vertical.compute_squared_distance(&other.vertical)))
+                   self.vertical.compute_squared_distance(&other.vertical)?)
             }
         }
     }
@@ -83,9 +83,9 @@ ${helpers.single_keyword("caption-side", "top bottom",
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result
             where W: fmt::Write,
         {
-            try!(self.horizontal.to_css(dest));
+            self.horizontal.to_css(dest)?;
             if let Some(vertical) = self.vertical.as_ref() {
-                try!(dest.write_str(" "));
+                dest.write_str(" ")?;
                 vertical.to_css(dest)?;
             }
             Ok(())

components/style/properties/longhand/inherited_text.mako.rs

@@ -470,16 +470,16 @@ ${helpers.predefined_type("word-spacing",
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             if let Some(fill) = self.fill() {
                 if fill {
-                    try!(dest.write_str("filled"));
+                    dest.write_str("filled")?;
                 } else {
-                    try!(dest.write_str("open"));
+                    dest.write_str("open")?;
                 }
             }
             if let Some(shape) = self.shape() {
                 if self.fill().is_some() {
-                    try!(dest.write_str(" "));
+                    dest.write_str(" ")?;
                 }
-                try!(shape.to_css(dest));
+                shape.to_css(dest)?;
             }
             Ok(())
         }
@@ -487,11 +487,11 @@ ${helpers.predefined_type("word-spacing",
     impl ToCss for computed_value::KeywordValue {
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             if self.fill {
-                try!(dest.write_str("filled"));
+                dest.write_str("filled")?;
             } else {
-                try!(dest.write_str("open"));
+                dest.write_str("open")?;
             }
-            try!(dest.write_str(" "));
+            dest.write_str(" ")?;
             self.shape.to_css(dest)
         }
     }
@@ -643,11 +643,11 @@ ${helpers.predefined_type("word-spacing",
     pub fn parse<'i, 't>(_context: &ParserContext, input: &mut Parser<'i, 't>)
                          -> Result<SpecifiedValue, ParseError<'i>> {
        if let Ok(horizontal) = input.try(|input| HorizontalWritingModeValue::parse(input)) {
-            let vertical = try!(VerticalWritingModeValue::parse(input));
+            let vertical = VerticalWritingModeValue::parse(input)?;
             Ok(SpecifiedValue(horizontal, vertical))
         } else {
-            let vertical = try!(VerticalWritingModeValue::parse(input));
+            let vertical = VerticalWritingModeValue::parse(input)?;
-            let horizontal = try!(HorizontalWritingModeValue::parse(input));
+            let horizontal = HorizontalWritingModeValue::parse(input)?;
             Ok(SpecifiedValue(horizontal, vertical))
         }
     }

components/style/properties/longhand/pointing.mako.rs

@@ -52,12 +52,12 @@
         #[cfg(feature = "gecko")]
         impl ToCss for Image {
             fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-                try!(self.url.to_css(dest));
+                self.url.to_css(dest)?;
                 if let Some((x, y)) = self.hotspot {
-                    try!(dest.write_str(" "));
+                    dest.write_str(" ")?;
-                    try!(x.to_css(dest));
+                    x.to_css(dest)?;
-                    try!(dest.write_str(" "));
+                    dest.write_str(" ")?;
-                    try!(y.to_css(dest));
+                    y.to_css(dest)?;
                 }
                 Ok(())
             }
@@ -67,8 +67,8 @@
         impl ToCss for T {
             fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
                 for url in &self.images {
-                    try!(url.to_css(dest));
+                    url.to_css(dest)?;
-                    try!(dest.write_str(", "));
+                    dest.write_str(", ")?;
                 }
                 self.keyword.to_css(dest)
             }
@@ -95,7 +95,7 @@
                          -> Result<computed_value::Keyword, ParseError<'i>> {
             use std::ascii::AsciiExt;
             use style_traits::cursor::Cursor;
-            let ident = try!(input.expect_ident());
+            let ident = input.expect_ident()?;
             if ident.eq_ignore_ascii_case("auto") {
                 Ok(computed_value::Keyword::Auto)
             } else {
@@ -110,9 +110,9 @@
     fn parse_image<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                            -> Result<computed_value::Image, ParseError<'i>> {
         Ok(computed_value::Image {
-            url: try!(SpecifiedUrl::parse(context, input)),
+            url: SpecifiedUrl::parse(context, input)?,
             hotspot: match input.try(|input| input.expect_number()) {
-                Ok(number) => Some((number, try!(input.expect_number()))),
+                Ok(number) => Some((number, input.expect_number()?)),
                 Err(_) => None,
             },
         })
@@ -137,12 +137,12 @@
                 }
                 Err(_) => break,
             }
-            try!(input.expect_comma());
+            input.expect_comma()?;
         }
 
         Ok(computed_value::T {
             images: images,
-            keyword: try!(computed_value::Keyword::parse(context, input)),
+            keyword: computed_value::Keyword::parse(context, input)?,
         })
     }
 </%helpers:longhand>

components/style/properties/longhand/text.mako.rs

@@ -57,11 +57,11 @@
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             if self.sides_are_logical {
                 assert!(self.first == Side::Clip);
-                try!(self.second.to_css(dest));
+                self.second.to_css(dest)?;
             } else {
-                try!(self.first.to_css(dest));
+                self.first.to_css(dest)?;
-                try!(dest.write_str(" "));
+                dest.write_str(" ")?;
-                try!(self.second.to_css(dest));
+                self.second.to_css(dest)?;
             }
             Ok(())
         }
@@ -133,10 +133,10 @@
 
     impl ToCss for SpecifiedValue {
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-            try!(self.first.to_css(dest));
+            self.first.to_css(dest)?;
             if let Some(ref second) = self.second {
-                try!(dest.write_str(" "));
+                dest.write_str(" ")?;
-                try!(second.to_css(dest));
+                second.to_css(dest)?;
             }
             Ok(())
         }

components/style/properties/longhand/ui.mako.rs

@@ -78,7 +78,7 @@ ${helpers.single_keyword("-moz-window-shadow", "none default menu tooltip sheet"
 
     pub fn parse<'i, 't>(_context: &ParserContext, input: &mut Parser<'i, 't>)
                          -> Result<SpecifiedValue, ParseError<'i>> {
-        match try!(input.expect_integer()) {
+        match input.expect_integer()? {
             0 => Ok(computed_value::T(false)),
             1 => Ok(computed_value::T(true)),
             _ => Err(StyleParseError::UnspecifiedError.into()),

components/style/properties/properties.mako.rs

@@ -234,8 +234,8 @@ pub mod shorthands {
             while let Ok(_) = input.next() {}  // Look for var()
             if input.seen_var_functions() {
                 input.reset(start);
-                let (first_token_type, css) = try!(
+                let (first_token_type, css) =
-                    ::custom_properties::parse_non_custom_with_var(input));
+                    ::custom_properties::parse_non_custom_with_var(input)?;
                 declarations.all_shorthand = AllShorthand::WithVariables(Arc::new(UnparsedValue {
                     css: css.into_owned(),
                     first_token_type: first_token_type,
@@ -1137,8 +1137,8 @@ impl HasViewportPercentage for PropertyDeclaration {
 
 impl fmt::Debug for PropertyDeclaration {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(self.id().to_css(f));
+        self.id().to_css(f)?;
-        try!(f.write_str(": "));
+        f.write_str(": ")?;
         self.to_css(f)
     }
 }

components/style/properties/shorthand/background.mako.rs

@@ -39,7 +39,7 @@
         % for name in "image position_x position_y repeat size attachment origin clip".split():
             let mut background_${name} = background_${name}::SpecifiedValue(Vec::new());
         % endfor
-        try!(input.parse_comma_separated(|input| {
+        input.parse_comma_separated(|input| {
             // background-color can only be in the last element, so if it
             // is parsed anywhere before, the value is invalid.
             if background_color.is_some() {
@@ -62,7 +62,7 @@
 
                         // Parse background size, if applicable.
                         size = input.try(|input| {
-                            try!(input.expect_delim('/'));
+                            input.expect_delim('/')?;
                             background_size::single_value::parse(context, input)
                         }).ok();
 
@@ -110,7 +110,7 @@
             } else {
                 Err(StyleParseError::UnspecifiedError.into())
             }
-        }));
+        })?;
 
         Ok(expanded! {
              background_color: background_color.unwrap_or(Color::transparent()),
@@ -148,37 +148,37 @@
                 % endfor
 
                 if i != 0 {
-                    try!(write!(dest, ", "));
+                    write!(dest, ", ")?;
                 }
 
                 if i == len - 1 {
-                    try!(self.background_color.to_css(dest));
+                    self.background_color.to_css(dest)?;
-                    try!(write!(dest, " "));
+                    write!(dest, " ")?;
                 }
 
-                try!(image.to_css(dest));
+                image.to_css(dest)?;
                 % for name in "repeat attachment".split():
-                    try!(write!(dest, " "));
+                    write!(dest, " ")?;
-                    try!(${name}.to_css(dest));
+                    ${name}.to_css(dest)?;
                 % endfor
 
-                try!(write!(dest, " "));
+                write!(dest, " ")?;
                 Position {
                     horizontal: position_x.clone(),
                     vertical: position_y.clone()
                 }.to_css(dest)?;
 
                 if *size != background_size::single_value::get_initial_specified_value() {
-                    try!(write!(dest, " / "));
+                    write!(dest, " / ")?;
-                    try!(size.to_css(dest));
+                    size.to_css(dest)?;
                 }
 
                 if *origin != Origin::padding_box || *clip != Clip::border_box {
-                    try!(write!(dest, " "));
+                    write!(dest, " ")?;
-                    try!(origin.to_css(dest));
+                    origin.to_css(dest)?;
                     if *clip != From::from(*origin) {
-                        try!(write!(dest, " "));
+                        write!(dest, " ")?;
-                        try!(clip.to_css(dest));
+                        clip.to_css(dest)?;
                     }
                 }
             }

components/style/properties/shorthand/border.mako.rs

@@ -104,7 +104,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
 
     pub fn parse_value<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                                -> Result<Longhands, ParseError<'i>> {
-        let (color, style, width) = try!(super::parse_border(context, input));
+        let (color, style, width) = super::parse_border(context, input)?;
         Ok(expanded! {
             border_${to_rust_ident(side)}_color: color,
             border_${to_rust_ident(side)}_style: style,
@@ -146,7 +146,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
         use properties::longhands::{border_image_outset, border_image_repeat, border_image_slice};
         use properties::longhands::{border_image_source, border_image_width};
 
-        let (color, style, width) = try!(super::parse_border(context, input));
+        let (color, style, width) = super::parse_border(context, input)?;
         Ok(expanded! {
             % for side in PHYSICAL_SIDES:
                 border_${side}_color: color.clone(),
@@ -214,7 +214,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
 
     pub fn parse_value<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                                -> Result<Longhands, ParseError<'i>> {
-        let radii = try!(BorderRadius::parse(context, input));
+        let radii = BorderRadius::parse(context, input)?;
         Ok(expanded! {
             border_top_left_radius: radii.top_left,
             border_top_right_radius: radii.top_right,
@@ -262,7 +262,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                         slice = Some(value);
                         // Parse border image width and outset, if applicable.
                         let maybe_width_outset: Result<_, ParseError> = input.try(|input| {
-                            try!(input.expect_delim('/'));
+                            input.expect_delim('/')?;
 
                             // Parse border image width, if applicable.
                             let w = input.try(|input|
@@ -270,7 +270,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
 
                             // Parse border image outset if applicable.
                             let o = input.try(|input| {
-                                try!(input.expect_delim('/'));
+                                input.expect_delim('/')?;
                                 border_image_outset::parse(context, input)
                             }).ok();
                             if w.is_none() && o.is_none() {
@@ -313,7 +313,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                 Err(StyleParseError::UnspecifiedError.into())
             }
         });
-        try!(result);
+        result?;
 
         Ok(expanded! {
             % for name in "outset repeat slice source width".split():

components/style/properties/shorthand/box.mako.rs

@@ -135,7 +135,7 @@ macro_rules! try_parse_one {
         % endfor
 
         if input.try(|input| input.expect_ident_matching("none")).is_err() {
-            let results = try!(input.parse_comma_separated(|i| parse_one_transition(context, i)));
+            let results = input.parse_comma_separated(|i| parse_one_transition(context, i))?;
             for result in results {
                 % for prop in "property duration timing_function delay".split():
                 ${prop}s.push(result.transition_${prop});
@@ -257,7 +257,7 @@ macro_rules! try_parse_one {
         let mut ${prop}s = vec![];
         % endfor
 
-        let results = try!(input.parse_comma_separated(|i| parse_one_animation(context, i)));
+        let results = input.parse_comma_separated(|i| parse_one_animation(context, i))?;
         for result in results.into_iter() {
             % for prop in props:
             ${prop}s.push(result.animation_${prop});
@@ -289,7 +289,7 @@ macro_rules! try_parse_one {
 
             for i in 0..len {
                 if i != 0 {
-                    try!(write!(dest, ", "));
+                    write!(dest, ", ")?;
                 }
 
                 % for name in props[1:]:
@@ -310,7 +310,7 @@ macro_rules! try_parse_one {
 
     pub fn parse_value<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                                -> Result<Longhands, ParseError<'i>> {
-        let result = try!(scroll_snap_type_x::parse(context, input));
+        let result = scroll_snap_type_x::parse(context, input)?;
         Ok(expanded! {
             scroll_snap_type_x: result,
             scroll_snap_type_y: result,

components/style/properties/shorthand/font.mako.rs

@@ -89,7 +89,7 @@
                     continue
                 }
             }
-            size = Some(try!(font_size::parse(context, input)));
+            size = Some(font_size::parse(context, input)?);
             break
         }
         #[inline]
@@ -101,7 +101,7 @@
             return Err(StyleParseError::UnspecifiedError.into())
         }
         let line_height = if input.try(|input| input.expect_delim('/')).is_ok() {
-            Some(try!(LineHeight::parse(context, input)))
+            Some(LineHeight::parse(context, input)?)
         } else {
             None
         };

components/style/properties/shorthand/mask.mako.rs

@@ -41,7 +41,7 @@
             let mut mask_${name} = mask_${name}::SpecifiedValue(Vec::new());
         % endfor
 
-        try!(input.parse_comma_separated(|input| {
+        input.parse_comma_separated(|input| {
             % for name in "image mode position size repeat origin clip composite".split():
                 let mut ${name} = None;
             % endfor
@@ -59,7 +59,7 @@
 
                         // Parse mask size, if applicable.
                         size = input.try(|input| {
-                            try!(input.expect_delim('/'));
+                            input.expect_delim('/')?;
                             mask_size::single_value::parse(context, input)
                         }).ok();
 
@@ -106,7 +106,7 @@
             } else {
                 Err(StyleParseError::UnspecifiedError.into())
             }
-        }));
+        })?;
 
         Ok(expanded! {
             % for name in "image mode position_x position_y size repeat origin clip composite".split():

components/style/properties/shorthand/outline.mako.rs

@@ -66,7 +66,7 @@
 
     pub fn parse_value<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                                -> Result<Longhands, ParseError<'i>> {
-        let radii = try!(BorderRadius::parse(context, input));
+        let radii = BorderRadius::parse(context, input)?;
         Ok(expanded! {
             _moz_outline_radius_topleft: radii.top_left,
             _moz_outline_radius_topright: radii.top_right,

components/style/properties/shorthand/position.mako.rs

@@ -50,7 +50,7 @@
 
     fn parse_flexibility<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                                  -> Result<(Number, Option<Number>),ParseError<'i>> {
-        let grow = try!(Number::parse_non_negative(context, input));
+        let grow = Number::parse_non_negative(context, input)?;
         let shrink = input.try(|i| Number::parse_non_negative(context, i)).ok();
         Ok((grow, shrink))
     }

components/style/servo/media_queries.rs

@@ -154,20 +154,20 @@ impl Expression {
     /// Only supports width and width ranges for now.
     pub fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                          -> Result<Self, ParseError<'i>> {
-        try!(input.expect_parenthesis_block());
+        input.expect_parenthesis_block()?;
         input.parse_nested_block(|input| {
-            let name = try!(input.expect_ident());
+            let name = input.expect_ident()?;
-            try!(input.expect_colon());
+            input.expect_colon()?;
             // TODO: Handle other media features
             Ok(Expression(match_ignore_ascii_case! { &name,
                 "min-width" => {
-                    ExpressionKind::Width(Range::Min(try!(specified::Length::parse_non_negative(context, input))))
+                    ExpressionKind::Width(Range::Min(specified::Length::parse_non_negative(context, input)?))
                 },
                 "max-width" => {
-                    ExpressionKind::Width(Range::Max(try!(specified::Length::parse_non_negative(context, input))))
+                    ExpressionKind::Width(Range::Max(specified::Length::parse_non_negative(context, input)?))
                 },
                 "width" => {
-                    ExpressionKind::Width(Range::Eq(try!(specified::Length::parse_non_negative(context, input))))
+                    ExpressionKind::Width(Range::Eq(specified::Length::parse_non_negative(context, input)?))
                 },
                 _ => return Err(SelectorParseError::UnexpectedIdent(name.clone()).into())
             }))
@@ -195,14 +195,14 @@ impl ToCss for Expression {
     fn to_css<W>(&self, dest: &mut W) -> fmt::Result
         where W: fmt::Write,
     {
-        try!(write!(dest, "("));
+        write!(dest, "(")?;
         let (mm, l) = match self.0 {
             ExpressionKind::Width(Range::Min(ref l)) => ("min-", l),
             ExpressionKind::Width(Range::Max(ref l)) => ("max-", l),
             ExpressionKind::Width(Range::Eq(ref l)) => ("", l),
         };
-        try!(write!(dest, "{}width: ", mm));
+        write!(dest, "{}width: ", mm)?;
-        try!(l.to_css(dest));
+        l.to_css(dest)?;
         write!(dest, ")")
     }
 }

components/style/servo/restyle_damage.rs

@@ -162,14 +162,14 @@ impl fmt::Display for ServoRestyleDamage {
 
         for &(damage, damage_str) in &to_iter {
             if self.contains(damage) {
-                if !first_elem { try!(write!(f, " | ")); }
+                if !first_elem { write!(f, " | ")?; }
-                try!(write!(f, "{}", damage_str));
+                write!(f, "{}", damage_str)?;
                 first_elem = false;
             }
         }
 
         if first_elem {
-            try!(write!(f, "NoDamage"));
+            write!(f, "NoDamage")?;
         }
 
         Ok(())