Add support for fixed-size arrays in the binder (#1518)

This PR adds a new type in the binder's `TypeRegistry` for fixed-size
arrays. It also implements a basic compile-time constant evaluator to be
able to compute the size of fixed-size arrays declared. This
implementation only supports integers at the moment.

Author: ggiraldez

Cargo.lock

@@ -142,7 +142,9 @@ logos = { version = "0.16.0" }
 lsp-positions = { version = "0.3.0" } 
 markdown = { version = "0.3.0" }
 nom = { version = "7.1.3" }
+num-bigint = { version = "0.4.6" }
 num-format = { version = "0.4.4" }
+num-traits = { version = "0.2.18" }
 paste = { version = "1.0.15" }
 proc-macro2 = { version = "1.0.94" }
 public-api = { version = "0.47.1" }

Cargo.toml

@@ -27,7 +27,13 @@ categories = [
 [features]
 default = []
 __private_ariadne_errors = ["dep:ariadne"]
-__private_backend_api = ["dep:indexmap", "dep:paste", "dep:sha3"]
+__private_backend_api = [
+  "dep:indexmap",
+  "dep:paste",
+  "dep:num-bigint",
+  "dep:num-traits",
+  "dep:sha3",
+]
 __private_wasm_apis = []
 __private_testing_utils = ["metaslang_bindings/__private_testing_utils"]
 
@@ -36,6 +42,8 @@ ariadne = { workspace = true, optional = true }
 indexmap = { workspace = true, optional = true }
 metaslang_bindings = { workspace = true }
 metaslang_cst = { workspace = true }
+num-bigint = { workspace = true, optional = true }
+num-traits = { workspace = true, optional = true }
 paste = { workspace = true, optional = true }
 semver = { workspace = true }
 serde = { workspace = true }

crates/solidity/outputs/cargo/crate/Cargo.toml

@@ -102,7 +102,7 @@ impl ContractDefinitionStruct {
 
             // check if we can pack the variable in the previous slot
             let remaining_bytes = SemanticAnalysis::SLOT_SIZE - (ptr % SemanticAnalysis::SLOT_SIZE);
-            if variable_size > remaining_bytes {
+            if remaining_bytes < SemanticAnalysis::SLOT_SIZE && variable_size > remaining_bytes {
                 ptr += remaining_bytes;
             }
 

crates/solidity/outputs/cargo/crate/src/backend/abi/mod.rs

@@ -39,6 +39,7 @@ pub enum Definition {
 #[derive(Debug)]
 pub struct ConstantDefinition {
     pub(crate) ir_node: output_ir::ConstantDefinition,
+    pub scope_id: ScopeId,
 }
 
 #[derive(Debug)]
@@ -301,9 +302,12 @@ impl Definition {
         }
     }
 
-    pub(crate) fn new_constant(ir_node: &output_ir::ConstantDefinition) -> Self {
+    pub(crate) fn new_constant(ir_node: &output_ir::ConstantDefinition, scope_id: ScopeId) -> Self {
+        // for constants we store the scope_id where it's defined to use for
+        // evaluation of compile-time constants (eg. fixed arrays size)
         Self::Constant(ConstantDefinition {
             ir_node: Rc::clone(ir_node),
+            scope_id,
         })
     }
 

crates/solidity/outputs/cargo/crate/src/backend/binder/definitions.rs

@@ -562,6 +562,10 @@ impl<'a> BuiltInsResolver<'a> {
             }
             Type::Enum { .. } => None,
             Type::FixedPointNumber { .. } => None,
+            Type::FixedSizeArray { .. } => match symbol {
+                "length" => Some(BuiltIn::Length),
+                _ => None,
+            },
             Type::Function(FunctionType { external, .. }) => {
                 // Solidity < 0.5.0 didn't require explicit visibility attributes
                 if *external || self.language_version < VERSION_0_5_0 {

crates/solidity/outputs/cargo/crate/src/backend/built_ins.rs

@@ -16,6 +16,7 @@ pub enum Type {
     Bytes(BytesType),
     Contract(ContractType),
     Enum(EnumType),
+    FixedSizeArray(FixedSizeArrayType),
     FixedPointNumber(FixedPointNumberType),
     Function(FunctionType),
     Integer(IntegerType),
@@ -55,6 +56,7 @@ define_type_variant!(ByteArray);
 define_type_variant!(Bytes);
 define_type_variant!(Contract);
 define_type_variant!(Enum);
+define_type_variant!(FixedSizeArray);
 define_type_variant!(FixedPointNumber);
 define_type_variant!(Function);
 define_type_variant!(Integer);
@@ -79,6 +81,9 @@ impl Type {
             types::Type::Bytes { .. } => Self::Bytes(BytesType { type_id, semantic }),
             types::Type::Contract { .. } => Self::Contract(ContractType { type_id, semantic }),
             types::Type::Enum { .. } => Self::Enum(EnumType { type_id, semantic }),
+            types::Type::FixedSizeArray { .. } => {
+                Self::FixedSizeArray(FixedSizeArrayType { type_id, semantic })
+            }
             types::Type::FixedPointNumber { .. } => {
                 Self::FixedPointNumber(FixedPointNumberType { type_id, semantic })
             }
@@ -106,6 +111,7 @@ impl Type {
             Type::Bytes(details) => details.type_id,
             Type::Contract(details) => details.type_id,
             Type::Enum(details) => details.type_id,
+            Type::FixedSizeArray(details) => details.type_id,
             Type::FixedPointNumber(details) => details.type_id,
             Type::Function(details) => details.type_id,
             Type::Integer(details) => details.type_id,
@@ -183,6 +189,27 @@ impl EnumType {
     }
 }
 
+impl FixedSizeArrayType {
+    pub fn element_type(&self) -> Type {
+        let types::Type::FixedSizeArray { element_type, .. } = self.internal_type() else {
+            unreachable!("invalid fixed-size array type");
+        };
+        Type::create(*element_type, &self.semantic)
+    }
+    pub fn location(&self) -> DataLocation {
+        let types::Type::FixedSizeArray { location, .. } = self.internal_type() else {
+            unreachable!("invalid fixed-size array type");
+        };
+        *location
+    }
+    pub fn size(&self) -> usize {
+        let types::Type::FixedSizeArray { size, .. } = self.internal_type() else {
+            unreachable!("invalid fixed-size array type");
+        };
+        *size
+    }
+}
+
 impl FixedPointNumberType {
     pub fn signed(&self) -> bool {
         let types::Type::FixedPointNumber { signed, .. } = self.internal_type() else {

crates/solidity/outputs/cargo/crate/src/backend/ir/ast/node_extensions/types.rs

@@ -18,6 +18,18 @@ pub fn run_file(language_version: &Version, source_unit: &input::SourceUnit) ->
     pass.transform_source_unit(source_unit)
 }
 
+// We need this entry point to test the compile-time constant evaluator
+#[cfg(test)]
+pub(crate) fn transform_expression(
+    language_version: &Version,
+    expression: &input::Expression,
+) -> output::Expression {
+    let mut pass = Pass {
+        language_version: language_version.clone(),
+    };
+    pass.transform_expression(expression)
+}
+
 struct Pass {
     language_version: Version,
 }

crates/solidity/outputs/cargo/crate/src/backend/passes/p1_flatten_contracts.rs

@@ -416,7 +416,7 @@ impl Visitor for Pass<'_> {
     }
 
     fn enter_constant_definition(&mut self, node: &input_ir::ConstantDefinition) -> bool {
-        let definition = Definition::new_constant(node);
+        let definition = Definition::new_constant(node, self.current_scope_id());
         self.insert_definition_in_current_scope(definition);
 
         false