builtin contract creation on ctx

crates/analyzer/src/builtins.rs

@@ -7,6 +7,7 @@ pub enum ValueMethod {
     Clone,
     ToMem,
     AbiEncode,
+    Create,
 }
 
 #[derive(

crates/analyzer/src/traversal/expressions.rs

@@ -1349,6 +1349,7 @@ fn expr_call_method(
             target,
             method,
             field,
+            generic_args,
             args,
         );
     }
@@ -1468,6 +1469,7 @@ fn expr_call_builtin_value_method(
     value: &Node<fe::Expr>,
     method: ValueMethod,
     method_name: &Node<SmolStr>,
+    generic_args: &Option<Node<Vec<fe::GenericArg>>>,
     args: &Node<Vec<Node<fe::CallArg>>>,
 ) -> Result<(ExpressionAttributes, CallType), FatalError> {
     // for now all of these functions expect 0 arguments
@@ -1603,6 +1605,10 @@ fn expr_call_builtin_value_method(
                 ],
             ))),
         },
+        ValueMethod::Create => {
+            // temp
+            Ok((value_attrs.into_cloned(), calltype))
+        }
     }
 }
 

crates/test-files/fixtures/features/create_contract.fe

@@ -6,5 +6,5 @@ contract Foo:
 
 contract FooFactory:
     pub fn create_foo(ctx: Context) -> address:
-        let foo: Foo = Foo.create(ctx, 0)
+        let foo: Foo = ctx.create<Foo>((), 0)
         return address(foo)

crates/yulgen/src/mappers/expressions.rs

@@ -5,7 +5,7 @@ use crate::operations::{
     math as math_operations, structs as struct_operations,
 };
 use crate::types::{AsAbiType, EvmSized};
-use fe_analyzer::builtins::{self, ContractTypeMethod, GlobalFunction};
+use fe_analyzer::builtins::{self, ContractTypeMethod, GlobalFunction, ValueMethod};
 use fe_analyzer::context::{CallType, Location};
 use fe_analyzer::namespace::items::Class;
 use fe_analyzer::namespace::types::{Base, FixedSize, Type};
@@ -126,6 +126,13 @@ fn expr_call(context: &mut FnContext, exp: &Node<fe::Expr>) -> yul::Expression {
                     ),
                     _ => panic!("invalid attributes"),
                 },
+                builtins::ValueMethod::Create => {
+                    contract_operations::create2(
+                        &contract_name,
+                        yul_args[1].clone(),
+                        yul_args[2].clone(),
+                    )
+                }
             }
         }
         CallType::TypeConstructor(Type::Struct(val)) => {
@@ -149,11 +156,7 @@ fn expr_call(context: &mut FnContext, exp: &Node<fe::Expr>) -> yul::Expression {
         CallType::BuiltinAssociatedFunction { contract, function } => {
             let contract_name = contract.name(context.adb);
             match function {
-                ContractTypeMethod::Create2 => contract_operations::create2(
-                    &contract_name,
-                    yul_args[1].clone(),
-                    yul_args[2].clone(),
-                ),
+                ContractTypeMethod::Create2 => ,
                 ContractTypeMethod::Create => {
                     contract_operations::create(&contract_name, yul_args[0].clone())
                 }