Merge pull request #55 from qupa-project/constant-argument

Constant argument

Author: AjaniBilby

changelog.md

@@ -14,6 +14,7 @@
 - [x] Elif statement
 - [x] Fixed inverted signedness issues on integer comparison
 - [x] Escaped string characters
+- [x] Constant Function Arguments
 
 ## Fixes
 - [x] Bug with nested structure access

compiler/component/execution/base.js

@@ -176,15 +176,6 @@ class ExecutionBase {
 			template
 		);
 
-		if (type === null) {
-			return null;
-		}
-
-		// Linear types are handled by address, not value
-		if (type.type.typeSystem == "linear") {
-			type.pointer++;
-		}
-
 		return type;
 	}
 

compiler/component/execution/index.js

@@ -80,12 +80,6 @@ class Execution extends ExecutionFlow {
 			this.getFile().throw(`Error: Invalid type name "${Flattern.DataTypeStr(ast.tokens[0])}"`, ast.ref.start, ast.ref.end);
 			return null;
 		}
-		typeRef.localLife = ast.tokens[0];
-
-		// Complex types are handled by address, not value
-		if (typeRef.type.typeSystem == "linear" || typeRef.type instanceof Array) {
-			typeRef.pointer++;
-		}
 
 		this.scope.register_Var(
 			typeRef,

compiler/component/function_instance.js

@@ -68,8 +68,10 @@ class Function_Instance {
 		// Flaten signature types AST into a single array
 		let types = [ head.tokens[0] ];
 		let borrows = [ false ];
+		let consts = [ false ];
 		if (args.length > 0) {
-			borrows = borrows.concat(args.map(x => x[0]));
+			borrows = borrows.concat(args.map(x => x[0] == "@"));
+			consts = consts.concat(args.map(x => x[0] == "#"));
 			types = types.concat(args.map((x) => x[1]));
 		}
 
@@ -83,8 +85,9 @@ class Function_Instance {
 		for (let [i, type] of types.entries()){
 			let search = exec.resolveType(type);
 			if (search instanceof TypeRef) {
-				search.pointer = type.tokens[0]; // Copy the pointer level across
-				search.lent = borrows[i];
+				search.pointer  = type.tokens[0]; // Copy the pointer level across
+				search.lent     = borrows[i];
+				search.constant = consts[i];
 
 				this.signature.push(search);
 			} else {

compiler/component/memory/scope.js

@@ -71,15 +71,17 @@ class Scope {
 			));
 
 			// Assigning name space to argument value
-			let chg = this.variables[arg.name].markUpdated(new LLVM.Argument(
-				this.variables[arg.name].type.toLLVM(),
-				new LLVM.Name(id.reference(), false)
-			),
-			true,
-			{
-				start: arg.ref,
-				end: arg.ref
-			});
+			let chg = this.variables[arg.name].markUpdated(
+				new LLVM.Argument(
+					this.variables[arg.name].type.toLLVM(),
+					new LLVM.Name(id.reference(), false)
+				),
+				true,
+				{
+					start: arg.ref,
+					end: arg.ref
+				}
+			);
 			if (chg.error) {
 				this.getFile().throw(chg.msg, chg.ref.start, chg.ref.end);
 				return null;
@@ -248,7 +250,7 @@ class Scope {
 				// If the value is undefined in all states
 				//   Resolve the result to be undefined with no errors
 				if (!branches.map( x => x.scope.variables[name].isUndefined()).includes(false)) {
-					this.variables[name].makeUndefined();
+					this.variables[name].makeUndefined(ref);
 					continue;
 				}
 

compiler/component/memory/variable.js

@@ -152,19 +152,28 @@ class Variable extends Value {
 					msg: "Cannot give ownership of a borrowed value to a child function",
 					ref
 				};
+			} else if (this.type.constant) {
+				return {
+					error: true,
+					msg: `Cannot consume a constant value\n  Recommend cloning $${this.name}`,
+					ref
+				};
 			}
 
-			this.makeUndefined();
+			this.makeUndefined(ref);
 			this.lastUninit = ref.start;
 		}
 
 		out.type = this.type;
 		return out;
 	}
 
-	makeUndefined() {
-		this.store = null;
+	makeUndefined(ref) {
+		this.elements.clear();
+		this.isDecomposed = false;
 		this.probability = null;
+		this.store = null;
+		this.lastUninit = ref.start;
 	}
 
 	/**
@@ -175,19 +184,26 @@ class Variable extends Value {
 	 * @returns {Error?}
 	 */
 	markUpdated (register, force = false, ref) {
-		if (!force && this.type.lent) {
-			return {
-				error: true,
-				msg: "Cannot overwite a lent value",
-				ref
-			};
+		if (!force) {
+			if (this.type.lent) {
+				return {
+					error: true,
+					msg: "Cannot overwite a lent value",
+					ref
+				};
+			} else if (this.type.constant) {
+				return {
+					error: true,
+					msg: "Cannot overwite a constant value",
+					ref
+				};
+			}
 		}
 
-		this.store = register;
+		this.isDecomposed = false;
 		this.probability = null;
-		this.lastUninit = null;
 		this.hasUpdated = true;
-		this.isDecomposed = false;
+		this.store = register;
 
 		return true;
 	}
@@ -235,6 +251,7 @@ class Variable extends Value {
 			let out;
 			if (!this.elements.has(gep.index)) {
 				let read = struct.accessGEPByIndex(gep.index, this.store);
+				read.type.constant = read.type.constant || this.type.constant;
 				out = new Variable(
 					read.type,
 					`${this.name}.${accessor}`,
@@ -712,7 +729,7 @@ class Variable extends Value {
 	cleanup(ref) {
 		let frag = new LLVM.Fragment();
 
-		if (this.isClone) {            // Do nothing as this variable is a clone
+		if (this.isClone || this.type.constant) {  // Do nothing as this variable is a clone/constant
 			return frag;
 		} else if (this.type.lent) {   // Borrowed types need to be recomposed
 			let res = this.resolve(ref, false);
@@ -750,13 +767,15 @@ class Variable extends Value {
 				msg: "Cannot delete an already undefined value",
 				ref: ref
 			};
+		} else if (this.type.constant) {
+			return {
+				error: true,
+				msg: "Cannot delete a constant value",
+				ref: ref
+			};
 		}
 
-		this.elements = new Map();
-		this.isDecomposed = false;
-		this.probability = null;
-		this.store = null;
-		this.lastUninit = ref.start;
+		this.makeUndefined(ref);
 		return new LLVM.Fragment();
 	}
 }

compiler/component/struct.js

@@ -144,7 +144,7 @@ class Structure extends TypeDef {
 		return {
 			preamble: preamble,
 			instruction: val,
-			type: type
+			type: type.duplicate()
 		};
 	}
 
@@ -226,12 +226,11 @@ class Structure extends TypeDef {
 
 		let term = new Struct_Term(
 			name,
-			new TypeRef(typeNode.tokens[0], typeRef.type),
+			new TypeRef(0, typeRef.type),
 			node.ref.start
 		);
 		this.terms.push(term);
 		this.size += term.size;
-
 		return true;
 	}
 

compiler/component/typeRef.js

@@ -9,10 +9,11 @@ class TypeRef {
 	 * @param {Number} pointerLvl
 	 * @param {Type} type
 	 */
-	constructor (pointerLvl, type, lent = false) {
+	constructor (pointerLvl, type, lent = false, constant = false) {
 		this.pointer = pointerLvl;
 		this.type = type;
 		this.lent = lent;
+		this.constant = constant;
 	}
 
 	getName () {
@@ -55,7 +56,7 @@ class TypeRef {
 	 * Creates a clone of this reference
 	 */
 	duplicate () {
-		return new TypeRef(this.pointer, this.type, this.lent);
+		return new TypeRef(this.pointer, this.type, this.lent, this.constant);
 	}
 
 

compiler/parser/parse.js

@@ -700,7 +700,7 @@ function Simplify_Func_Args_List (node) {
 	let ittr = node.tokens[0].concat(node.tokens[2].map(x => x.tokens[2][0]));
 
 	node.tokens = ittr.map((arg) => [
-		arg.tokens[4].length > 0,             // borrowed?
+		arg.tokens[4][0] ? arg.tokens[4][0].tokens : null,             // borrowed?
 		Simplify_Data_Type(arg.tokens[6][0]), // type
 		Simplify_Name(arg.tokens[0][0])       // name
 	]);

compiler/parser/syntax.bnf

@@ -83,7 +83,7 @@ program ::= w* ( stmt_top w* )*
 		func_head ::= "fn" w+ name w* func_arguments w* ( ":" w* data_type )?
 			func_arguments ::= "(" w* func_arg_list? ")"
 				func_arg_list ::= func_arg w* ( "," w* func_arg w* )*
-				func_arg      ::= name w* ":" w* "@"? w* data_type
+				func_arg      ::= name w* ":" w* ( "@" | "#" )? w* data_type
 		function_body ::= "{" w* ( func_stmt w* )* "}"
 			func_stmt ::= comment | if | return | composition | declare | delete | assign | declare_assign | call_procedure