Initial Fuel HLL

.gitignore

@@ -1,6 +1,7 @@
 # Generated by Cargo
 # will have compiled files and executables
-/target/
+**/*/target/
+target
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html

Cargo.toml

@@ -1,9 +1,3 @@
-[package]
-name = "hll"
-version = "0.1.0"
-authors = ["Alex <[email protected]>"]
-edition = "2018"
+[workspace]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
+members = ["core_lang", "forc"]

README.md

@@ -1,2 +1,15 @@
-# fuel-vm-hll
-High Level Language (Name Subject to Change) for the FuelVM
+# Fume
+
+Fume is a language developed for the Fuel blockchain. It is heavily inspired by Rust and aims to bring modern language development and performance to the Ethereum ecosystem.
+
+## Running the Compiler
+To run the compiler from this directory:
+```
+cargo run --bin forc -- -p <path_to_project>
+
+// e.g.
+
+cargo run --bin forc -- build -p example_project/fuel_project
+```
+
+

core_lang/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "core_lang"
+version = "0.1.0"
+authors = ["Alex <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+pest = "2.0"
+pest_derive = "2.0"
+thiserror = "1.0"
+either = "1.6"
+Inflector = "0.11"
+petgraph = "0.5"
+uuid-b64 = "0.1"

core_lang/README.md

@@ -0,0 +1,8 @@
+# fuel-vm-hll
+High Level Language (Name Subject to Change) for the FuelVM.
+
+# Running the Compiler
+It is recommended to run this compiler from the `forc` executable, which can be found in this workspace. 
+
+# Minimum supported Rust version
+As of now, this code was developed on and is guaranteed to run on Rust 1.50 stable. 

core_lang/src/asm_generation/compiler_constants.rs

@@ -0,0 +1 @@
+

core_lang/src/asm_generation/declaration/fn_decl.rs

@@ -0,0 +1,15 @@
+use crate::{
+    asm_generation::{AsmNamespace, RegisterSequencer},
+    asm_lang::Op,
+    error::*,
+    TypedFunctionDeclaration,
+};
+
+pub(crate) fn convert_fn_decl_to_asm<'sc>(
+    _decl: &TypedFunctionDeclaration<'sc>,
+    _namespace: &mut AsmNamespace,
+    _register_sequencer: &mut RegisterSequencer,
+) -> CompileResult<'sc, Vec<Op<'sc>>> {
+    // for now, we inline all functions as a shortcut.
+    ok(vec![], vec![], vec![])
+}

core_lang/src/asm_generation/declaration/mod.rs

@@ -0,0 +1,42 @@
+use crate::{asm_lang::Op, error::*, TypedDeclaration};
+
+use super::{AsmNamespace, RegisterSequencer};
+mod fn_decl;
+mod reassignment;
+mod var_decl;
+pub(crate) use fn_decl::convert_fn_decl_to_asm;
+pub(crate) use reassignment::convert_reassignment_to_asm;
+pub(crate) use var_decl::convert_variable_decl_to_asm;
+
+pub(crate) fn convert_decl_to_asm<'sc>(
+    decl: &TypedDeclaration<'sc>,
+    namespace: &mut AsmNamespace<'sc>,
+    register_sequencer: &mut RegisterSequencer,
+) -> CompileResult<'sc, Vec<Op<'sc>>> {
+    match decl {
+        // For an enum declaration, we don't generate any asm.
+        TypedDeclaration::EnumDeclaration(_) => ok(vec![], vec![], vec![]),
+        TypedDeclaration::FunctionDeclaration(typed_fn_decl) => {
+            convert_fn_decl_to_asm(typed_fn_decl, namespace, register_sequencer)
+        }
+        // a trait declaration also does not have any asm directly generated from it
+        TypedDeclaration::TraitDeclaration(_) => ok(vec![], vec![], vec![]),
+        // since all functions are inlined (for now -- shortcut), we also don't need to do anything for this.
+        TypedDeclaration::ImplTrait { .. } => ok(vec![], vec![], vec![]),
+        // once again the declaration of a type has no inherent asm, only instantiations
+        TypedDeclaration::StructDeclaration(_) => ok(vec![], vec![], vec![]),
+        TypedDeclaration::VariableDeclaration(var_decl) => {
+            convert_variable_decl_to_asm(var_decl, namespace, register_sequencer)
+        }
+        TypedDeclaration::Reassignment(reassignment) => {
+            convert_reassignment_to_asm(reassignment, namespace, register_sequencer)
+        }
+        _ => err(
+            vec![],
+            vec![CompileError::Unimplemented(
+                "ASM generation has not yet been implemented for this declaration variant.",
+                decl.span().clone(),
+            )],
+        ),
+    }
+}

core_lang/src/asm_generation/declaration/reassignment.rs

@@ -0,0 +1,52 @@
+use super::*;
+use crate::{
+    asm_generation::{convert_expression_to_asm, AsmNamespace, RegisterSequencer},
+    semantics::ast_node::TypedReassignment,
+};
+
+pub(crate) fn convert_reassignment_to_asm<'sc>(
+    reassignment: &TypedReassignment<'sc>,
+    namespace: &mut AsmNamespace<'sc>,
+    register_sequencer: &mut RegisterSequencer,
+) -> CompileResult<'sc, Vec<Op<'sc>>> {
+    // 0. evaluate the RHS of the reassignment
+    // 1. Find the register that the previous var was stored in
+    // 2. move the return register of the RHS into the register in the namespace
+
+    let mut buf = vec![];
+    let mut warnings = vec![];
+    let mut errors = vec![];
+    // step 0
+    let return_register = register_sequencer.next();
+    let mut rhs = type_check!(
+        convert_expression_to_asm(
+            &reassignment.rhs,
+            namespace,
+            &return_register,
+            register_sequencer
+        ),
+        vec![],
+        warnings,
+        errors
+    );
+
+    buf.append(&mut rhs);
+
+    // step 1
+    let var_register = type_check!(
+        namespace.look_up_variable(&reassignment.lhs),
+        return err(warnings, errors),
+        warnings,
+        errors
+    );
+
+    // step 2
+    buf.push(Op::register_move_comment(
+        var_register.clone(),
+        return_register,
+        reassignment.lhs.span.clone(),
+        format!("variable {} reassignment", reassignment.lhs.primary_name),
+    ));
+
+    ok(buf, warnings, errors)
+}

core_lang/src/asm_generation/declaration/var_decl.rs

@@ -0,0 +1,20 @@
+use crate::{
+    asm_generation::{convert_expression_to_asm, AsmNamespace, RegisterSequencer},
+    asm_lang::Op,
+    error::*,
+    semantics::ast_node::TypedVariableDeclaration,
+};
+
+/// Provisions a register to put a variable in, and then adds the assembly used to initialize the
+/// variable to the end of the buffer.
+pub(crate) fn convert_variable_decl_to_asm<'sc>(
+    var_decl: &TypedVariableDeclaration<'sc>,
+    namespace: &mut AsmNamespace<'sc>,
+    register_sequencer: &mut RegisterSequencer,
+) -> CompileResult<'sc, Vec<Op<'sc>>> {
+    let var_register = register_sequencer.next();
+    let initialization =
+        convert_expression_to_asm(&var_decl.body, namespace, &var_register, register_sequencer);
+    namespace.insert_variable(var_decl.name.clone(), var_register);
+    initialization
+}

core_lang/src/asm_generation/expression/enum_instantiation.rs

@@ -0,0 +1,103 @@
+use crate::asm_generation::{convert_expression_to_asm, AsmNamespace, RegisterSequencer};
+use crate::asm_lang::{ConstantRegister, Op, Opcode, RegisterId};
+use crate::error::*;
+use crate::semantics::ast_node::TypedEnumDeclaration;
+use crate::semantics::TypedExpression;
+use crate::Literal;
+use crate::{CompileResult, Ident};
+use std::convert::TryFrom;
+
+pub(crate) fn convert_enum_instantiation_to_asm<'sc>(
+    decl: &TypedEnumDeclaration<'sc>,
+    _variant_name: &Ident<'sc>,
+    tag: usize,
+    contents: &Option<Box<TypedExpression<'sc>>>,
+    return_register: &RegisterId,
+    namespace: &mut AsmNamespace<'sc>,
+    register_sequencer: &mut RegisterSequencer,
+) -> CompileResult<'sc, Vec<Op<'sc>>> {
+    let mut warnings = vec![];
+    let mut errors = vec![];
+    // step 0: load the tag into a register
+    // step 1: load the data into a register
+    // step 2: write both registers sequentially to memory, extending the call frame
+    // step 3: write the location of the value to the return register
+    let mut asm_buf = vec![];
+    // step 0
+    let data_label = namespace.insert_data_value(&Literal::U64(tag as u64));
+    let tag_register = register_sequencer.next();
+    asm_buf.push(Op::unowned_load_data_comment(
+        tag_register.clone(),
+        data_label,
+        format!("{} enum instantiation", decl.name.primary_name),
+    ));
+    let pointer_register = register_sequencer.next();
+    // copy stack pointer into pointer register
+    asm_buf.push(Op::unowned_register_move_comment(
+        pointer_register.clone(),
+        RegisterId::Constant(ConstantRegister::StackPointer),
+        "load $sp for enum pointer",
+    ));
+    let size_of_enum = 1 /* tag */ + decl.as_type().stack_size_of();
+    let size_of_enum: u32 = match u32::try_from(size_of_enum) {
+        Ok(o) if o < 16777216 /* 2^24 */ => o,
+        _ => {
+            errors.push(CompileError::Unimplemented(
+                "Stack variables which exceed 2^24 (16777216) words in size are not supported yet.",
+                decl.clone().span,
+            ));
+            return err(warnings, errors);
+        }
+    };
+
+    asm_buf.push(Op::unowned_stack_allocate_memory(size_of_enum));
+    // initialize all the memory to 0
+    asm_buf.push(Op::new(
+        Opcode::MemClearImmediate(pointer_register.clone(), size_of_enum),
+        decl.clone().span,
+    ));
+    // write the tag
+    // step 2
+    asm_buf.push(Op::write_register_to_memory(
+        pointer_register.clone(),
+        tag_register.clone(),
+        0,
+        decl.clone().span,
+    ));
+
+    // step 1 continued
+    // // if there are any enum contents, instantiate them
+    if let Some(instantiation) = contents {
+        let return_register = register_sequencer.next();
+        let mut asm = type_check!(
+            convert_expression_to_asm(
+                &*instantiation,
+                namespace,
+                &return_register.clone(),
+                register_sequencer
+            ),
+            return err(warnings, errors),
+            warnings,
+            errors
+        );
+        asm_buf.append(&mut asm);
+        // write these enum contents to the address after the tag
+        // step 2
+        asm_buf.push(Op::write_register_to_memory_comment(
+            pointer_register.clone(),
+            return_register.clone(),
+            1, /* offset by 1 because the tag was already written */
+            instantiation.span.clone(),
+            format!("{} enum contents", decl.name.primary_name),
+        ));
+    }
+
+    // step 3
+    asm_buf.push(Op::register_move(
+        return_register.clone(),
+        pointer_register,
+        decl.clone().span,
+    ));
+
+    ok(asm_buf, warnings, errors)
+}