Basic mut enforcement, remove .clone() function

crates/analyzer/src/builtins.rs

@@ -4,7 +4,6 @@ use strum::{AsRefStr, EnumIter, EnumString};
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, EnumString, AsRefStr)]
 #[strum(serialize_all = "snake_case")]
 pub enum ValueMethod {
-    Clone,
     ToMem,
     AbiEncode,
 }

crates/analyzer/src/context.rs

@@ -146,6 +146,7 @@ pub trait AnalyzerContext {
     /// Panics if a context is not in a function. Use [`Self::is_in_function`]
     /// to determine whether a context is in a function.
     fn add_call(&self, node: &Node<ast::Expr>, call_type: CallType);
+    fn get_call(&self, node: &Node<ast::Expr>) -> Option<CallType>;
 
     /// Returns `true` if the context is in function scope.
     fn is_in_function(&self) -> bool;
@@ -362,6 +363,10 @@ impl AnalyzerContext for TempContext {
         panic!("TempContext can't add call");
     }
 
+    fn get_call(&self, _node: &Node<ast::Expr>) -> Option<CallType> {
+        panic!("TempContext can't have calls");
+    }
+
     fn is_in_function(&self) -> bool {
         false
     }
@@ -419,8 +424,9 @@ pub struct Adjustment {
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum AdjustmentKind {
-    FromStorage,
-    // DeMut,
+    Copy,
+    /// Load from storage ptr
+    Load,
     IntSizeIncrease,
     StringSizeIncrease,
 }
@@ -447,7 +453,7 @@ impl crate::display::DisplayWithDb for ExpressionAttributes {
             write!(f, " = {:?}", val)?;
         }
         for adj in type_adjustments {
-            write!(f, " -> {}", adj.into.display(db))?;
+            write!(f, " -{:?}-> {}", adj.kind, adj.into.display(db))?;
         }
         Ok(())
     }

crates/analyzer/src/db/queries/functions.rs

@@ -85,15 +85,15 @@ pub fn function_signature(
         .iter()
         .enumerate()
         .filter_map(|(index, arg)| match &arg.kind {
-            ast::FunctionArg::Self_ { .. }=> {
+            ast::FunctionArg::Self_ { mut_ }=> {
                 if matches!(fn_parent, Item::Module(_)) {
                     scope.error(
                         "`self` can only be used in contract, struct, trait or impl functions",
                         arg.span,
                         "not allowed in functions defined directly in a module",
                     );
                 } else {
-                    self_decl = Some(SelfDecl::Mutable);
+                    self_decl = Some(SelfDecl { span: arg.span, mut_: *mut_ });
                     if index != 0 {
                         scope.error(
                             "`self` is not the first parameter",
@@ -104,9 +104,15 @@ pub fn function_signature(
                 }
                 None
             }
-            ast::FunctionArg::Regular { mut_: _, label, name, typ: typedesc } => {
-                let typ = resolve_function_param_type(db, function, &mut scope, &typedesc).and_then(|typ| match typ {
-                    typ if typ.has_fixed_size(db) => Ok(typ),
+            ast::FunctionArg::Regular { mut_, label, name, typ: typedesc } => {
+                let typ = resolve_function_param_type(db, function, &mut scope, typedesc).and_then(|typ| match typ {
+                    typ if typ.has_fixed_size(db) => {
+                        if mut_.is_some() {
+                            Ok(Type::Mut(typ).id(db))
+                        } else {
+                            Ok(typ)
+                        }
+                    }
                     _ => Err(TypeError::new(scope.error(
                         "function parameter types must have fixed size",
                         typedesc.span,
@@ -177,6 +183,7 @@ pub fn function_signature(
                     None
                 } else {
                     names.insert(&name.kind, index);
+
                     Some(types::FunctionParam::new(
                         label.as_ref().map(|s| s.kind.as_str()),
                         &name.kind,
@@ -229,7 +236,7 @@ pub fn function_signature(
     }
 }
 
-pub fn resolve_function_param_type(
+fn resolve_function_param_type(
     db: &dyn AnalyzerDb,
     function: FunctionSigId,
     context: &mut dyn AnalyzerContext,

crates/analyzer/src/namespace/scopes.rs

@@ -98,6 +98,9 @@ impl<'a> AnalyzerContext for ItemScope<'a> {
     fn add_call(&self, _node: &Node<ast::Expr>, _call_type: CallType) {
         unreachable!("Can't call function outside of function")
     }
+    fn get_call(&self, _node: &Node<ast::Expr>) -> Option<CallType> {
+        unreachable!("Can't call function outside of function")
+    }
 
     fn is_in_function(&self) -> bool {
         false
@@ -285,14 +288,16 @@ impl<'a> AnalyzerContext for FunctionScope<'a> {
 
     fn add_call(&self, node: &Node<ast::Expr>, call_type: CallType) {
         // TODO: should probably take the Expr::Call node, rather than the function node
-
         self.add_node(node);
         self.body
             .borrow_mut()
             .calls
             .insert(node.id, call_type)
             .expect_none("call attributes already exist");
     }
+    fn get_call(&self, node: &Node<ast::Expr>) -> Option<CallType> {
+        self.body.borrow().calls.get(&node.id).cloned()
+    }
 
     fn is_in_function(&self) -> bool {
         true
@@ -509,6 +514,10 @@ impl AnalyzerContext for BlockScope<'_, '_> {
         self.root.add_call(node, call_type)
     }
 
+    fn get_call(&self, node: &Node<ast::Expr>) -> Option<CallType> {
+        self.root.get_call(node)
+    }
+
     fn is_in_function(&self) -> bool {
         true
     }

crates/analyzer/src/namespace/types.rs

@@ -86,6 +86,7 @@ impl TypeId {
     pub fn deref(self, db: &dyn AnalyzerDb) -> TypeId {
         match self.typ(db) {
             Type::SPtr(inner) => inner,
+            Type::Mut(inner) => inner.deref(db),
             _ => self,
         }
     }
@@ -96,6 +97,11 @@ impl TypeId {
     pub fn has_fixed_size(&self, db: &dyn AnalyzerDb) -> bool {
         self.typ(db).has_fixed_size(db)
     }
+
+    /// `true` if Type::Base or Type::Contract (which is just an Address)
+    pub fn is_primitive(&self, db: &dyn AnalyzerDb) -> bool {
+        matches!(self.typ(db), Type::Base(_) | Type::Contract(_))
+    }
     pub fn is_base(&self, db: &dyn AnalyzerDb) -> bool {
         matches!(self.typ(db), Type::Base(_))
     }
@@ -125,7 +131,18 @@ impl TypeId {
         matches!(self.typ(db), Type::Struct(_))
     }
     pub fn is_sptr(&self, db: &dyn AnalyzerDb) -> bool {
-        matches!(self.typ(db), Type::SPtr(_))
+        match self.typ(db) {
+            Type::SPtr(_) => true,
+            Type::Mut(inner) => inner.is_sptr(db),
+            _ => false,
+        }
+    }
+    pub fn is_generic(&self, db: &dyn AnalyzerDb) -> bool {
+        matches!(self.deref(db).typ(db), Type::Generic(_))
+    }
+
+    pub fn is_mut(&self, db: &dyn AnalyzerDb) -> bool {
+        matches!(self.typ(db), Type::Mut(_))
     }
 
     pub fn name(&self, db: &dyn AnalyzerDb) -> SmolStr {
@@ -305,9 +322,15 @@ pub struct FunctionSignature {
     pub return_type: Result<TypeId, TypeError>,
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Ord, Eq, Hash)]
-pub enum SelfDecl {
-    Mutable,
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct SelfDecl {
+    pub span: Span,
+    pub mut_: Option<Span>,
+}
+impl SelfDecl {
+    pub fn is_mut(&self) -> bool {
+        self.mut_.is_some()
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -718,9 +741,13 @@ impl DisplayWithDb for FunctionSignature {
             return_type,
         } = self;
 
-        write!(f, "self: {:?}, ", self_decl)?;
         write!(f, "params: [")?;
         let mut delim = "";
+        if let Some(s) = self_decl {
+            write!(f, "{}self", if s.mut_.is_some() { "mut " } else { "" },)?;
+            delim = ", ";
+        }
+
         for p in params {
             write!(
                 f,

crates/analyzer/src/operations.rs

@@ -1,6 +1,7 @@
 use crate::context::AnalyzerContext;
 use crate::errors::{BinaryOperationError, IndexingError};
 use crate::namespace::types::{Array, Integer, Map, Type, TypeDowncast, TypeId};
+
 use crate::traversal::types::{deref_type, try_coerce_type};
 use fe_parser::{ast as fe, node::Node};
 
@@ -56,7 +57,7 @@ fn index_array(
     index_expr: &Node<fe::Expr>,
 ) -> Result<TypeId, IndexingError> {
     let u256 = Type::u256().id(context.db());
-    if try_coerce_type(context, Some(index_expr), index, u256).is_err() {
+    if try_coerce_type(context, Some(index_expr), index, u256, false).is_err() {
         return Err(IndexingError::WrongIndexType);
     }
 
@@ -70,7 +71,8 @@ fn index_map(
     index_expr: &Node<fe::Expr>,
 ) -> Result<TypeId, IndexingError> {
     let Map { key, value } = map;
-    if try_coerce_type(context, Some(index_expr), index, *key).is_err() {
+
+    if try_coerce_type(context, Some(index_expr), index, *key, false).is_err() {
         return Err(IndexingError::WrongIndexType);
     }
     Ok(*value)
@@ -120,7 +122,7 @@ fn bin_arithmetic(
 ) -> Result<TypeId, BinaryOperationError> {
     // For now, we require that the types be numeric, have the same signedness,
     // and that left.size() >= right.size(). (The rules imposed by try_coerce_type)
-    if try_coerce_type(context, Some(right_expr), right, left).is_ok() {
+    if try_coerce_type(context, Some(right_expr), right, left, false).is_ok() {
         // TODO: loosen up arightmetic type rules.
         // The rules should be:
         // - Any combination of numeric types can be operated on.