Merge branch 'development'

Author: mathiasvatter

AST/ASTNodes/AST.cpp

@@ -30,6 +30,7 @@
 #include "../ASTVisitor/ASTCollectLowerings.h"
 #include "../ASTVisitor/ASTVariableChecking.h"
 #include "../ASTVisitor/TypeInference.h"
+#include "../ASTVisitor/ASTLowerTypes.h"
 #include "../ASTVisitor/FunctionHandling/BuiltinRestrictionValidator.h"
 #include "../ASTVisitor/FunctionHandling/FunctionExitCheck.h"
 #include "../ASTVisitor/FunctionHandling/ReturnPathValidator.h"
@@ -208,6 +209,11 @@ void NodeAST::do_type_inference(NodeProgram *program) {
 	accept(inference);
 }
 
+NodeAST * NodeAST::do_type_lowering(NodeProgram *program) {
+	static ASTLowerTypes lowering_types(program);
+	return accept(lowering_types);
+}
+
 NodeAST * NodeAST::do_lowering(NodeProgram *program) {
 	static ASTCollectLowerings collect_lowerings(program);
 	return accept(collect_lowerings);

AST/ASTNodes/AST.h

@@ -109,7 +109,10 @@ struct NodeAST {
 	[[nodiscard]] struct NodeCallback* get_current_callback() const;
 	[[nodiscard]] struct NodeFunctionDefinition* get_current_function() const;
 	NodeAST *do_constant_folding();
+	/// calls TypeInference pass
 	void do_type_inference(NodeProgram *program);
+	/// calls ASTLowerTypes pass
+	NodeAST* do_type_lowering(NodeProgram *program);
 	NodeAST* do_lowering(NodeProgram* program);
 	NodeAST* collect_declarations(NodeProgram* program);
 	NodeAST* collect_call_sites(NodeProgram* program);

AST/ASTNodes/ASTInstructions.cpp

@@ -276,7 +276,12 @@ void NodeFunctionCall::determine_function_strategy(NodeProgram *program, NodeCal
 }
 
 bool NodeFunctionCall::is_in_access_chain() const {
-	return parent and parent->cast<NodeAccessChain>();
+	if (!parent) return false;
+	if (auto chain = parent->cast<NodeAccessChain>()) {
+		if (chain->member(0).get() == this) return false;
+		return true;
+	}
+	return false;
 }
 
 bool NodeFunctionCall::has_side_effects(const std::unordered_set<std::string> &free_vars) {

AST/ASTNodes/ASTInstructions.h

@@ -111,6 +111,8 @@ struct NodeFunctionCall final : NodeInstruction {
 	bool is_destructive_builtin_func() const;
 	bool check_restricted_environment(NodeCallback *current_callback) const;
 	void determine_function_strategy(NodeProgram* program, NodeCallback* current_callback);
+	/// returns true if the function call is inside an access chain. NOT if it is the first member of
+	/// the chain
 	bool is_in_access_chain() const;
 	/// Checks if the function call or any of its arguments has side effects
 	/// this gets checked by giving a set of free variables that are being modified inside

AST/ASTVisitor/ASTLifeTimeAnalysis.h

@@ -6,6 +6,15 @@
 
 #include "ASTVisitor.h"
 
+/**
+ * This pass analysis lifetimes of variables by using Life structs with the first statement
+ * and the last statement they are used in.
+ * It parses stmt by stmt, assigns a lifetime object with the current stmt as start and end
+ * upon visiting a declaration and assignes a new end stmt every time a reference to this var is
+ * visited
+ * - variables declared in a while loop (since all other loop forms are transformed at this point)
+ *   are always assigned the full lifetime of the while loop body
+ */
 class ASTLifeTimeAnalysis : public ASTVisitor {
 	DefinitionProvider* m_def_provider = nullptr;
 	NodeStatement* m_current_statement = nullptr;
@@ -61,6 +70,18 @@ class ASTLifeTimeAnalysis : public ASTVisitor {
 		return m_life_times;
 	}
 
+	// this is not used in variable reuse because all relevant function parameters are already
+	// transformed into assignment statements by parameter transform pass
+	std::unordered_map<NodeDataStructure*, Life>& run(NodeFunctionDefinition& def) {
+		m_variables_in_while.clear();
+		is_in_while_loop = false;
+		m_life_times.clear();
+		m_visited_blocks.clear();
+		m_current_statement = def.body->front();
+		def.accept(*this);
+		return m_life_times;
+	}
+
 	/// can be called after run() -> deletes all declaration nodes with variables where
 	/// start and end member in Life are the same
 	int remove_unused_local_variables() {
@@ -101,7 +122,7 @@ class ASTLifeTimeAnalysis : public ASTVisitor {
 
 	NodeAST *visit(NodeBlock &node) override {
 		m_visited_blocks.insert(&node);
-		m_end_of_current_block.push(node.statements.empty() ? nullptr : node.statements.back().get());
+		m_end_of_current_block.push(node.back());
 		ASTVisitor::visit(node);
 		m_end_of_current_block.pop();
 		return &node;
@@ -132,6 +153,17 @@ class ASTLifeTimeAnalysis : public ASTVisitor {
 		return &node;
 	}
 
+	NodeAST* visit(NodeFunctionParam & node) override {
+		node.variable->accept(*this);
+		// have to do this extra if-check because function param nodes are also used for
+		// foreach key, value
+		if (node.variable->is_function_param()) {
+			add_lifetime_start(node.variable.get(), m_current_statement);
+		}
+		if (node.value) node.value->accept(*this);
+		return &node;
+	}
+
 	NodeAST *visit(NodeArrayRef &node) override {
 		add_lifetime_end(node, m_current_statement);
 		return ASTVisitor::visit(node);

AST/ASTVisitor/ASTLowerTypes.h

@@ -19,9 +19,6 @@ class ASTLowerTypes final : public ASTVisitor {
 		// most func defs will be visited when called, keeping local scopes in mind
 		m_program->global_declarations->accept(*this);
 		m_program->init_callback->accept(*this);
-		// for(const auto & s : node.struct_definitions) {
-		// 	s->accept(*this);
-		// }
 		for(const auto & callback : node.callbacks) {
 			if(callback.get() != m_program->init_callback) callback->accept(*this);
 		}
@@ -95,9 +92,11 @@ class ASTLowerTypes final : public ASTVisitor {
 		node.function->accept(*this);
 		if (node.kind == NodeFunctionCall::Kind::Builtin) return &node;
 		// go first into definition to lower the header type first und give that to the header ref
-		if(node.bind_definition(m_program)) {
-			if(!node.get_definition()->visited) node.get_definition()->accept(*this);
-			node.get_definition()->visited = true;
+		node.bind_definition(m_program);
+		auto decl = node.get_definition();
+		if(decl) {
+			if(!decl->visited) decl->accept(*this);
+			decl->visited = true;
 		}
 		if (node.ty->get_element_type() == TypeRegistry::Boolean) {
 			node.set_element_type(TypeRegistry::Integer);

AST/ASTVisitor/ASTParameterQualifier.h

@@ -52,16 +52,16 @@ class ASTReturnFunctionRewriting final : public ASTVisitor {
 	void do_rewriting(NodeProgram& node) {
 		// do hoisting and return parameter promotion
 		node.accept(*this);
-		static ReturnFunctionCallHoisting hoisting;
+		ReturnFunctionCallHoisting hoisting;
 		hoisting.visit(node);
 		node.reset_function_visited_flag();
 		node.debug_print();
 
-		static ReturnFunctionIsolation isolation(m_program);
+		ReturnFunctionIsolation isolation(m_program);
 		isolation.do_return_function_isolation(node);
 		node.debug_print();
 
-		static ASTTemporaryPointerScope temp_scope(m_program);
+		ASTTemporaryPointerScope temp_scope(m_program);
 		temp_scope.visit(node);
 
 		node.update_function_lookup();