Merge branch 'master' into josh/remove_forc_explore

Author: IGI-111

docs/book/src/reference/compiler_intrinsics.md

@@ -120,7 +120,7 @@ __addr_of<T>(val: T) -> raw_ptr
 
 **Description:** Returns the address in memory where `val` is stored.
 
-**Constraints:** `T` is a reference type.
+**Constraints:** None.
 
 ---
 

sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs

@@ -1021,7 +1021,6 @@ fn type_check_gtf(
 
 /// Signature: `__addr_of<T>(val: T) -> raw_ptr`
 /// Description: Returns the address in memory where `val` is stored.
-/// Constraints: `T` is a reference type.
 fn type_check_addr_of(
     handler: &Handler,
     ctx: TypeCheckContext,
@@ -1042,18 +1041,6 @@ fn type_check_addr_of(
         .with_help_text("")
         .with_type_annotation(type_engine.new_unknown());
     let exp = ty::TyExpression::type_check(handler, ctx, &arguments[0])?;
-    let copy_type_info = type_engine
-        .to_typeinfo(exp.return_type, &span)
-        .map_err(|e| handler.emit_err(e.into()))
-        .unwrap_or_else(TypeInfo::ErrorRecovery);
-    if copy_type_info.is_copy_type() {
-        return Err(handler.emit_err(CompileError::IntrinsicUnsupportedArgType {
-            name: kind.to_string(),
-            span,
-            hint: "Only a reference type can be used as argument here".to_string(),
-        }));
-    }
-
     let intrinsic_function = ty::TyIntrinsicFunctionKind {
         kind,
         arguments: vec![exp],

test/src/e2e_vm_tests/test_programs/should_fail/addrof_intrinsic/Forc.lock

@@ -1,13 +1,8 @@
 [[package]]
-name = 'addrof_intrinsic'
-source = 'member'
-dependencies = ['std']
+name = "addrof_intrinsic"
+source = "member"
+dependencies = ["std"]
 
 [[package]]
-name = 'core'
-source = 'path+from-root-B3EAB3022B5FAD04'
-
-[[package]]
-name = 'std'
-source = 'path+from-root-B3EAB3022B5FAD04'
-dependencies = ['core']
+name = "std"
+source = "path+from-root-B3EAB3022B5FAD04"

test/src/e2e_vm_tests/test_programs/should_fail/addrof_intrinsic/Forc.toml

@@ -0,0 +1,24 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "errorCodes": {},
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1.1"
+}

test/src/e2e_vm_tests/test_programs/should_fail/addrof_intrinsic/json_abi_oracle.json

@@ -1,13 +1,6 @@
 script;
 
-const B1 = Address {
-    value: 0x0100000000000000000000000000000000000000000000000000000000000010
-};
-
-pub fn addr_of<T>(val: T) -> raw_ptr {
-    if !__is_reference_type::<T>() {
-        revert(0);
-    }
+pub fn as_raw_ptr<T>(val: &T) -> raw_ptr {
     asm(ptr: val) {
         ptr: raw_ptr
     }
@@ -18,21 +11,158 @@ enum X {
      B: u64,
 }
 
-fn main() {
-    let sender = Identity::Address(B1);
-    assert (__addr_of(sender) == addr_of(sender));
+struct Y {
+    a: u32,
+    b: u64,
+}
+
+const A_U256: u256 = 0x0;
+const B_U256: u256 = 0x1;
+
+const A_U32: u32 = 0;
+const B_U32: u32 = 1;
+
+const A_BOOL: bool = true;
+const B_BOOL: bool = false;
+
+const A_U64: u64 = 0;
+const B_U64: u64 = 1;
+
+const A_X: X = X::A(0);
+const B_X: X = X::B(1);
 
+const A_Y: Y = Y { a: 0, b: 1 };
+const B_Y: Y = Y { a: 1, b: 2 };
+
+fn main() {
     let x = X::A(2);
     let y = X::B(22);
-    assert(__addr_of(x) == addr_of(x));
-    assert(__addr_of(x) != addr_of(y));
+    assert(__addr_of(x) == as_raw_ptr(&x));
+    assert(__addr_of(x) != as_raw_ptr(&y));
+
+    let y = Y { a: 2, b: 22 };
+    let z = Y { a: 3, b: 23 };
+    assert(__addr_of(y) == as_raw_ptr(&y));
+    assert(__addr_of(y) != as_raw_ptr(&z));
+
+    let addr_y_a = __addr_of(y.a);
+    let addr_y_b = __addr_of(y.b);
+    assert(addr_y_a == as_raw_ptr(&y.a));
+    assert(addr_y_b == as_raw_ptr(&y.b));
+    assert(addr_y_a != addr_y_b);
 
     let a = [1,2,3];
-    assert(__addr_of(a) == addr_of(a));
+    assert(__addr_of(a) == as_raw_ptr(&a));
 
     let b = "hello";
-    assert(__addr_of(b) == addr_of(b));
+    assert(__addr_of(b) == as_raw_ptr(&b));
 
     let c = (1, 2);
-    assert(__addr_of(c) == addr_of(c));
+    assert(__addr_of(c) == as_raw_ptr(&c));
+
+    let i1 = 42u64;
+    let i2 = 43u64;
+    assert(__addr_of(i1) == as_raw_ptr(&i1));
+    assert(__addr_of(i1) != as_raw_ptr(&i2));
+
+    let b1 = true;
+    let b2 = false;
+    assert(__addr_of(b1) == as_raw_ptr(&b1));
+    assert(__addr_of(b1) != as_raw_ptr(&b2));
+
+    let u8_1 = 8u8;
+    let u8_2 = 9u8;
+    assert(__addr_of(u8_1) == as_raw_ptr(&u8_1));
+    assert(__addr_of(u8_1) != as_raw_ptr(&u8_2));
+
+    let u256_1: u256 = 0x0000000000000000000000000000000000000000000000000000000000000001u256;
+    let u256_2: u256 = 0x0000000000000000000000000000000000000000000000000000000000000002u256;
+    assert(__addr_of(u256_1) == as_raw_ptr(&u256_1));
+    assert(__addr_of(u256_1) != as_raw_ptr(&u256_2));
+
+    let addr_addr_of = __addr_of(__addr_of(x));
+    assert (!addr_addr_of.is_null());
+    assert(__addr_of(__addr_of(x)) != __addr_of(x));
+
+    let some_temp = __addr_of(1 + 4);
+    assert(!some_temp.is_null());
+
+    let raw_ptr = __addr_of(x);
+    assert(!raw_ptr.is_null());
+
+    const X1: u32 = 42;
+    const Y1: u32 = 43;
+    assert(__addr_of(X1) == as_raw_ptr(&X1));
+    assert(__addr_of(X1) != as_raw_ptr(&Y1)); 
+    assert(__addr_of(X1) != __addr_of(Y1));
+
+    const X2: u64 = 42;
+    const Y2: u64 = 43;
+    assert(__addr_of(X2) == as_raw_ptr(&X2)); 
+    assert(__addr_of(X2) != as_raw_ptr(&Y2));
+    assert(__addr_of(X2) != __addr_of(Y2));
+
+    const X3: u256 = 42u256;
+    const Y3: u256 = 43u256;
+    assert(__addr_of(X3) == as_raw_ptr(&X3));
+    assert(__addr_of(X3) != as_raw_ptr(&Y3));
+    assert(__addr_of(X3) != __addr_of(Y3));
+    
+    const X4: bool = true;
+    const Y4: bool = false;
+    assert(__addr_of(X4) == as_raw_ptr(&X4));
+    assert(__addr_of(X4) != as_raw_ptr(&Y4));
+    assert(__addr_of(X4) != __addr_of(Y4));
+
+    const X5: X = X::A(42);
+    const Y5: X = X::B(43);
+    assert(__addr_of(X5) == as_raw_ptr(&X5));
+    assert(__addr_of(X5) != as_raw_ptr(&Y5));
+    assert(__addr_of(X5) != __addr_of(Y5));
+
+    const X6: Y = Y { a: 42, b: 43 };
+    const Y6: Y = Y { a: 44, b: 45 };
+    assert(__addr_of(X6) == as_raw_ptr(&X6));
+    assert(__addr_of(X6) != as_raw_ptr(&Y6));
+    assert(__addr_of(X6) != __addr_of(Y6));
+
+    const X7: [u32; 3] = [1, 2, 3];
+    const Y7: [u32; 3] = [4, 5, 6];
+    assert(__addr_of(X7) == as_raw_ptr(&X7));
+    assert(__addr_of(X7) != as_raw_ptr(&Y7));
+
+    const X8: (u32, u32) = (1, 2);
+    const Y8: (u32, u32) = (3, 4);
+    assert(__addr_of(X8) == as_raw_ptr(&X8));
+    assert(__addr_of(X8) != as_raw_ptr(&Y8));
+
+    const X10: u8 = 8;
+    const Y10: u8 = 9;
+    assert(__addr_of(X10) == as_raw_ptr(&X10));
+    assert(__addr_of(X10) != as_raw_ptr(&Y10));
+
+    assert(__addr_of(A_U256) == as_raw_ptr(&A_U256));
+    assert(__addr_of(B_U256) == as_raw_ptr(&B_U256));
+    assert(__addr_of(A_U256) != __addr_of(B_U256));
+
+    assert(__addr_of(A_U32) == as_raw_ptr(&A_U32));
+    assert(__addr_of(B_U32) == as_raw_ptr(&B_U32));
+    assert(__addr_of(A_U32) != __addr_of(B_U32));
+    assert(__addr_of(A_U32) != __addr_of(A_U256));
+
+    assert(__addr_of(A_BOOL) == as_raw_ptr(&A_BOOL));
+    assert(__addr_of(B_BOOL) == as_raw_ptr(&B_BOOL));
+    assert(__addr_of(A_BOOL) != __addr_of(B_BOOL));
+
+    assert(__addr_of(A_U64) == as_raw_ptr(&A_U64));
+    assert(__addr_of(B_U64) == as_raw_ptr(&B_U64));
+    assert(__addr_of(A_U64) != __addr_of(B_U64));
+
+    assert(__addr_of(A_X) == as_raw_ptr(&A_X));
+    assert(__addr_of(B_X) == as_raw_ptr(&B_X));
+    assert(__addr_of(A_X) != __addr_of(B_X));
+
+    assert(__addr_of(A_Y) == as_raw_ptr(&A_Y));
+    assert(__addr_of(B_Y) == as_raw_ptr(&B_Y));
+    assert(__addr_of(A_Y) != __addr_of(B_Y));
 }