Merge pull request #873 from Y-Nak/name-resolution

Name resolution

README.md

@@ -57,15 +57,15 @@ Run `fe --help` to explore further options.
 
 The following is a simple contract implemented in Fe.
 
-```rust
+```fe
 struct Signed {
-    book_msg: String<100>
+    pub book_msg: String<100>
 }
 
 contract GuestBook {
     messages: Map<address, String<100>>
 
-    pub fn sign(self, ctx: Context, book_msg: String<100>) {
+    pub fn sign(mut self, mut ctx: Context, book_msg: String<100>) {
         self.messages[ctx.msg_sender()] = book_msg
         ctx.emit(Signed(book_msg: book_msg))
     }

crates/abi/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "fe-abi"
-version = "0.22.0"
+version = "0.23.0"
 authors = ["The Fe Developers <snakecharmers@ethereum.org>"]
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/ethereum/fe"
 
 [dependencies]
-fe-common = { path = "../common", version = "^0.22.0"}
+fe-common = { path = "../common", version = "^0.23.0"}
 serde = { version = "1.0", features = ["derive"] }
 
 [dev-dependencies]

crates/analyzer/Cargo.toml

@@ -1,16 +1,16 @@
 [package]
 name = "fe-analyzer"
-version = "0.22.0"
+version = "0.23.0"
 authors = ["The Fe Developers <snakecharmers@ethereum.org>"]
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/ethereum/fe"
 
 [dependencies]
 
-fe-common = {path = "../common", version = "^0.22.0"}
-fe-parser = {path = "../parser", version = "^0.22.0"}
-fe-library = {path = "../library", version = "^0.22.0"}
+fe-common = {path = "../common", version = "^0.23.0"}
+fe-parser = {path = "../parser", version = "^0.23.0"}
+fe-library = {path = "../library", version = "^0.23.0"}
 hex = "0.4"
 num-bigint = "0.4.3"
 num-traits = "0.2.14"

crates/analyzer/benches/bench.rs

@@ -1,6 +1,5 @@
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
-use fe_analyzer::namespace::items::ModuleId;
-use fe_analyzer::TestDb;
+use fe_analyzer::{namespace::items::ModuleId, TestDb};
 
 fn criterion_benchmark(c: &mut Criterion) {
     let path = "demos/uniswap.fe";

crates/analyzer/src/context.rs

@@ -5,33 +5,34 @@ use crate::{
     pattern_analysis::PatternMatrix,
 };
 
-use crate::namespace::items::{
-    ContractId, DiagnosticSink, FunctionId, FunctionSigId, Item, TraitId,
-};
-use crate::namespace::types::{Generic, SelfDecl, Type, TypeId};
-use crate::AnalyzerDb;
 use crate::{
     builtins::{ContractTypeMethod, GlobalFunction, Intrinsic, ValueMethod},
-    namespace::scopes::BlockScopeType,
-};
-use crate::{
     errors::{self, IncompleteItem, TypeError},
-    namespace::items::ModuleId,
+    namespace::{
+        items::{ContractId, DiagnosticSink, FunctionId, FunctionSigId, Item, ModuleId, TraitId},
+        scopes::BlockScopeType,
+        types::{Generic, SelfDecl, Type, TypeId},
+    },
+    AnalyzerDb,
 };
-use fe_common::diagnostics::Diagnostic;
 pub use fe_common::diagnostics::Label;
-use fe_common::Span;
-use fe_parser::ast;
-use fe_parser::node::{Node, NodeId};
+use fe_common::{diagnostics::Diagnostic, Span};
+use fe_parser::{
+    ast,
+    node::{Node, NodeId},
+};
 
 use indexmap::IndexMap;
 use num_bigint::BigInt;
 use smol_str::SmolStr;
-use std::fmt::{self, Debug};
-use std::hash::Hash;
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::{cell::RefCell, collections::HashMap};
+use std::{
+    cell::RefCell,
+    collections::HashMap,
+    fmt::{self, Debug},
+    hash::Hash,
+    marker::PhantomData,
+    rc::Rc,
+};
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub struct Analysis<T> {
@@ -222,7 +223,7 @@ pub trait AnalyzerContext {
 
     fn register_diag(&self, diag: Diagnostic) -> DiagnosticVoucher {
         self.add_diagnostic(diag);
-        DiagnosticVoucher(PhantomData::default())
+        DiagnosticVoucher(PhantomData)
     }
 }
 
@@ -313,7 +314,7 @@ pub struct DiagnosticVoucher(PhantomData<()>);
 
 impl DiagnosticVoucher {
     pub fn assume_the_parser_handled_it() -> Self {
-        Self(PhantomData::default())
+        Self(PhantomData)
     }
 }
 

crates/analyzer/src/db.rs

@@ -1,19 +1,19 @@
-use crate::namespace::items::{
-    self, AttributeId, ContractFieldId, ContractId, DepGraphWrapper, EnumVariantKind, FunctionId,
-    FunctionSigId, ImplId, IngotId, Item, ModuleConstantId, ModuleId, StructFieldId, StructId,
-    TraitId, TypeAliasId,
-};
-use crate::namespace::types::{self, Type, TypeId};
 use crate::{
     context::{Analysis, Constant, FunctionBody},
-    namespace::items::EnumId,
-};
-use crate::{
     errors::{ConstEvalError, TypeError},
-    namespace::items::EnumVariantId,
+    namespace::{
+        items::{
+            self, AttributeId, ContractFieldId, ContractId, DepGraphWrapper, EnumId, EnumVariantId,
+            EnumVariantKind, FunctionId, FunctionSigId, ImplId, IngotId, Item, ModuleConstantId,
+            ModuleId, StructFieldId, StructId, TraitId, TypeAliasId,
+        },
+        types::{self, Type, TypeId},
+    },
+};
+use fe_common::{
+    db::{SourceDb, SourceDbStorage, Upcast, UpcastMut},
+    SourceFileId, Span,
 };
-use fe_common::db::{SourceDb, SourceDbStorage, Upcast, UpcastMut};
-use fe_common::{SourceFileId, Span};
 use fe_parser::ast;
 use indexmap::map::IndexMap;
 use smol_str::SmolStr;

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

@@ -1,13 +1,17 @@
-use crate::context::AnalyzerContext;
-use crate::db::{Analysis, AnalyzerDb};
-use crate::errors;
-use crate::namespace::items::{
-    self, ContractFieldId, ContractId, DepGraph, DepGraphWrapper, DepLocality, FunctionId, Item,
-    TypeDef,
+use crate::{
+    context::AnalyzerContext,
+    db::{Analysis, AnalyzerDb},
+    errors,
+    namespace::{
+        items::{
+            self, ContractFieldId, ContractId, DepGraph, DepGraphWrapper, DepLocality, FunctionId,
+            Item, TypeDef,
+        },
+        scopes::ItemScope,
+        types::{self, Type},
+    },
+    traversal::types::type_desc,
 };
-use crate::namespace::scopes::ItemScope;
-use crate::namespace::types::{self, Type};
-use crate::traversal::types::type_desc;
 use fe_common::diagnostics::Label;
 use fe_parser::ast;
 use indexmap::map::{Entry, IndexMap};

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

@@ -1,21 +1,26 @@
-use crate::context::{AnalyzerContext, CallType, FunctionBody};
-use crate::db::{Analysis, AnalyzerDb};
-use crate::display::Displayable;
-use crate::errors::TypeError;
-use crate::namespace::items::{
-    DepGraph, DepGraphWrapper, DepLocality, FunctionId, FunctionSigId, Item, TypeDef,
+use crate::{
+    context::{AnalyzerContext, CallType, FunctionBody},
+    db::{Analysis, AnalyzerDb},
+    display::Displayable,
+    errors::TypeError,
+    namespace::{
+        items::{DepGraph, DepGraphWrapper, DepLocality, FunctionId, FunctionSigId, Item, TypeDef},
+        scopes::{BlockScope, BlockScopeType, FunctionScope, ItemScope},
+        types::{self, CtxDecl, Generic, SelfDecl, Type, TypeId},
+    },
+    traversal::{
+        functions::traverse_statements,
+        types::{type_desc, type_desc_to_trait},
+    },
 };
-use crate::namespace::scopes::{BlockScope, BlockScopeType, FunctionScope, ItemScope};
-use crate::namespace::types::{self, CtxDecl, Generic, SelfDecl, Type, TypeId};
-use crate::traversal::functions::traverse_statements;
-use crate::traversal::types::{type_desc, type_desc_to_trait};
 use fe_common::diagnostics::Label;
-use fe_parser::ast::{self, GenericParameter};
-use fe_parser::node::Node;
+use fe_parser::{
+    ast::{self, GenericParameter},
+    node::Node,
+};
 use if_chain::if_chain;
 use smol_str::SmolStr;
-use std::collections::HashMap;
-use std::rc::Rc;
+use std::{collections::HashMap, rc::Rc};
 
 /// Gather context information for a function definition and check for type
 /// errors. Does not inspect the function body.
@@ -131,6 +136,14 @@ pub fn function_signature(
                 });
 
                 if let Some(context_type) = scope.get_context_type() {
+                    if arg.name() == "ctx" &&  typ.as_ref().map(|val| val.deref(db)) != Ok(context_type) {
+                        scope.error(
+                            "`ctx` is reserved for instances of `Context`",
+                            arg.span,
+                            "`ctx` must be an instance of `Context`",
+                        );
+                    };
+
                     if typ.as_ref().map(|val| val.deref(db)) == Ok(context_type) {
                         if arg.name() != "ctx" {
                             scope.error(

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

@@ -1,11 +1,14 @@
-use indexmap::map::Entry;
-use indexmap::IndexMap;
+use indexmap::{map::Entry, IndexMap};
 use smol_str::SmolStr;
 
-use crate::context::{Analysis, AnalyzerContext};
-use crate::namespace::items::{Function, FunctionId, ImplId, Item};
-use crate::namespace::scopes::ItemScope;
-use crate::AnalyzerDb;
+use crate::{
+    context::{Analysis, AnalyzerContext},
+    namespace::{
+        items::{Function, FunctionId, ImplId, Item},
+        scopes::ItemScope,
+    },
+    AnalyzerDb,
+};
 use std::rc::Rc;
 
 pub fn impl_all_functions(db: &dyn AnalyzerDb, impl_: ImplId) -> Rc<[FunctionId]> {

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

@@ -181,23 +181,33 @@ pub fn module_item_map(
             if function.is_test(db) {
                 if !sig_ast.generic_params.kind.is_empty() {
                     diagnostics.push(errors::fancy_error(
-                        "generic function parameters are not supported on test functions",
+                        "generic parameters are not supported on test functions",
                         vec![Label::primary(
                             sig_ast.generic_params.span,
-                            "this cannot appear here",
+                            "invalid generic parameters",
                         )],
                         vec!["Hint: remove the generic parameters".into()],
                     ));
                 }
 
-                if !sig_ast.args.is_empty() {
-                    let span =
-                        sig_ast.args.first().unwrap().span + sig_ast.args.last().unwrap().span;
-                    diagnostics.push(errors::fancy_error(
-                        "function parameters are not supported on test functions",
-                        vec![Label::primary(span, "this cannot appear here")],
-                        vec!["Hint: remove the parameters".into()],
-                    ));
+                if let Some(arg) = sig_ast.args.first() {
+                    if arg.name() != "ctx" {
+                        diagnostics.push(errors::fancy_error(
+                            "function parameters other than `ctx` are not supported on test functions",
+                            vec![Label::primary(arg.span, "invalid function parameter")],
+                            vec!["Hint: remove the parameter".into()],
+                        ));
+                    }
+                }
+
+                for arg in sig_ast.args.iter().skip(1) {
+                    if arg.name() != "ctx" {
+                        diagnostics.push(errors::fancy_error(
+                            "function parameters other than `ctx` are not supported on test functions",
+                            vec![Label::primary(arg.span, "invalid function parameter")],
+                            vec!["Hint: remove the parameter".into()],
+                        ));
+                    }
                 }
             }
         }

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

@@ -1,22 +1,25 @@
-use crate::builtins;
-use crate::constants::MAX_INDEXED_EVENT_FIELDS;
-use crate::context::AnalyzerContext;
-use crate::db::Analysis;
-use crate::errors::TypeError;
-use crate::namespace::items::{
-    self, DepGraph, DepGraphWrapper, DepLocality, FunctionId, Item, StructField, StructFieldId,
-    StructId, TypeDef,
+use crate::{
+    builtins,
+    constants::MAX_INDEXED_EVENT_FIELDS,
+    context::AnalyzerContext,
+    db::Analysis,
+    errors::TypeError,
+    namespace::{
+        items::{
+            self, DepGraph, DepGraphWrapper, DepLocality, FunctionId, Item, StructField,
+            StructFieldId, StructId, TypeDef,
+        },
+        scopes::ItemScope,
+        types::{Type, TypeId},
+    },
+    traversal::types::type_desc,
+    AnalyzerDb,
 };
-use crate::namespace::scopes::ItemScope;
-use crate::namespace::types::{Type, TypeId};
-use crate::traversal::types::type_desc;
-use crate::AnalyzerDb;
 use fe_common::utils::humanize::pluralize_conditionally;
 use fe_parser::{ast, Label};
 use indexmap::map::{Entry, IndexMap};
 use smol_str::SmolStr;
-use std::rc::Rc;
-use std::str::FromStr;
+use std::{rc::Rc, str::FromStr};
 
 pub fn struct_all_fields(db: &dyn AnalyzerDb, struct_: StructId) -> Rc<[StructFieldId]> {
     struct_

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

@@ -1,12 +1,15 @@
-use indexmap::map::Entry;
-use indexmap::IndexMap;
+use indexmap::{map::Entry, IndexMap};
 use smol_str::SmolStr;
 
-use crate::context::{Analysis, AnalyzerContext};
-use crate::namespace::items::{FunctionSig, FunctionSigId, Item, TraitId};
-use crate::namespace::scopes::ItemScope;
-use crate::namespace::types::TypeId;
-use crate::AnalyzerDb;
+use crate::{
+    context::{Analysis, AnalyzerContext},
+    namespace::{
+        items::{FunctionSig, FunctionSigId, Item, TraitId},
+        scopes::ItemScope,
+        types::TypeId,
+    },
+    AnalyzerDb,
+};
 use std::rc::Rc;
 
 pub fn trait_all_functions(db: &dyn AnalyzerDb, trait_: TraitId) -> Rc<[FunctionSigId]> {