Merge branch 'vaivaswatha/ir_consts_2' of github.com:FuelLabs/sway in…

…to vaivaswatha/ir_consts_2
FuelLabs · Feb 26, 2025 · f3088a8 · f3088a8
2 parents c0f6b7e + e27927f
commit f3088a8
Show file tree

Hide file tree

Showing 24 changed files with 374 additions and 53 deletions.
diff --git a/sway-core/src/asm_lang/mod.rs b/sway-core/src/asm_lang/mod.rs
@@ -596,6 +596,10 @@ impl Op {
                 let (r1, r2, r3, i0) = three_regs_imm_06(handler, args, immediate, whole_op_span)?;
                 VirtualOp::LDC(r1, r2, r3, i0)
             }
+            "bldd" => {
+                let (r1, r2, r3, r4) = four_regs(handler, args, immediate, whole_op_span)?;
+                VirtualOp::BLDD(r1, r2, r3, r4)
+            }
             "log" => {
                 let (r1, r2, r3, r4) = four_regs(handler, args, immediate, whole_op_span)?;
                 VirtualOp::LOG(r1, r2, r3, r4)

diff --git a/sway-core/src/language/ty/code_block.rs b/sway-core/src/language/ty/code_block.rs
@@ -1,6 +1,6 @@
 use crate::{
     decl_engine::*, engine_threading::*, language::ty::*, semantic_analysis::TypeCheckContext,
-    type_system::*,
+    transform::AllowDeprecatedState, type_system::*,
 };
 use serde::{Deserialize, Serialize};
 use std::hash::Hasher;
@@ -13,6 +13,19 @@ pub struct TyCodeBlock {
     pub(crate) whole_block_span: Span,
 }
 
+impl TyCodeBlock {
+    pub(crate) fn check_deprecated(
+        &self,
+        engines: &Engines,
+        handler: &Handler,
+        allow_deprecated: &mut AllowDeprecatedState,
+    ) {
+        for n in self.contents.iter() {
+            n.check_deprecated(engines, handler, allow_deprecated);
+        }
+    }
+}
+
 impl Default for TyCodeBlock {
     fn default() -> Self {
         Self {

diff --git a/sway-core/src/language/ty/expression/expression.rs b/sway-core/src/language/ty/expression/expression.rs
@@ -437,6 +437,81 @@ impl TyExpression {
         }
 
         match &self.expression {
+            TyExpressionVariant::Literal(..) => {}
+            TyExpressionVariant::FunctionApplication {
+                call_path,
+                fn_ref,
+                arguments,
+                ..
+            } => {
+                for (_, expr) in arguments.iter() {
+                    expr.check_deprecated(engines, handler, allow_deprecated);
+                }
+
+                let fn_ty = engines.de().get(fn_ref);
+                if let Some(TyDecl::ImplSelfOrTrait(t)) = &fn_ty.implementing_type {
+                    let t = &engines.de().get(&t.decl_id).implementing_for;
+                    if let TypeInfo::Struct(struct_id) = &*engines.te().get(t.type_id) {
+                        let s = engines.de().get(struct_id);
+                        emit_warning_if_deprecated(
+                            &s.attributes,
+                            &call_path.span(),
+                            handler,
+                            "deprecated struct",
+                            allow_deprecated,
+                        );
+                    }
+                }
+
+                emit_warning_if_deprecated(
+                    &fn_ty.attributes,
+                    &call_path.span(),
+                    handler,
+                    "deprecated function",
+                    allow_deprecated,
+                );
+            }
+            TyExpressionVariant::LazyOperator { lhs, rhs, .. } => {
+                lhs.check_deprecated(engines, handler, allow_deprecated);
+                rhs.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::ConstantExpression { span, decl, .. } => {
+                emit_warning_if_deprecated(
+                    &decl.attributes,
+                    span,
+                    handler,
+                    "deprecated constant",
+                    allow_deprecated,
+                );
+            }
+            TyExpressionVariant::ConfigurableExpression { span, decl, .. } => {
+                emit_warning_if_deprecated(
+                    &decl.attributes,
+                    span,
+                    handler,
+                    "deprecated configurable",
+                    allow_deprecated,
+                );
+            }
+            TyExpressionVariant::VariableExpression { .. } => {}
+            TyExpressionVariant::Tuple { fields } => {
+                for e in fields.iter() {
+                    e.check_deprecated(engines, handler, allow_deprecated);
+                }
+            }
+            TyExpressionVariant::ArrayExplicit { contents, .. } => {
+                for e in contents.iter() {
+                    e.check_deprecated(engines, handler, allow_deprecated);
+                }
+            }
+            TyExpressionVariant::ArrayRepeat { value, length, .. } => {
+                value.check_deprecated(engines, handler, allow_deprecated);
+                length.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::ArrayIndex { prefix, index } => {
+                prefix.check_deprecated(engines, handler, allow_deprecated);
+                index.check_deprecated(engines, handler, allow_deprecated);
+            }
             TyExpressionVariant::StructExpression {
                 struct_id,
                 instantiation_span,
@@ -451,26 +526,132 @@ impl TyExpression {
                     allow_deprecated,
                 );
             }
-            TyExpressionVariant::FunctionApplication {
-                call_path, fn_ref, ..
+            TyExpressionVariant::CodeBlock(block) => {
+                block.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::FunctionParameter => {}
+            TyExpressionVariant::MatchExp {
+                desugared,
+                //scrutinees,
+                ..
             } => {
-                if let Some(TyDecl::ImplSelfOrTrait(t)) =
-                    &engines.de().get(fn_ref).implementing_type
-                {
-                    let t = &engines.de().get(&t.decl_id).implementing_for;
-                    if let TypeInfo::Struct(struct_id) = &*engines.te().get(t.type_id) {
-                        let s = engines.de().get(struct_id);
-                        emit_warning_if_deprecated(
-                            &s.attributes,
-                            &call_path.span(),
-                            handler,
-                            "deprecated struct",
-                            allow_deprecated,
-                        );
-                    }
+                desugared.check_deprecated(engines, handler, allow_deprecated);
+                // TODO: check scrutinees if necessary
+            }
+            TyExpressionVariant::IfExp {
+                condition,
+                then,
+                r#else,
+            } => {
+                condition.check_deprecated(engines, handler, allow_deprecated);
+                then.check_deprecated(engines, handler, allow_deprecated);
+                if let Some(e) = r#else {
+                    e.check_deprecated(engines, handler, allow_deprecated);
                 }
             }
-            _ => {}
+            TyExpressionVariant::AsmExpression { .. } => {}
+            TyExpressionVariant::StructFieldAccess {
+                prefix,
+                field_to_access,
+                field_instantiation_span,
+                ..
+            } => {
+                prefix.check_deprecated(engines, handler, allow_deprecated);
+                emit_warning_if_deprecated(
+                    &field_to_access.attributes,
+                    field_instantiation_span,
+                    handler,
+                    "deprecated struct field",
+                    allow_deprecated,
+                );
+            }
+            TyExpressionVariant::TupleElemAccess { prefix, .. } => {
+                prefix.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::EnumInstantiation {
+                enum_ref,
+                tag,
+                contents,
+                variant_instantiation_span,
+                ..
+            } => {
+                let enum_ty = engines.de().get(enum_ref);
+                emit_warning_if_deprecated(
+                    &enum_ty.attributes,
+                    variant_instantiation_span,
+                    handler,
+                    "deprecated enum",
+                    allow_deprecated,
+                );
+                if let Some(variant_decl) = enum_ty.variants.get(*tag) {
+                    emit_warning_if_deprecated(
+                        &variant_decl.attributes,
+                        variant_instantiation_span,
+                        handler,
+                        "deprecated enum variant",
+                        allow_deprecated,
+                    );
+                }
+                if let Some(expr) = contents {
+                    expr.check_deprecated(engines, handler, allow_deprecated);
+                }
+            }
+            TyExpressionVariant::AbiCast { address, .. } => {
+                // TODO: check abi name?
+                address.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::StorageAccess(access) => {
+                // TODO: check storage access?
+                if let Some(expr) = &access.key_expression {
+                    expr.check_deprecated(engines, handler, allow_deprecated);
+                }
+            }
+            TyExpressionVariant::IntrinsicFunction(kind) => {
+                for arg in kind.arguments.iter() {
+                    arg.check_deprecated(engines, handler, allow_deprecated);
+                }
+            }
+            TyExpressionVariant::AbiName(..) => {}
+            TyExpressionVariant::EnumTag { exp } => {
+                exp.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::UnsafeDowncast {
+                exp,
+                //variant,
+                ..
+            } => {
+                exp.check_deprecated(engines, handler, allow_deprecated);
+                // TODO: maybe check variant?
+            }
+            TyExpressionVariant::WhileLoop { condition, body } => {
+                condition.check_deprecated(engines, handler, allow_deprecated);
+                body.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::ForLoop { desugared } => {
+                desugared.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::Break => {}
+            TyExpressionVariant::Continue => {}
+            TyExpressionVariant::Reassignment(reass) => {
+                if let TyReassignmentTarget::Deref(expr) = &reass.lhs {
+                    expr.check_deprecated(engines, handler, allow_deprecated);
+                }
+                reass
+                    .rhs
+                    .check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::ImplicitReturn(expr) => {
+                expr.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::Return(expr) => {
+                expr.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::Ref(expr) => {
+                expr.check_deprecated(engines, handler, allow_deprecated);
+            }
+            TyExpressionVariant::Deref(expr) => {
+                expr.check_deprecated(engines, handler, allow_deprecated);
+            }
         }
     }
 

diff --git a/sway-lib-std/src/ecr.sw b/sway-lib-std/src/ecr.sw
@@ -217,6 +217,7 @@ pub fn ed_verify(public_key: b256, signature: B512, msg: Bytes) -> Result<bool,
 /// }
 /// ```
 #[deprecated(note = "std::ecr has been replaced by std::crypto, and is no longer maintained")]
+#[allow(deprecated)]
 pub fn ec_recover_address(signature: B512, msg_hash: b256) -> Result<Address, EcRecoverError> {
     let pub_key_result = ec_recover(signature, msg_hash);
 
@@ -263,6 +264,7 @@ pub fn ec_recover_address(signature: B512, msg_hash: b256) -> Result<Address, Ec
 /// }
 /// ```
 #[deprecated(note = "std::ecr has been replaced by std::crypto, and is no longer maintained")]
+#[allow(deprecated)]
 pub fn ec_recover_address_r1(signature: B512, msg_hash: b256) -> Result<Address, EcRecoverError> {
     let pub_key_result = ec_recover_r1(signature, msg_hash);
 

diff --git a/sway-lib-std/src/u128.sw b/sway-lib-std/src/u128.sw
@@ -299,6 +299,7 @@ impl U128 {
         }
     }
 
+    // TODO: Rename to `try_as_u64` to be consistent with all other downcasts
     /// Safely downcast to `u64` without loss of precision.
     ///
     /// # Additional Information
@@ -333,6 +334,27 @@ impl U128 {
         }
     }
 
+    /// Upcasts a `U128` to a `u256`.
+    ///
+    /// # Returns
+    ///
+    /// * [u256] - The `u256` representation of the `U128` value.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// use std::u128::U128;
+    ///
+    /// fn foo() {
+    ///     let u128_value = U128::from(0u64);
+    ///     let u256_value = u128_value.as_u256();
+    /// }
+    pub fn as_u256(self) -> u256 {
+        asm(nums: (0, 0, self.upper, self.lower)) {
+            nums: u256
+        }
+    }
+
     /// The smallest value that can be represented by this integer type.
     ///
     /// # Returns

diff --git a/sway-lib-std/src/vm/evm/ecr.sw b/sway-lib-std/src/vm/evm/ecr.sw
@@ -36,6 +36,7 @@ use ::vm::evm::evm_address::EvmAddress;
 /// }
 /// ```
 #[deprecated(note = "std:vm::evm:ecr has been replaced by std::crypto, and is no longer maintained")]
+#[allow(deprecated)]
 pub fn ec_recover_evm_address(
     signature: B512,
     msg_hash: b256,

diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/ecall/ecall_basic/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/ecall/ecall_basic/Forc.lock
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/ecall/ecall_basic/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/ecall/ecall_basic/test.toml
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/bldd/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/bldd/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "bldd"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/bldd/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/bldd/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "bldd"
+entry = "main.sw"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/bldd/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/bldd/src/main.sw
@@ -0,0 +1,10 @@
+library;
+
+// Intentionally not using `b256::zero()` to avoid dependency to `core`.
+const B256_ZERO: b256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+
+pub fn main() {
+    asm(r1: B256_ZERO, r2: B256_ZERO, r3: 42u64, r4: 21u64) {
+        bldd r1 r2 r3 r4;
+    }
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/bldd/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/bldd/test.toml
@@ -0,0 +1 @@
+category = "compile"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/ecall/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/ecall/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "ecall"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/ecall/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/ecall/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "ecall"
+entry = "main.sw"
+implicit-std = false
diff --git a/...should_pass/ecall/ecall_basic/src/main.sw → ...nguage/asm/instructions/ecall/src/main.sw b/...should_pass/ecall/ecall_basic/src/main.sw → ...nguage/asm/instructions/ecall/src/main.sw
@@ -1,6 +1,6 @@
-script;
+library;
 
-fn main() {
+pub fn main() {
     asm(r1: 1u64, r2: 2u32, r3: 3u32, r4: 4u32) {
         ecal r1 r2 r3 r4;
     }

diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/ecall/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/instructions/ecall/test.toml
@@ -0,0 +1 @@
+category = "compile"