comby-rust (#2065)

* comby-rust

* Fix clippy warning

Co-authored-by: Mohammad Fawaz <mohammadfawaz89@gmail.com>

sway-core/src/convert_parse_tree.rs

@@ -2704,10 +2704,10 @@ fn asm_register_declaration_to_asm_register_declaration(
 ) -> Result<AsmRegisterDeclaration, ErrorEmitted> {
     Ok(AsmRegisterDeclaration {
         name: asm_register_declaration.register,
-        initializer: match asm_register_declaration.value_opt {
-            None => None,
-            Some((_colon_token, expr)) => Some(expr_to_expression(ec, *expr)?),
-        },
+        initializer: asm_register_declaration
+            .value_opt
+            .map(|(_colon_token, expr)| expr_to_expression(ec, *expr))
+            .transpose()?,
     })
 }
 
@@ -2877,10 +2877,9 @@ fn pattern_struct_field_to_struct_scrutinee_field(
         } => {
             let struct_scrutinee_field = StructScrutineeField::Field {
                 field: field_name,
-                scrutinee: match pattern_opt {
-                    Some((_colon_token, pattern)) => Some(pattern_to_scrutinee(ec, *pattern)?),
-                    None => None,
-                },
+                scrutinee: pattern_opt
+                    .map(|(_colon_token, pattern)| pattern_to_scrutinee(ec, *pattern))
+                    .transpose()?,
                 span,
             };
             Ok(struct_scrutinee_field)

sway-ir/src/verify.rs

@@ -173,10 +173,9 @@ impl<'a> InstructionVerifier<'a> {
 
     fn verify_bitcast(&self, value: &Value, ty: &Type) -> Result<(), IrError> {
         // The to and from types must be copy-types, excluding short strings, and the same size.
-        let val_ty = match value.get_type(self.context) {
-            None => return Err(IrError::VerifyBitcastUnknownSourceType),
-            Some(ty) => ty,
-        };
+        let val_ty = value
+            .get_type(self.context)
+            .ok_or(IrError::VerifyBitcastUnknownSourceType)?;
         if !val_ty.is_copy_type() {
             return Err(IrError::VerifyBitcastFromNonCopyType(
                 val_ty.as_string(self.context),

sway-parse/src/expr/asm.rs

@@ -121,14 +121,13 @@ impl ParseToEnd for AsmBlockContents {
 impl Parse for AsmImmediate {
     fn parse(parser: &mut Parser) -> ParseResult<AsmImmediate> {
         let ident = parser.parse::<Ident>()?;
-        let digits = match ident.as_str().strip_prefix('i') {
-            Some(digits) => digits,
-            None => return Err(parser.emit_error(ParseErrorKind::MalformedAsmImmediate)),
-        };
-        let parsed = match BigUint::from_str(digits).ok() {
-            Some(parsed) => parsed,
-            None => return Err(parser.emit_error(ParseErrorKind::MalformedAsmImmediate)),
-        };
+        let digits = ident
+            .as_str()
+            .strip_prefix('i')
+            .ok_or_else(|| parser.emit_error(ParseErrorKind::MalformedAsmImmediate))?;
+        let parsed = BigUint::from_str(digits)
+            .ok()
+            .ok_or_else(|| parser.emit_error(ParseErrorKind::MalformedAsmImmediate))?;
         Ok(AsmImmediate {
             span: ident.span(),
             parsed,

sway-parse/src/item/item_use.rs

@@ -51,10 +51,9 @@ impl Parse for UseTree {
         if let Some(star_token) = parser.take() {
             return Ok(UseTree::Glob { star_token });
         }
-        let name = match parser.take() {
-            Some(name) => name,
-            None => return Err(parser.emit_error(ParseErrorKind::ExpectedImportNameGroupOrGlob)),
-        };
+        let name = parser
+            .take()
+            .ok_or_else(|| parser.emit_error(ParseErrorKind::ExpectedImportNameGroupOrGlob))?;
         if let Some(as_token) = parser.take() {
             let alias = parser.parse()?;
             return Ok(UseTree::Rename {

sway-parse/src/literal.rs

@@ -68,10 +68,9 @@ impl Peek for Literal {
 
 impl Parse for Literal {
     fn parse(parser: &mut Parser) -> ParseResult<Literal> {
-        match parser.take() {
-            Some(literal) => Ok(literal),
-            None => Err(parser.emit_error(ParseErrorKind::ExpectedLiteral)),
-        }
+        parser
+            .take()
+            .ok_or_else(|| parser.emit_error(ParseErrorKind::ExpectedLiteral))
     }
 }