Basic mathematical stdlib functionality

core_lang/src/semantic_analysis/ast_node/declaration.rs

@@ -411,3 +411,24 @@ impl<'sc> TypedFunctionDeclaration<'sc> {
         )
     }
 }
+
+impl<'sc> TypedTraitFn<'sc> {
+    /// This function is used in trait declarations to insert "placeholder" functions
+    /// in the methods. This allows the methods to use functions declared in the
+    /// interface surface.
+    pub(crate) fn to_dummy_func(&self) -> TypedFunctionDeclaration<'sc> {
+        TypedFunctionDeclaration {
+            name: self.name.clone(),
+            body: TypedCodeBlock {
+                contents: vec![],
+                whole_block_span: self.name.span.clone(),
+            },
+            parameters: vec![],
+            span: self.name.span.clone(),
+            return_type: self.return_type.clone(),
+            return_type_span: self.return_type_span.clone(),
+            visibility: Visibility::Public,
+            type_parameters: vec![],
+        }
+    }
+}

core_lang/src/semantic_analysis/ast_node/mod.rs

@@ -171,28 +171,42 @@ impl<'sc> TypedAstNode<'sc> {
                         }) => {
                             let mut methods_buf = Vec::new();
                             let interface_surface = interface_surface
-                        .into_iter()
-                        .map(|TraitFn {
-                             name,
-                              parameters,
-                              return_type,
-                              return_type_span
-                             }| TypedTraitFn {
-                            name,
-                            return_type_span,
-                            parameters: parameters
-                                .into_iter()
-                                .map(|FunctionParameter { name, r#type, type_span }|
-                                    TypedFunctionParameter {
-                                         name,
-                                         r#type: namespace.resolve_type(&r#type, 
-                                            &MaybeResolvedType::Partial(PartiallyResolvedType::SelfType)),
-                                             type_span }
-                                ).collect(),
-                            return_type: namespace.resolve_type(&return_type,
-                                &MaybeResolvedType::Partial(PartiallyResolvedType::SelfType)
-                            )
-                        }).collect::<Vec<_>>();
+                            .into_iter()
+                            .map(|TraitFn {
+                                name,
+                                parameters,
+                                return_type,
+                                return_type_span
+                                }| TypedTraitFn {
+                                name,
+                                return_type_span,
+                                parameters: parameters
+                                    .into_iter()
+                                    .map(|FunctionParameter { name, r#type, type_span }|
+                                        TypedFunctionParameter {
+                                            name,
+                                            r#type: namespace.resolve_type(&r#type, 
+                                                &MaybeResolvedType::Partial(PartiallyResolvedType::SelfType)),
+                                                type_span }
+                                    ).collect(),
+                                return_type: namespace.resolve_type(&return_type,
+                                    &MaybeResolvedType::Partial(PartiallyResolvedType::SelfType)
+                                )
+                            }).collect::<Vec<_>>();
+                            let mut l_namespace = namespace.clone();
+                            // insert placeholder functions representing the interface surface
+                            // to allow methods to use those functions
+                            l_namespace.insert_trait_implementation(
+                                CallPath {
+                                    prefixes: vec![],
+                                    suffix: name.clone(),
+                                },
+                                MaybeResolvedType::Partial(PartiallyResolvedType::SelfType),
+                                interface_surface
+                                    .iter()
+                                    .map(|x| x.to_dummy_func())
+                                    .collect(),
+                            );
                             for FunctionDeclaration {
                                 body,
                                 name: fn_name,
@@ -204,7 +218,7 @@ impl<'sc> TypedAstNode<'sc> {
                                 ..
                             } in methods
                             {
-                                let mut namespace = namespace.clone();
+                                let mut namespace = l_namespace.clone();
                                 parameters.clone().into_iter().for_each(
                                     |FunctionParameter { name, r#type, .. }| {
                                         let r#type = namespace.resolve_type(
@@ -298,6 +312,7 @@ impl<'sc> TypedAstNode<'sc> {
                                         },
                                     )
                                     .collect::<Vec<_>>();
+
                                 // TODO check code block implicit return
                                 let return_type = namespace.resolve_type(&return_type, self_type);
                                 let (body, _code_block_implicit_return) = type_check!(

forc/src/ops/forc_build.rs

@@ -14,37 +14,6 @@ use core_lang::{
 };
 use std::{fs, path::PathBuf};
 
-pub fn print_asm(path: Option<String>) -> Result<(), String> {
-    // find manifest directory, even if in subdirectory
-    let this_dir = if let Some(path) = path {
-        PathBuf::from(path)
-    } else {
-        std::env::current_dir().unwrap()
-    };
-    let manifest_dir = find_manifest_dir(&this_dir).ok_or(format!(
-        "No manifest file found in this directory or any parent directories of it: {:?}",
-        this_dir
-    ))?;
-    let manifest = read_manifest(&manifest_dir)?;
-
-    let mut namespace: Namespace = Default::default();
-    if let Some(ref deps) = manifest.dependencies {
-        for (dependency_name, dependency_details) in deps.iter() {
-            compile_dependency_lib(
-                &this_dir,
-                &dependency_name,
-                &dependency_details,
-                &mut namespace,
-            )?;
-        }
-    }
-
-    // now, compile this program with all of its dependencies
-    let main_file = get_main_file(&manifest, &manifest_dir)?;
-
-    Ok(())
-}
-
 pub fn build(command: BuildCommand) -> Result<Vec<u8>, String> {
     let BuildCommand {
         path,