Replace SemanticAnalyzer with CodeContext in CodeNode.check parameter

87 files changed, 614 insertions, 614 deletions

diff --git a/vala/valaaddressofexpression.vala b/vala/valaaddressofexpression.vala
index 1033ccc13..7786cfd2e 100644
--- a/vala/valaaddressofexpression.vala
+++ b/vala/valaaddressofexpression.vala
@@ -72,14 +72,14 @@ public class Vala.AddressofExpression : Expression {
 		return inner.is_pure ();
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!inner.check (analyzer)) {
+		if (!inner.check (context)) {
 			error = true;
 			return false;
 		}
diff --git a/vala/valaarraycreationexpression.vala b/vala/valaarraycreationexpression.vala
index d8d0f2c08..1c72d6b5c 100644
--- a/vala/valaarraycreationexpression.vala
+++ b/vala/valaarraycreationexpression.vala
@@ -128,11 +128,11 @@ public class Vala.ArrayCreationExpression : Expression {
 		}
 	}
 
-	private int create_sizes_from_initializer_list (SemanticAnalyzer analyzer, InitializerList il, int rank, List<Literal> sl) {
+	private int create_sizes_from_initializer_list (CodeContext context, InitializerList il, int rank, List<Literal> sl) {
 		if (sl.size == (this.rank - rank)) {
 			// only add size if this is the first initializer list of the current dimension
 			var init = new IntegerLiteral (il.size.to_string (), il.source_reference);
-			init.check (analyzer);
+			init.check (context);
 			sl.add (init);
 		}
 
@@ -145,7 +145,7 @@ public class Vala.ArrayCreationExpression : Expression {
 					Report.error (e.source_reference, "Expected array element, got array initializer list");
 					return -1;
 				}
-				int size = create_sizes_from_initializer_list (analyzer, (InitializerList) e, rank - 1, sl);
+				int size = create_sizes_from_initializer_list (context, (InitializerList) e, rank - 1, sl);
 				if (size == -1) {
 					return -1;
 				}
@@ -168,7 +168,7 @@ public class Vala.ArrayCreationExpression : Expression {
 		return il.size;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -179,20 +179,20 @@ public class Vala.ArrayCreationExpression : Expression {
 		var initlist = initializer_list;
 
 		if (element_type != null) {
-			element_type.check (analyzer);
+			element_type.check (context);
 		}
 
 		foreach (Expression e in sizes) {
-			e.check (analyzer);
+			e.check (context);
 		}
 
 		var calc_sizes = new ArrayList<Literal> ();
 		if (initlist != null) {
 			initlist.target_type = new ArrayType (element_type, rank, source_reference);
 
-			initlist.check (analyzer);
+			initlist.check (context);
 
-			var ret = create_sizes_from_initializer_list (analyzer, initlist, rank, calc_sizes);
+			var ret = create_sizes_from_initializer_list (context, initlist, rank, calc_sizes);
 			if (ret == -1) {
 				error = true;
 			}
diff --git a/vala/valaarraytype.vala b/vala/valaarraytype.vala
index bff533383..5ed4ff683 100644
--- a/vala/valaarraytype.vala
+++ b/vala/valaarraytype.vala
@@ -236,13 +236,13 @@ public class Vala.ArrayType : ReferenceType {
 		return element_type.is_accessible (sym);
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (invalid_syntax) {
 			Report.error (source_reference, "syntax error, no expression allowed between array brackets");
 			error = true;
 			return false;
 		}
-		return element_type.check (analyzer);
+		return element_type.check (context);
 	}
 
 	public override string? get_type_id () {
diff --git a/vala/valaassignment.vala b/vala/valaassignment.vala
index 993de9bef..2af76b7e2 100644
--- a/vala/valaassignment.vala
+++ b/vala/valaassignment.vala
@@ -97,7 +97,7 @@ public class Vala.Assignment : Expression {
 		return false;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -109,15 +109,15 @@ public class Vala.Assignment : Expression {
 
 			var local = new LocalVariable (null, get_temp_name (), right, right.source_reference);
 			var decl = new DeclarationStatement (local, source_reference);
-			decl.check (analyzer);
-			insert_statement (analyzer.insert_block, decl);
+			decl.check (context);
+			insert_statement (context.analyzer.insert_block, decl);
 
 			int i = 0;
 			ExpressionStatement stmt = null;
 			foreach (var expr in tuple.get_expressions ()) {
 				if (stmt != null) {
-					stmt.check (analyzer);
-					insert_statement (analyzer.insert_block, stmt);
+					stmt.check (context);
+					insert_statement (context.analyzer.insert_block, stmt);
 				}
 
 				var temp_access = new MemberAccess.simple (local.name, right.source_reference);
@@ -129,14 +129,14 @@ public class Vala.Assignment : Expression {
 				i++;
 			}
 
-			analyzer.replaced_nodes.add (this);
+			context.analyzer.replaced_nodes.add (this);
 			parent_node.replace_expression (this, stmt.expression);
-			return stmt.expression.check (analyzer);
+			return stmt.expression.check (context);
 		}
 
 		left.lvalue = true;
 
-		if (!left.check (analyzer)) {
+		if (!left.check (context)) {
 			// skip on error in inner expression
 			error = true;
 			return false;
@@ -146,7 +146,7 @@ public class Vala.Assignment : Expression {
 			var ma = (MemberAccess) left;
 
 			if ((!(ma.symbol_reference is Signal || ma.symbol_reference is DynamicProperty) && ma.value_type == null) ||
-			    (ma.inner == null && ma.member_name == "this" && analyzer.is_in_instance_method ())) {
+			    (ma.inner == null && ma.member_name == "this" && context.analyzer.is_in_instance_method ())) {
 				error = true;
 				Report.error (source_reference, "unsupported lvalue in assignment");
 				return false;
@@ -165,11 +165,11 @@ public class Vala.Assignment : Expression {
 
 			if (ma.symbol_reference is DynamicSignal) {
 				// target_type not available for dynamic signals
-				if (!analyzer.context.deprecated) {
+				if (!context.deprecated) {
 					Report.warning (source_reference, "deprecated syntax, use `connect' method instead");
 				}
 			} else if (ma.symbol_reference is Signal) {
-				if (!analyzer.context.deprecated) {
+				if (!context.deprecated) {
 					Report.warning (source_reference, "deprecated syntax, use `connect' method instead");
 				}
 				var sig = (Signal) ma.symbol_reference;
@@ -181,7 +181,7 @@ public class Vala.Assignment : Expression {
 		} else if (left is ElementAccess) {
 			var ea = (ElementAccess) left;
 
-			if (ea.container.value_type.data_type == analyzer.string_type.data_type) {
+			if (ea.container.value_type.data_type == context.analyzer.string_type.data_type) {
 				error = true;
 				Report.error (ea.source_reference, "strings are immutable");
 				return false;
@@ -196,7 +196,7 @@ public class Vala.Assignment : Expression {
 				}
 				set_call.add_argument (right);
 				parent_node.replace_expression (this, set_call);
-				return set_call.check (analyzer);
+				return set_call.check (context);
 			} else {
 				right.target_type = left.value_type;
 			}
@@ -208,7 +208,7 @@ public class Vala.Assignment : Expression {
 			return false;
 		}
 
-		if (!right.check (analyzer)) {
+		if (!right.check (context)) {
 			// skip on error in inner expression
 			error = true;
 			return false;
@@ -252,7 +252,7 @@ public class Vala.Assignment : Expression {
 				}
 
 				right = bin;
-				right.check (analyzer);
+				right.check (context);
 
 				operator = AssignmentOperator.SIMPLE;
 			}
@@ -306,14 +306,14 @@ public class Vala.Assignment : Expression {
 				}
 
 				if (prop.set_accessor == null
-				    || (!prop.set_accessor.writable && !(analyzer.find_current_method () is CreationMethod || analyzer.is_in_constructor ()))) {
+				    || (!prop.set_accessor.writable && !(context.analyzer.find_current_method () is CreationMethod || context.analyzer.is_in_constructor ()))) {
 					ma.error = true;
 					Report.error (ma.source_reference, "Property `%s' is read-only".printf (prop.get_full_name ()));
 					return false;
-				} else if (!analyzer.context.deprecated
+				} else if (!context.deprecated
 				           && !prop.set_accessor.writable
-				           && analyzer.find_current_method () is CreationMethod) {
-					if (ma.inner.symbol_reference != analyzer.find_current_method ().this_parameter) {
+				           && context.analyzer.find_current_method () is CreationMethod) {
+					if (ma.inner.symbol_reference != context.analyzer.find_current_method ().this_parameter) {
 						// trying to set construct-only property in creation method for foreign instance
 						Report.error (ma.source_reference, "Property `%s' is read-only".printf (prop.get_full_name ()));
 						return false;
diff --git a/vala/valabaseaccess.vala b/vala/valabaseaccess.vala
index e03baf772..805854068 100644
--- a/vala/valabaseaccess.vala
+++ b/vala/valabaseaccess.vala
@@ -49,36 +49,36 @@ public class Vala.BaseAccess : Expression {
 		return true;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!analyzer.is_in_instance_method ()) {
+		if (!context.analyzer.is_in_instance_method ()) {
 			error = true;
 			Report.error (source_reference, "Base access invalid outside of instance methods");
 			return false;
 		}
 
-		if (analyzer.current_class == null) {
-			if (analyzer.current_struct == null) {
+		if (context.analyzer.current_class == null) {
+			if (context.analyzer.current_struct == null) {
 				error = true;
 				Report.error (source_reference, "Base access invalid outside of class and struct");
 				return false;
-			} else if (analyzer.current_struct.base_type == null) {
+			} else if (context.analyzer.current_struct.base_type == null) {
 				error = true;
 				Report.error (source_reference, "Base access invalid without base type");
 				return false;
 			}
-			value_type = analyzer.current_struct.base_type;
-		} else if (analyzer.current_class.base_class == null) {
+			value_type = context.analyzer.current_struct.base_type;
+		} else if (context.analyzer.current_class.base_class == null) {
 			error = true;
 			Report.error (source_reference, "Base access invalid without base class");
 			return false;
 		} else {
-			foreach (var base_type in analyzer.current_class.get_base_types ()) {
+			foreach (var base_type in context.analyzer.current_class.get_base_types ()) {
 				if (base_type.data_type is Class) {
 					value_type = base_type.copy ();
 					value_type.value_owned = false;
diff --git a/vala/valabinaryexpression.vala b/vala/valabinaryexpression.vala
index 307d79dc4..9c7aedc2a 100644
--- a/vala/valabinaryexpression.vala
+++ b/vala/valabinaryexpression.vala
@@ -141,7 +141,7 @@ public class Vala.BinaryExpression : Expression {
 		return left.is_non_null () && right.is_non_null ();
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -150,14 +150,14 @@ public class Vala.BinaryExpression : Expression {
 
 		// some expressions are not in a block,
 		// for example, expressions in method contracts
-		if (analyzer.current_symbol is Block
+		if (context.analyzer.current_symbol is Block
 		    && (operator == BinaryOperator.AND || operator == BinaryOperator.OR)) {
 			// convert conditional expression into if statement
 			// required for flow analysis and exception handling
 
-			var local = new LocalVariable (analyzer.bool_type.copy (), get_temp_name (), null, source_reference);
+			var local = new LocalVariable (context.analyzer.bool_type.copy (), get_temp_name (), null, source_reference);
 			var decl = new DeclarationStatement (local, source_reference);
-			decl.check (analyzer);
+			decl.check (context);
 
 			var right_stmt = new ExpressionStatement (new Assignment (new MemberAccess.simple (local.name, right.source_reference), right, AssignmentOperator.SIMPLE, right.source_reference), right.source_reference);
 
@@ -176,17 +176,17 @@ public class Vala.BinaryExpression : Expression {
 
 			var if_stmt = new IfStatement (left, true_block, false_block, source_reference);
 
-			insert_statement (analyzer.insert_block, decl);
-			insert_statement (analyzer.insert_block, if_stmt);
+			insert_statement (context.analyzer.insert_block, decl);
+			insert_statement (context.analyzer.insert_block, if_stmt);
 
-			if (!if_stmt.check (analyzer)) {
+			if (!if_stmt.check (context)) {
 				error = true;
 				return false;
 			}
 
 			var ma = new MemberAccess.simple (local.name, source_reference);
 			ma.target_type = target_type;
-			ma.check (analyzer);
+			ma.check (context);
 
 			parent_node.replace_expression (this, ma);
 
@@ -196,7 +196,7 @@ public class Vala.BinaryExpression : Expression {
 		if (operator == BinaryOperator.COALESCE) {
 			var local = new LocalVariable (null, get_temp_name (), left, source_reference);
 			var decl = new DeclarationStatement (local, source_reference);
-			decl.check (analyzer);
+			decl.check (context);
 
 			var right_stmt = new ExpressionStatement (new Assignment (new MemberAccess.simple (local.name, right.source_reference), right, AssignmentOperator.SIMPLE, right.source_reference), right.source_reference);
 
@@ -208,24 +208,24 @@ public class Vala.BinaryExpression : Expression {
 
 			var if_stmt = new IfStatement (cond, true_block, null, source_reference);
 
-			insert_statement (analyzer.insert_block, decl);
-			insert_statement (analyzer.insert_block, if_stmt);
+			insert_statement (context.analyzer.insert_block, decl);
+			insert_statement (context.analyzer.insert_block, if_stmt);
 
-			if (!if_stmt.check (analyzer)) {
+			if (!if_stmt.check (context)) {
 				error = true;
 				return false;
 			}
 
 			var ma = new MemberAccess.simple (local.name, source_reference);
 			ma.target_type = target_type;
-			ma.check (analyzer);
+			ma.check (context);
 
 			parent_node.replace_expression (this, ma);
 
 			return true;
 		}
 
-		if (!left.check (analyzer) || !right.check (analyzer)) {
+		if (!left.check (context) || !right.check (context)) {
 			/* if there were any errors in inner expressions, skip type check */
 			error = true;
 			return false;
@@ -243,31 +243,31 @@ public class Vala.BinaryExpression : Expression {
 			return false;
 		}
 
-		if (left.value_type.data_type == analyzer.string_type.data_type
+		if (left.value_type.data_type == context.analyzer.string_type.data_type
 		    && operator == BinaryOperator.PLUS) {
 			// string concatenation
 
-			if (analyzer.context.profile == Profile.DOVA) {
+			if (context.profile == Profile.DOVA) {
 				var concat_call = new MethodCall (new MemberAccess (left, "concat", source_reference), source_reference);
 				concat_call.add_argument (right);
 				concat_call.target_type = target_type;
 				parent_node.replace_expression (this, concat_call);
-				return concat_call.check (analyzer);
+				return concat_call.check (context);
 			}
 
-			if (right.value_type == null || right.value_type.data_type != analyzer.string_type.data_type) {
+			if (right.value_type == null || right.value_type.data_type != context.analyzer.string_type.data_type) {
 				error = true;
 				Report.error (source_reference, "Operands must be strings");
 				return false;
 			}
 
-			value_type = analyzer.string_type.copy ();
+			value_type = context.analyzer.string_type.copy ();
 			if (left.is_constant () && right.is_constant ()) {
 				value_type.value_owned = false;
 			} else {
 				value_type.value_owned = true;
 			}
-		} else if (analyzer.context.profile == Profile.DOVA && left.value_type.data_type == analyzer.list_type.data_type
+		} else if (context.profile == Profile.DOVA && left.value_type.data_type == context.analyzer.list_type.data_type
 		    && operator == BinaryOperator.PLUS) {
 			// list concatenation
 
@@ -275,8 +275,8 @@ public class Vala.BinaryExpression : Expression {
 			concat_call.add_argument (right);
 			concat_call.target_type = target_type;
 			parent_node.replace_expression (this, concat_call);
-			return concat_call.check (analyzer);
-		} else if (analyzer.context.profile != Profile.DOVA && left.value_type is ArrayType && operator == BinaryOperator.PLUS) {
+			return concat_call.check (context);
+		} else if (context.profile != Profile.DOVA && left.value_type is ArrayType && operator == BinaryOperator.PLUS) {
 			// array concatenation
 
 			var array_type = (ArrayType) left.value_type;
@@ -313,16 +313,16 @@ public class Vala.BinaryExpression : Expression {
 					}
 				} else if (right.value_type is PointerType) {
 					// pointer arithmetic: pointer - pointer
-					if (analyzer.context.profile == Profile.DOVA) {
-						value_type = analyzer.long_type;
+					if (context.profile == Profile.DOVA) {
+						value_type = context.analyzer.long_type;
 					} else {
-						value_type = analyzer.size_t_type;
+						value_type = context.analyzer.size_t_type;
 					}
 				}
 			}
 
 			if (value_type == null) {
-				value_type = analyzer.get_arithmetic_result_type (left.value_type, right.value_type);
+				value_type = context.analyzer.get_arithmetic_result_type (left.value_type, right.value_type);
 			}
 
 			if (value_type == null) {
@@ -334,7 +334,7 @@ public class Vala.BinaryExpression : Expression {
 			   || operator == BinaryOperator.SHIFT_LEFT
 			   || operator == BinaryOperator.SHIFT_RIGHT
 			   || operator == BinaryOperator.BITWISE_XOR) {
-			value_type = analyzer.get_arithmetic_result_type (left.value_type, right.value_type);
+			value_type = context.analyzer.get_arithmetic_result_type (left.value_type, right.value_type);
 
 			if (value_type == null) {
 				error = true;
@@ -345,8 +345,8 @@ public class Vala.BinaryExpression : Expression {
 			   || operator == BinaryOperator.GREATER_THAN
 			   || operator == BinaryOperator.LESS_THAN_OR_EQUAL
 			   || operator == BinaryOperator.GREATER_THAN_OR_EQUAL) {
-			if (left.value_type.compatible (analyzer.string_type)
-			    && right.value_type.compatible (analyzer.string_type)) {
+			if (left.value_type.compatible (context.analyzer.string_type)
+			    && right.value_type.compatible (context.analyzer.string_type)) {
 				// string comparison
 				} else if (left.value_type is PointerType && right.value_type is PointerType) {
 					// pointer arithmetic
@@ -355,9 +355,9 @@ public class Vala.BinaryExpression : Expression {
 
 				if (chained) {
 					var lbe = (BinaryExpression) left;
-					resulting_type = analyzer.get_arithmetic_result_type (lbe.right.value_type, right.value_type);
+					resulting_type = context.analyzer.get_arithmetic_result_type (lbe.right.value_type, right.value_type);
 				} else {
-					resulting_type = analyzer.get_arithmetic_result_type (left.value_type, right.value_type);
+					resulting_type = context.analyzer.get_arithmetic_result_type (left.value_type, right.value_type);
 				}
 
 				if (resulting_type == null) {
@@ -374,7 +374,7 @@ public class Vala.BinaryExpression : Expression {
 				right.target_type.value_owned = false;
 			}
 
-			value_type = analyzer.bool_type;
+			value_type = context.analyzer.bool_type;
 		} else if (operator == BinaryOperator.EQUALITY
 			   || operator == BinaryOperator.INEQUALITY) {
 			/* relational operation */
@@ -400,10 +400,10 @@ public class Vala.BinaryExpression : Expression {
 				}
 			}
 
-			if (left.value_type.compatible (analyzer.string_type)
-			    && right.value_type.compatible (analyzer.string_type)) {
+			if (left.value_type.compatible (context.analyzer.string_type)
+			    && right.value_type.compatible (context.analyzer.string_type)) {
 				// string comparison
-				if (analyzer.context.profile == Profile.DOVA) {
+				if (context.profile == Profile.DOVA) {
 					var string_ma = new MemberAccess.simple ("string", source_reference);
 					string_ma.qualified = true;
 					var equals_call = new MethodCall (new MemberAccess (string_ma, "equals", source_reference), source_reference);
@@ -411,16 +411,16 @@ public class Vala.BinaryExpression : Expression {
 					equals_call.add_argument (right);
 					if (operator == BinaryOperator.EQUALITY) {
 						parent_node.replace_expression (this, equals_call);
-						return equals_call.check (analyzer);
+						return equals_call.check (context);
 					} else {
 						var not = new UnaryExpression (UnaryOperator.LOGICAL_NEGATION, equals_call, source_reference);
 						parent_node.replace_expression (this, not);
-						return not.check (analyzer);
+						return not.check (context);
 					}
 				}
 			}
 
-			value_type = analyzer.bool_type;
+			value_type = context.analyzer.bool_type;
 		} else if (operator == BinaryOperator.BITWISE_AND
 			   || operator == BinaryOperator.BITWISE_OR) {
 			// integer type or flags type
@@ -428,15 +428,15 @@ public class Vala.BinaryExpression : Expression {
 			value_type = left.value_type;
 		} else if (operator == BinaryOperator.AND
 			   || operator == BinaryOperator.OR) {
-			if (!left.value_type.compatible (analyzer.bool_type) || !right.value_type.compatible (analyzer.bool_type)) {
+			if (!left.value_type.compatible (context.analyzer.bool_type) || !right.value_type.compatible (context.analyzer.bool_type)) {
 				error = true;
 				Report.error (source_reference, "Operands must be boolean");
 			}
 
-			value_type = analyzer.bool_type;
+			value_type = context.analyzer.bool_type;
 		} else if (operator == BinaryOperator.IN) {
-			if (left.value_type.compatible (analyzer.int_type)
-			    && right.value_type.compatible (analyzer.int_type)) {
+			if (left.value_type.compatible (context.analyzer.int_type)
+			    && right.value_type.compatible (context.analyzer.int_type)) {
 				// integers or enums
 			} else if (right.value_type is ArrayType) {
 				if (!left.value_type.compatible (((ArrayType) right.value_type).element_type)) {
@@ -455,7 +455,7 @@ public class Vala.BinaryExpression : Expression {
 					error = true;
 					return false;
 				}
-				if (!contains_method.return_type.compatible (analyzer.bool_type)) {
+				if (!contains_method.return_type.compatible (context.analyzer.bool_type)) {
 					Report.error (source_reference, "`%s' must return a boolean value".printf (contains_method.get_full_name ()));
 					error = true;
 					return false;
@@ -464,10 +464,10 @@ public class Vala.BinaryExpression : Expression {
 				var contains_call = new MethodCall (new MemberAccess (right, "contains"));
 				contains_call.add_argument (left);
 				parent_node.replace_expression (this, contains_call);
-				return contains_call.check (analyzer);
+				return contains_call.check (context);
 			}
 			
-			value_type = analyzer.bool_type;
+			value_type = context.analyzer.bool_type;
 			
 		} else {
 			assert_not_reached ();
diff --git a/vala/valablock.vala b/vala/valablock.vala
index c5b044d6a..de8a62ab3 100644
--- a/vala/valablock.vala
+++ b/vala/valablock.vala
@@ -135,22 +135,22 @@ public class Vala.Block : Symbol, Statement {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		owner = analyzer.current_symbol.scope;
+		owner = context.analyzer.current_symbol.scope;
 
-		var old_symbol = analyzer.current_symbol;
-		var old_insert_block = analyzer.insert_block;
-		analyzer.current_symbol = this;
-		analyzer.insert_block = this;
+		var old_symbol = context.analyzer.current_symbol;
+		var old_insert_block = context.analyzer.insert_block;
+		context.analyzer.current_symbol = this;
+		context.analyzer.insert_block = this;
 
 		for (int i = 0; i < statement_list.size; i++) {
-			statement_list[i].check (analyzer);
+			statement_list[i].check (context);
 		}
 
 		foreach (LocalVariable local in get_local_variables ()) {
@@ -166,8 +166,8 @@ public class Vala.Block : Symbol, Statement {
 			add_error_types (stmt.get_error_types ());
 		}
 
-		analyzer.current_symbol = old_symbol;
-		analyzer.insert_block = old_insert_block;
+		context.analyzer.current_symbol = old_symbol;
+		context.analyzer.insert_block = old_insert_block;
 
 		return !error;
 	}
diff --git a/vala/valabooleanliteral.vala b/vala/valabooleanliteral.vala
index e0279447f..1a1aee86e 100644
--- a/vala/valabooleanliteral.vala
+++ b/vala/valabooleanliteral.vala
@@ -61,14 +61,14 @@ public class Vala.BooleanLiteral : Literal {
 		return true;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		value_type = analyzer.bool_type;
+		value_type = context.analyzer.bool_type;
 
 		return !error;
 	}
diff --git a/vala/valacastexpression.vala b/vala/valacastexpression.vala
index 7018992bb..1b58b2572 100644
--- a/vala/valacastexpression.vala
+++ b/vala/valacastexpression.vala
@@ -109,14 +109,14 @@ public class Vala.CastExpression : Expression {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!inner.check (analyzer)) {
+		if (!inner.check (context)) {
 			error = true;
 			return false;
 		}
@@ -133,7 +133,7 @@ public class Vala.CastExpression : Expression {
 			type_reference.nullable = false;
 		}
 
-		type_reference.check (analyzer);
+		type_reference.check (context);
 
 		// FIXME: check whether cast is allowed
 
diff --git a/vala/valacatchclause.vala b/vala/valacatchclause.vala
index b6d742eab..72c9d8468 100644
--- a/vala/valacatchclause.vala
+++ b/vala/valacatchclause.vala
@@ -109,7 +109,7 @@ public class Vala.CatchClause : CodeNode {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -125,16 +125,16 @@ public class Vala.CatchClause : CodeNode {
 			error_variable.checked = true;
 		} else {
 			// generic catch clause
-			if (analyzer.context.profile == Profile.GOBJECT) {
+			if (context.profile == Profile.GOBJECT) {
 				error_type = new ErrorType (null, null, source_reference);
 			} else {
-				error_type = analyzer.error_type;
+				error_type = context.analyzer.error_type;
 			}
 		}
 
-		error_type.check (analyzer);
+		error_type.check (context);
 
-		body.check (analyzer);
+		body.check (context);
 
 		return !error;
 	}
diff --git a/vala/valacharacterliteral.vala b/vala/valacharacterliteral.vala
index 91a302899..d38a0e6de 100644
--- a/vala/valacharacterliteral.vala
+++ b/vala/valacharacterliteral.vala
@@ -83,20 +83,20 @@ public class Vala.CharacterLiteral : Literal {
 		return value;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (analyzer.context.profile == Profile.DOVA) {
-			value_type = new IntegerType ((Struct) analyzer.root_symbol.scope.lookup ("char"), get_char ().to_string (), "int");
+		if (context.profile == Profile.DOVA) {
+			value_type = new IntegerType ((Struct) context.analyzer.root_symbol.scope.lookup ("char"), get_char ().to_string (), "int");
 		} else {
 			if (get_char () < 128) {
-				value_type = new IntegerType ((Struct) analyzer.root_symbol.scope.lookup ("char"));
+				value_type = new IntegerType ((Struct) context.analyzer.root_symbol.scope.lookup ("char"));
 			} else {
-				value_type = new IntegerType ((Struct) analyzer.root_symbol.scope.lookup ("unichar"));
+				value_type = new IntegerType ((Struct) context.analyzer.root_symbol.scope.lookup ("unichar"));
 			}
 		}
 
diff --git a/vala/valaclass.vala b/vala/valaclass.vala
index ffb2265dd..0ba80329d 100644
--- a/vala/valaclass.vala
+++ b/vala/valaclass.vala
@@ -995,7 +995,7 @@ public class Vala.Class : ObjectTypeSymbol {
 		return false;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -1004,16 +1004,16 @@ public class Vala.Class : ObjectTypeSymbol {
 
 		process_attributes ();
 
-		var old_source_file = analyzer.current_source_file;
-		var old_symbol = analyzer.current_symbol;
+		var old_source_file = context.analyzer.current_source_file;
+		var old_symbol = context.analyzer.current_symbol;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
-		analyzer.current_symbol = this;
+		context.analyzer.current_symbol = this;
 
 		foreach (DataType base_type_reference in get_base_types ()) {
-			if (!base_type_reference.check (analyzer)) {
+			if (!base_type_reference.check (context)) {
 				error = true;
 				return false;
 			}
@@ -1025,7 +1025,7 @@ public class Vala.Class : ObjectTypeSymbol {
 			}
 
 			// check whether base type is at least as accessible as the class
-			if (!analyzer.is_type_accessible (this, base_type_reference)) {
+			if (!context.analyzer.is_type_accessible (this, base_type_reference)) {
 				error = true;
 				Report.error (source_reference, "base type `%s` is less accessible than class `%s`".printf (base_type_reference.to_string (), get_full_name ()));
 				return false;
@@ -1045,72 +1045,72 @@ public class Vala.Class : ObjectTypeSymbol {
 		}
 
 		foreach (DataType type in base_types) {
-			type.check (analyzer);
+			type.check (context);
 		}
 
 		foreach (TypeParameter p in get_type_parameters ()) {
-			p.check (analyzer);
+			p.check (context);
 		}
 
 		/* process enums first to avoid order problems in C code */
 		foreach (Enum en in enums) {
-			en.check (analyzer);
+			en.check (context);
 		}
 
 		foreach (Field f in fields) {
-			f.check (analyzer);
+			f.check (context);
 		}
 		
 		foreach (Constant c in constants) {
-			c.check (analyzer);
+			c.check (context);
 		}
 		
 		foreach (Method m in methods) {
-			m.check (analyzer);
+			m.check (context);
 		}
 		
 		foreach (Property prop in properties) {
-			prop.check (analyzer);
+			prop.check (context);
 		}
 		
 		foreach (Signal sig in signals) {
-			sig.check (analyzer);
+			sig.check (context);
 		}
 		
 		if (constructor != null) {
-			constructor.check (analyzer);
+			constructor.check (context);
 		}
 
 		if (class_constructor != null) {
-			class_constructor.check (analyzer);
+			class_constructor.check (context);
 		}
 
 		if (static_constructor != null) {
-			static_constructor.check (analyzer);
+			static_constructor.check (context);
 		}
 
 		if (destructor != null) {
-			destructor.check (analyzer);
+			destructor.check (context);
 		}
 
 		if (static_destructor != null) {
-			static_destructor.check (analyzer);
+			static_destructor.check (context);
 		}
 		
 		if (class_destructor != null) {
-			class_destructor.check (analyzer);
+			class_destructor.check (context);
 		}
 		
 		foreach (Class cl in classes) {
-			cl.check (analyzer);
+			cl.check (context);
 		}
 		
 		foreach (Struct st in structs) {
-			st.check (analyzer);
+			st.check (context);
 		}
 
 		foreach (Delegate d in delegates) {
-			d.check (analyzer);
+			d.check (context);
 		}
 
 		/* compact classes cannot implement interfaces */
@@ -1229,7 +1229,7 @@ public class Vala.Class : ObjectTypeSymbol {
 				while (base_class != null && base_class.is_abstract) {
 					foreach (Method base_method in base_class.get_methods ()) {
 						if (base_method.is_abstract) {
-							var override_method = analyzer.symbol_lookup_inherited (this, base_method.name) as Method;
+							var override_method = context.analyzer.symbol_lookup_inherited (this, base_method.name) as Method;
 							if (override_method == null || !override_method.overrides) {
 								error = true;
 								Report.error (source_reference, "`%s' does not implement abstract method `%s'".printf (get_full_name (), base_method.get_full_name ()));
@@ -1238,7 +1238,7 @@ public class Vala.Class : ObjectTypeSymbol {
 					}
 					foreach (Property base_property in base_class.get_properties ()) {
 						if (base_property.is_abstract) {
-							var override_property = analyzer.symbol_lookup_inherited (this, base_property.name) as Property;
+							var override_property = context.analyzer.symbol_lookup_inherited (this, base_property.name) as Property;
 							if (override_property == null || !override_property.overrides) {
 								error = true;
 								Report.error (source_reference, "`%s' does not implement abstract property `%s'".printf (get_full_name (), base_property.get_full_name ()));
@@ -1250,8 +1250,8 @@ public class Vala.Class : ObjectTypeSymbol {
 			}
 		}
 
-		analyzer.current_source_file = old_source_file;
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_source_file = old_source_file;
+		context.analyzer.current_symbol = old_symbol;
 
 		return !error;
 	}
diff --git a/vala/valacodenode.vala b/vala/valacodenode.vala
index 62508c7e6..b1fc30efa 100644
--- a/vala/valacodenode.vala
+++ b/vala/valacodenode.vala
@@ -121,7 +121,7 @@ public abstract class Vala.CodeNode {
 	public virtual void accept_children (CodeVisitor visitor) {
 	}
 
-	public virtual bool check (SemanticAnalyzer analyzer) {
+	public virtual bool check (CodeContext context) {
 		return true;
 	}
 
diff --git a/vala/valaconditionalexpression.vala b/vala/valaconditionalexpression.vala
index 25c3e2786..c5fdfd698 100644
--- a/vala/valaconditionalexpression.vala
+++ b/vala/valaconditionalexpression.vala
@@ -100,14 +100,14 @@ public class Vala.ConditionalExpression : Expression {
 		return condition.is_pure () && true_expression.is_pure () && false_expression.is_pure ();
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!(analyzer.current_symbol is Block)) {
+		if (!(context.analyzer.current_symbol is Block)) {
 			Report.error (source_reference, "Conditional expressions may only be used in blocks");
 			error = true;
 			return false;
@@ -136,10 +136,10 @@ public class Vala.ConditionalExpression : Expression {
 
 		var if_stmt = new IfStatement (condition, true_block, false_block, source_reference);
 
-		insert_statement (analyzer.insert_block, decl);
-		insert_statement (analyzer.insert_block, if_stmt);
+		insert_statement (context.analyzer.insert_block, decl);
+		insert_statement (context.analyzer.insert_block, if_stmt);
 
-		if (!if_stmt.check (analyzer) || true_expression.error || false_expression.error) {
+		if (!if_stmt.check (context) || true_expression.error || false_expression.error) {
 			error = true;
 			return false;
 		}
@@ -163,23 +163,23 @@ public class Vala.ConditionalExpression : Expression {
 		value_type.value_owned = (true_expression.value_type.value_owned || false_expression.value_type.value_owned);
 
 		local.variable_type = value_type;
-		decl.check (analyzer);
+		decl.check (context);
 
 		true_expression.target_type = value_type;
 		false_expression.target_type = value_type;
 
 		var true_stmt = new ExpressionStatement (new Assignment (new MemberAccess.simple (local.name, true_expression.source_reference), true_expression, AssignmentOperator.SIMPLE, true_expression.source_reference), true_expression.source_reference);
-		true_stmt.check (analyzer);
+		true_stmt.check (context);
 
 		var false_stmt = new ExpressionStatement (new Assignment (new MemberAccess.simple (local.name, false_expression.source_reference), false_expression, AssignmentOperator.SIMPLE, false_expression.source_reference), false_expression.source_reference);
-		false_stmt.check (analyzer);
+		false_stmt.check (context);
 
 		true_block.replace_statement (true_decl, true_stmt);
 		false_block.replace_statement (false_decl, false_stmt);
 
 		var ma = new MemberAccess.simple (local.name, source_reference);
 		ma.target_type = target_type;
-		ma.check (analyzer);
+		ma.check (context);
 
 		parent_node.replace_expression (this, ma);
 
diff --git a/vala/valaconstant.vala b/vala/valaconstant.vala
index 9860c3a38..974fee424 100644
--- a/vala/valaconstant.vala
+++ b/vala/valaconstant.vala
@@ -163,7 +163,7 @@ public class Vala.Constant : Symbol, Lockable {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -172,17 +172,17 @@ public class Vala.Constant : Symbol, Lockable {
 
 		process_attributes ();
 
-		var old_source_file = analyzer.current_source_file;
-		var old_symbol = analyzer.current_symbol;
+		var old_source_file = context.analyzer.current_source_file;
+		var old_symbol = context.analyzer.current_symbol;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
-		analyzer.current_symbol = this;
+		context.analyzer.current_symbol = this;
 
-		type_reference.check (analyzer);
+		type_reference.check (context);
 
-		if (!check_const_type (type_reference, analyzer)) {
+		if (!check_const_type (type_reference, context)) {
 			error = true;
 			Report.error (source_reference, "`%s' not supported as type for constants".printf (type_reference.to_string ()));
 			return false;
@@ -195,7 +195,7 @@ public class Vala.Constant : Symbol, Lockable {
 			} else {
 				value.target_type = type_reference;
 
-				value.check (analyzer);
+				value.check (context);
 
 				if (!value.value_type.compatible (type_reference)) {
 					error = true;
@@ -214,21 +214,21 @@ public class Vala.Constant : Symbol, Lockable {
 			Report.warning (source_reference, "%s hides inherited constant `%s'. Use the `new' keyword if hiding was intentional".printf (get_full_name (), get_hidden_member ().get_full_name ()));
 		}
 
-		analyzer.current_source_file = old_source_file;
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_source_file = old_source_file;
+		context.analyzer.current_symbol = old_symbol;
 
 		active = true;
 
 		return !error;
 	}
 
-	bool check_const_type (DataType type, SemanticAnalyzer analyzer) {
+	bool check_const_type (DataType type, CodeContext context) {
 		if (type is ValueType) {
 			return true;
 		} else if (type is ArrayType) {
 			var array_type = type as ArrayType;
-			return check_const_type (array_type.element_type, analyzer);
-		} else if (type.data_type == analyzer.string_type.data_type) {
+			return check_const_type (array_type.element_type, context);
+		} else if (type.data_type == context.analyzer.string_type.data_type) {
 			return true;
 		} else {
 			return false;
diff --git a/vala/valaconstructor.vala b/vala/valaconstructor.vala
index b3d88a67f..05a86711c 100644
--- a/vala/valaconstructor.vala
+++ b/vala/valaconstructor.vala
@@ -61,21 +61,21 @@ public class Vala.Constructor : Symbol {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		this_parameter = new Parameter ("this", new ObjectType (analyzer.current_class));
+		this_parameter = new Parameter ("this", new ObjectType (context.analyzer.current_class));
 		scope.add (this_parameter.name, this_parameter);
 
-		owner = analyzer.current_symbol.scope;
-		analyzer.current_symbol = this;
+		owner = context.analyzer.current_symbol.scope;
+		context.analyzer.current_symbol = this;
 
 		if (body != null) {
-			body.check (analyzer);
+			body.check (context);
 		}
 
 		foreach (DataType body_error_type in body.get_error_types ()) {
@@ -84,7 +84,7 @@ public class Vala.Constructor : Symbol {
 			}
 		}
 
-		analyzer.current_symbol = analyzer.current_symbol.parent_symbol;
+		context.analyzer.current_symbol = context.analyzer.current_symbol.parent_symbol;
 
 		return !error;
 	}
diff --git a/vala/valacreationmethod.vala b/vala/valacreationmethod.vala
index 22c243d0f..7958ec65b 100644
--- a/vala/valacreationmethod.vala
+++ b/vala/valacreationmethod.vala
@@ -143,7 +143,7 @@ public class Vala.CreationMethod : Method {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -154,78 +154,78 @@ public class Vala.CreationMethod : Method {
 
 		if (class_name != null && class_name != parent_symbol.name) {
 			// class_name is null for constructors generated by GIdlParser
-			Report.error (source_reference, "missing return type in method `%s.%s´".printf (analyzer.current_symbol.get_full_name (), class_name));
+			Report.error (source_reference, "missing return type in method `%s.%s´".printf (context.analyzer.current_symbol.get_full_name (), class_name));
 			error = true;
 			return false;
 		}
 
-		var old_source_file = analyzer.current_source_file;
-		var old_symbol = analyzer.current_symbol;
+		var old_source_file = context.analyzer.current_source_file;
+		var old_symbol = context.analyzer.current_symbol;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
-		analyzer.current_symbol = this;
+		context.analyzer.current_symbol = this;
 
 		foreach (Parameter param in get_parameters()) {
-			param.check (analyzer);
+			param.check (context);
 		}
 
 		foreach (DataType error_type in get_error_types ()) {
-			error_type.check (analyzer);
+			error_type.check (context);
 		}
 
 		foreach (Expression precondition in get_preconditions ()) {
-			precondition.check (analyzer);
+			precondition.check (context);
 		}
 
 		foreach (Expression postcondition in get_postconditions ()) {
-			postcondition.check (analyzer);
+			postcondition.check (context);
 		}
 
 		if (body != null) {
-			body.check (analyzer);
+			body.check (context);
 
 			var cl = parent_symbol as Class;
 
 			// ensure we chain up to base constructor
 			if (!chain_up && cl != null && cl.base_class != null) {
-				if (analyzer.context.profile == Profile.GOBJECT
+				if (context.profile == Profile.GOBJECT
 				    && cl.base_class.default_construction_method != null
 				    && !cl.base_class.default_construction_method.has_construct_function) {
 					// directly chain up to Object
-					var old_insert_block = analyzer.insert_block;
-					analyzer.current_symbol = body;
-					analyzer.insert_block = body;
+					var old_insert_block = context.analyzer.insert_block;
+					context.analyzer.current_symbol = body;
+					context.analyzer.insert_block = body;
 
 					var stmt = new ExpressionStatement (new MethodCall (new MemberAccess (new MemberAccess.simple ("GLib", source_reference), "Object", source_reference), source_reference), source_reference);
 					body.insert_statement (0, stmt);
-					stmt.check (analyzer);
+					stmt.check (context);
 
-					analyzer.current_symbol = this;
-					analyzer.insert_block = old_insert_block;
+					context.analyzer.current_symbol = this;
+					context.analyzer.insert_block = old_insert_block;
 				} else if (cl.base_class.default_construction_method == null
 				    || cl.base_class.default_construction_method.access == SymbolAccessibility.PRIVATE) {
 					Report.error (source_reference, "unable to chain up to private base constructor");
 				} else if (cl.base_class.default_construction_method.get_required_arguments () > 0) {
 					Report.error (source_reference, "unable to chain up to base constructor requiring arguments");
 				} else {
-					var old_insert_block = analyzer.insert_block;
-					analyzer.current_symbol = body;
-					analyzer.insert_block = body;
+					var old_insert_block = context.analyzer.insert_block;
+					context.analyzer.current_symbol = body;
+					context.analyzer.insert_block = body;
 
 					var stmt = new ExpressionStatement (new MethodCall (new BaseAccess (source_reference), source_reference), source_reference);
 					body.insert_statement (0, stmt);
-					stmt.check (analyzer);
+					stmt.check (context);
 
-					analyzer.current_symbol = this;
-					analyzer.insert_block = old_insert_block;
+					context.analyzer.current_symbol = this;
+					context.analyzer.insert_block = old_insert_block;
 				}
 			}
 		}
 
-		analyzer.current_source_file = old_source_file;
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_source_file = old_source_file;
+		context.analyzer.current_symbol = old_symbol;
 
 		if (is_abstract || is_virtual || overrides) {
 			Report.error (source_reference, "The creation method `%s' cannot be marked as override, virtual, or abstract".printf (get_full_name ()));
diff --git a/vala/valadeclarationstatement.vala b/vala/valadeclarationstatement.vala
index 51d80fc00..9eb8fffd6 100644
--- a/vala/valadeclarationstatement.vala
+++ b/vala/valadeclarationstatement.vala
@@ -62,14 +62,14 @@ public class Vala.DeclarationStatement : CodeNode, Statement {
 		declaration.accept (visitor);
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		declaration.check (analyzer);
+		declaration.check (context);
 
 		var local = declaration as LocalVariable;
 		if (local != null && local.initializer != null) {
diff --git a/vala/valadelegate.vala b/vala/valadelegate.vala
index 82ddc6899..00d9b39be 100644
--- a/vala/valadelegate.vala
+++ b/vala/valadelegate.vala
@@ -384,7 +384,7 @@ public class Vala.Delegate : TypeSymbol {
 		return str;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -393,27 +393,27 @@ public class Vala.Delegate : TypeSymbol {
 
 		process_attributes ();
 
-		var old_source_file = analyzer.current_source_file;
+		var old_source_file = context.analyzer.current_source_file;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
 
 		foreach (TypeParameter p in type_parameters) {
-			p.check (analyzer);
+			p.check (context);
 		}
 		
-		return_type.check (analyzer);
+		return_type.check (context);
 		
 		foreach (Parameter param in parameters) {
-			param.check (analyzer);
+			param.check (context);
 		}
 
 		foreach (DataType error_type in get_error_types ()) {
-			error_type.check (analyzer);
+			error_type.check (context);
 		}
 
-		analyzer.current_source_file = old_source_file;
+		context.analyzer.current_source_file = old_source_file;
 
 		return !error;
 	}
diff --git a/vala/valadelegatetype.vala b/vala/valadelegatetype.vala
index a355d7986..c5f2ec8e0 100644
--- a/vala/valadelegatetype.vala
+++ b/vala/valadelegatetype.vala
@@ -101,8 +101,8 @@ public class Vala.DelegateType : DataType {
 		return "G_TYPE_POINTER";
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
-		return delegate_symbol.check (analyzer);
+	public override bool check (CodeContext context) {
+		return delegate_symbol.check (context);
 	}
 
 	public override bool is_disposable () {
diff --git a/vala/valadeletestatement.vala b/vala/valadeletestatement.vala
index ce76bfd42..bb8da3922 100644
--- a/vala/valadeletestatement.vala
+++ b/vala/valadeletestatement.vala
@@ -42,14 +42,14 @@ public class Vala.DeleteStatement : CodeNode, Statement {
 		expression.accept (visitor);
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!expression.check (analyzer)) {
+		if (!expression.check (context)) {
 			// if there was an error in the inner expression, skip this check
 			return false;
 		}
diff --git a/vala/valadestructor.vala b/vala/valadestructor.vala
index 0ab2a74e1..79b93b5b7 100644
--- a/vala/valadestructor.vala
+++ b/vala/valadestructor.vala
@@ -61,21 +61,21 @@ public class Vala.Destructor : Symbol {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		owner = analyzer.current_symbol.scope;
-		analyzer.current_symbol = this;
+		owner = context.analyzer.current_symbol.scope;
+		context.analyzer.current_symbol = this;
 
 		if (body != null) {
-			body.check (analyzer);
+			body.check (context);
 		}
 
-		analyzer.current_symbol = analyzer.current_symbol.parent_symbol;
+		context.analyzer.current_symbol = context.analyzer.current_symbol.parent_symbol;
 
 		return !error;
 	}
diff --git a/vala/valadostatement.vala b/vala/valadostatement.vala
index fa64f1fee..6bf72c0c7 100644
--- a/vala/valadostatement.vala
+++ b/vala/valadostatement.vala
@@ -86,7 +86,7 @@ public class Vala.DoStatement : CodeNode, Statement {
 		return (literal != null && literal.value);
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		// convert to simple loop
 
 		// do not generate variable and if block if condition is always true
@@ -96,12 +96,12 @@ public class Vala.DoStatement : CodeNode, Statement {
 			var parent_block = (Block) parent_node;
 			parent_block.replace_statement (this, loop);
 
-			return loop.check (analyzer);
+			return loop.check (context);
 		}
 
 		var block = new Block (source_reference);
 
-		var first_local = new LocalVariable (analyzer.bool_type.copy (), get_temp_name (), new BooleanLiteral (true, source_reference), source_reference);
+		var first_local = new LocalVariable (context.analyzer.bool_type.copy (), get_temp_name (), new BooleanLiteral (true, source_reference), source_reference);
 		block.add_statement (new DeclarationStatement (first_local, source_reference));
 
 		var if_condition = new UnaryExpression (UnaryOperator.LOGICAL_NEGATION, condition, condition.source_reference);
@@ -121,6 +121,6 @@ public class Vala.DoStatement : CodeNode, Statement {
 		var parent_block = (Block) parent_node;
 		parent_block.replace_statement (this, block);
 
-		return block.check (analyzer);
+		return block.check (context);
 	}
 }
diff --git a/vala/valadynamicmethod.vala b/vala/valadynamicmethod.vala
index 361d4b2ad..3fc98f6f6 100644
--- a/vala/valadynamicmethod.vala
+++ b/vala/valadynamicmethod.vala
@@ -50,7 +50,7 @@ public class Vala.DynamicMethod : Method {
 		return cname;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		return true;
 	}
 }
diff --git a/vala/valadynamicproperty.vala b/vala/valadynamicproperty.vala
index 7155965a5..dc9acb568 100644
--- a/vala/valadynamicproperty.vala
+++ b/vala/valadynamicproperty.vala
@@ -37,7 +37,7 @@ public class Vala.DynamicProperty : Property {
 		return new ArrayList<string> ();
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		return true;
 	}
 }
diff --git a/vala/valadynamicsignal.vala b/vala/valadynamicsignal.vala
index dc1757eb4..c3cae8b06 100644
--- a/vala/valadynamicsignal.vala
+++ b/vala/valadynamicsignal.vala
@@ -35,7 +35,7 @@ public class Vala.DynamicSignal : Signal {
 		this.dynamic_type = dynamic_type;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		return true;
 	}
 }
diff --git a/vala/valaelementaccess.vala b/vala/valaelementaccess.vala
index 1b60c6b07..96ae50860 100644
--- a/vala/valaelementaccess.vala
+++ b/vala/valaelementaccess.vala
@@ -96,14 +96,14 @@ public class Vala.ElementAccess : Expression {
 		return container.is_pure ();
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!container.check (analyzer)) {
+		if (!container.check (context)) {
 			/* don't proceed if a child expression failed */
 			error = true;
 			return false;
@@ -124,11 +124,11 @@ public class Vala.ElementAccess : Expression {
 				Report.error (source_reference, "Element access with more than one dimension is not supported for signals");
 				return false;
 			}
-			get_indices ().get (0).target_type = analyzer.string_type.copy ();
+			get_indices ().get (0).target_type = context.analyzer.string_type.copy ();
 		}
 
 		foreach (Expression index in get_indices ()) {
-			index.check (analyzer);
+			index.check (context);
 		}
 
 		bool index_int_type_check = true;
@@ -144,7 +144,7 @@ public class Vala.ElementAccess : Expression {
 			}
 		} else if (pointer_type != null && !pointer_type.base_type.is_reference_type_or_type_parameter ()) {
 			value_type = pointer_type.base_type.copy ();
-		} else if (analyzer.context.profile == Profile.DOVA && container_type == analyzer.tuple_type.data_type) {
+		} else if (context.profile == Profile.DOVA && container_type == context.analyzer.tuple_type.data_type) {
 			if (get_indices ().size != 1) {
 				error = true;
 				Report.error (source_reference, "Element access with more than one dimension is not supported for tuples");
@@ -177,7 +177,7 @@ public class Vala.ElementAccess : Expression {
 			get_call.add_argument (index);
 			get_call.target_type = this.target_type;
 			parent_node.replace_expression (this, get_call);
-			return get_call.check (analyzer);
+			return get_call.check (context);
 		} else if (container is MemberAccess && container.symbol_reference is Signal) {
 			index_int_type_check = false;
 
@@ -200,7 +200,7 @@ public class Vala.ElementAccess : Expression {
 					get_call.formal_target_type = this.formal_target_type;
 					get_call.target_type = this.target_type;
 					parent_node.replace_expression (this, get_call);
-					return get_call.check (analyzer);
+					return get_call.check (context);
 				}
 			}
 
diff --git a/vala/valaenum.vala b/vala/valaenum.vala
index 170d7e24e..f5fca292f 100644
--- a/vala/valaenum.vala
+++ b/vala/valaenum.vala
@@ -320,7 +320,7 @@ public class Vala.Enum : TypeSymbol {
 		return "0";
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -329,28 +329,28 @@ public class Vala.Enum : TypeSymbol {
 
 		process_attributes ();
 
-		var old_source_file = analyzer.current_source_file;
-		var old_symbol = analyzer.current_symbol;
+		var old_source_file = context.analyzer.current_source_file;
+		var old_symbol = context.analyzer.current_symbol;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
-		analyzer.current_symbol = this;
+		context.analyzer.current_symbol = this;
 
 		foreach (EnumValue value in values) {
-			value.check (analyzer);
+			value.check (context);
 		}
 
 		foreach (Method m in methods) {
-			m.check (analyzer);
+			m.check (context);
 		}
 
 		foreach (Constant c in constants) {
-			c.check (analyzer);
+			c.check (context);
 		}
 
-		analyzer.current_source_file = old_source_file;
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_source_file = old_source_file;
+		context.analyzer.current_symbol = old_symbol;
 
 		return !error;
 	}
diff --git a/vala/valaenumvalue.vala b/vala/valaenumvalue.vala
index 973bc554e..4a04b8569 100644
--- a/vala/valaenumvalue.vala
+++ b/vala/valaenumvalue.vala
@@ -79,7 +79,7 @@ public class Vala.EnumValue : Constant {
 		return "%s%s".printf (en.get_cprefix (), name);
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -89,7 +89,7 @@ public class Vala.EnumValue : Constant {
 		process_attributes ();
 
 		if (value != null) {
-			value.check (analyzer);
+			value.check (context);
 		}
 
 		return !error;
diff --git a/vala/valaerrorcode.vala b/vala/valaerrorcode.vala
index 24d7f60ec..4102feda0 100644
--- a/vala/valaerrorcode.vala
+++ b/vala/valaerrorcode.vala
@@ -77,7 +77,7 @@ public class Vala.ErrorCode : TypeSymbol {
 		return get_cname ().down ();
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -85,7 +85,7 @@ public class Vala.ErrorCode : TypeSymbol {
 		checked = true;
 
 		if (value != null) {
-			value.check (analyzer);
+			value.check (context);
 		}
 
 		return !error;
diff --git a/vala/valaerrordomain.vala b/vala/valaerrordomain.vala
index 40274f2f0..a17e4f84d 100644
--- a/vala/valaerrordomain.vala
+++ b/vala/valaerrordomain.vala
@@ -217,7 +217,7 @@ public class Vala.ErrorDomain : TypeSymbol {
 		return "g_value_set_pointer";
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -227,11 +227,11 @@ public class Vala.ErrorDomain : TypeSymbol {
 		process_attributes ();
 
 		foreach (ErrorCode ecode in codes) {
-			ecode.check (analyzer);
+			ecode.check (context);
 		}
 
 		foreach (Method m in methods) {
-			m.check (analyzer);
+			m.check (context);
 		}
 
 		return !error;
diff --git a/vala/valaerrortype.vala b/vala/valaerrortype.vala
index f0e9ab219..33f5e41fe 100644
--- a/vala/valaerrortype.vala
+++ b/vala/valaerrortype.vala
@@ -147,9 +147,9 @@ public class Vala.ErrorType : ReferenceType {
 		return true;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (error_domain != null) {
-			return error_domain.check (analyzer);
+			return error_domain.check (context);
 		}
 		return true;
 	}
diff --git a/vala/valaexpressionstatement.vala b/vala/valaexpressionstatement.vala
index c6450c01b..afca3775e 100644
--- a/vala/valaexpressionstatement.vala
+++ b/vala/valaexpressionstatement.vala
@@ -67,14 +67,14 @@ public class Vala.ExpressionStatement : CodeNode, Statement {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!expression.check (analyzer)) {
+		if (!expression.check (context)) {
 			// ignore inner error
 			error = true;
 			return false;
diff --git a/vala/valafield.vala b/vala/valafield.vala
index 1fae0fe8c..6bf48686a 100644
--- a/vala/valafield.vala
+++ b/vala/valafield.vala
@@ -260,20 +260,20 @@ public class Vala.Field : Variable, Lockable {
 		attr.add_argument ("type", "\"%s\"".printf (ctype));
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		var old_source_file = analyzer.current_source_file;
-		var old_symbol = analyzer.current_symbol;
+		var old_source_file = context.analyzer.current_source_file;
+		var old_symbol = context.analyzer.current_symbol;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
-		analyzer.current_symbol = this;
+		context.analyzer.current_symbol = this;
 
 		if (variable_type is VoidType) {
 			error = true;
@@ -281,10 +281,10 @@ public class Vala.Field : Variable, Lockable {
 			return false;
 		}
 
-		variable_type.check (analyzer);
+		variable_type.check (context);
 
 		// check whether field type is at least as accessible as the field
-		if (!analyzer.is_type_accessible (this, variable_type)) {
+		if (!context.analyzer.is_type_accessible (this, variable_type)) {
 			error = true;
 			Report.error (source_reference, "field type `%s` is less accessible than field `%s`".printf (variable_type.to_string (), get_full_name ()));
 			return false;
@@ -295,7 +295,7 @@ public class Vala.Field : Variable, Lockable {
 		if (initializer != null) {
 			initializer.target_type = variable_type;
 
-			if (!initializer.check (analyzer)) {
+			if (!initializer.check (context)) {
 				error = true;
 				return false;
 			}
@@ -337,8 +337,8 @@ public class Vala.Field : Variable, Lockable {
 			Report.warning (source_reference, "%s hides inherited field `%s'. Use the `new' keyword if hiding was intentional".printf (get_full_name (), get_hidden_member ().get_full_name ()));
 		}
 
-		analyzer.current_source_file = old_source_file;
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_source_file = old_source_file;
+		context.analyzer.current_symbol = old_symbol;
 
 		return !error;
 	}
diff --git a/vala/valaforeachstatement.vala b/vala/valaforeachstatement.vala
index 469c51e18..77d4f5603 100644
--- a/vala/valaforeachstatement.vala
+++ b/vala/valaforeachstatement.vala
@@ -146,7 +146,7 @@ public class Vala.ForeachStatement : Block {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -154,7 +154,7 @@ public class Vala.ForeachStatement : Block {
 		checked = true;
 
 		// analyze collection expression first, used for type inference
-		if (!collection.check (analyzer)) {
+		if (!collection.check (context)) {
 			// ignore inner error
 			error = true;
 			return false;
@@ -167,29 +167,29 @@ public class Vala.ForeachStatement : Block {
 		var collection_type = collection.value_type.copy ();
 		collection.target_type = collection_type.copy ();
 		
-		if (analyzer.context.profile != Profile.DOVA && collection_type.is_array ()) {
+		if (context.profile != Profile.DOVA && collection_type.is_array ()) {
 			var array_type = (ArrayType) collection_type;
 
 			// can't use inline-allocated array for temporary variable
 			array_type.inline_allocated = false;
 
-			return check_without_iterator (analyzer, collection_type, array_type.element_type);
-		} else if (analyzer.context.profile == Profile.GOBJECT && (collection_type.compatible (analyzer.glist_type) || collection_type.compatible (analyzer.gslist_type))) {
+			return check_without_iterator (context, collection_type, array_type.element_type);
+		} else if (context.profile == Profile.GOBJECT && (collection_type.compatible (context.analyzer.glist_type) || collection_type.compatible (context.analyzer.gslist_type))) {
 			if (collection_type.get_type_arguments ().size != 1) {
 				error = true;
 				Report.error (collection.source_reference, "missing type argument for collection");
 				return false;
 			}
 
-			return check_without_iterator (analyzer, collection_type, collection_type.get_type_arguments ().get (0));
-		} else if (analyzer.context.profile == Profile.GOBJECT && collection_type.compatible (analyzer.gvaluearray_type)) {
-			return check_without_iterator (analyzer, collection_type, analyzer.gvalue_type);
+			return check_without_iterator (context, collection_type, collection_type.get_type_arguments ().get (0));
+		} else if (context.profile == Profile.GOBJECT && collection_type.compatible (context.analyzer.gvaluearray_type)) {
+			return check_without_iterator (context, collection_type, context.analyzer.gvalue_type);
 		} else {
-			return check_with_iterator (analyzer, collection_type);
+			return check_with_iterator (context, collection_type);
 		}
 	}
 
-	bool check_with_index (SemanticAnalyzer analyzer, DataType collection_type) {
+	bool check_with_index (CodeContext context, DataType collection_type) {
 		var get_method = collection_type.get_member ("get") as Method;
 		if (get_method == null) {
 			return false;
@@ -215,13 +215,13 @@ public class Vala.ForeachStatement : Block {
 		body.insert_statement (0, new DeclarationStatement (new LocalVariable (type_reference, variable_name, get_call, source_reference), source_reference));
 
 		checked = false;
-		return base.check (analyzer);
+		return base.check (context);
 	}
 
-	bool check_with_iterator (SemanticAnalyzer analyzer, DataType collection_type) {
+	bool check_with_iterator (CodeContext context, DataType collection_type) {
 		use_iterator = true;
 
-		if (check_with_index (analyzer, collection_type)) {
+		if (check_with_index (context, collection_type)) {
 			return true;
 		}
 
@@ -278,7 +278,7 @@ public class Vala.ForeachStatement : Block {
 				error = true;
 				return false;
 			}
-			if (!next_method.return_type.compatible (analyzer.bool_type)) {
+			if (!next_method.return_type.compatible (context.analyzer.bool_type)) {
 				Report.error (collection.source_reference, "`%s' must return a boolean value".printf (next_method.get_full_name ()));
 				error = true;
 				return false;
@@ -318,7 +318,7 @@ public class Vala.ForeachStatement : Block {
 		}
 
 		checked = false;
-		return base.check (analyzer);
+		return base.check (context);
 	}
 
 	bool analyze_element_type (DataType element_type) {
@@ -339,7 +339,7 @@ public class Vala.ForeachStatement : Block {
 		return true;
 	}
 
-	bool check_without_iterator (SemanticAnalyzer analyzer, DataType collection_type, DataType element_type) {
+	bool check_without_iterator (CodeContext context, DataType collection_type, DataType element_type) {
 		// analyze element type
 		if (type_reference == null) {
 			// var type
@@ -359,16 +359,16 @@ public class Vala.ForeachStatement : Block {
 		element_variable.checked = true;
 
 		// analyze body
-		owner = analyzer.current_symbol.scope;
-		analyzer.current_symbol = this;
+		owner = context.analyzer.current_symbol.scope;
+		context.analyzer.current_symbol = this;
 
-		body.check (analyzer);
+		body.check (context);
 
 		foreach (LocalVariable local in get_local_variables ()) {
 			local.active = false;
 		}
 
-		analyzer.current_symbol = analyzer.current_symbol.parent_symbol;
+		context.analyzer.current_symbol = context.analyzer.current_symbol.parent_symbol;
 
 		collection_variable = new LocalVariable (collection_type, "%s_collection".printf (variable_name));
 
diff --git a/vala/valaforstatement.vala b/vala/valaforstatement.vala
index 6e8be3d90..555dc623c 100644
--- a/vala/valaforstatement.vala
+++ b/vala/valaforstatement.vala
@@ -146,7 +146,7 @@ public class Vala.ForStatement : CodeNode, Statement {
 		return (literal != null && !literal.value);
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		// convert to simple loop
 
 		var block = new Block (source_reference);
@@ -171,7 +171,7 @@ public class Vala.ForStatement : CodeNode, Statement {
 		}
 
 		// iterator
-		var first_local = new LocalVariable (analyzer.bool_type.copy (), get_temp_name (), new BooleanLiteral (true, source_reference), source_reference);
+		var first_local = new LocalVariable (context.analyzer.bool_type.copy (), get_temp_name (), new BooleanLiteral (true, source_reference), source_reference);
 		block.add_statement (new DeclarationStatement (first_local, source_reference));
 
 		var iterator_block = new Block (source_reference);
@@ -188,6 +188,6 @@ public class Vala.ForStatement : CodeNode, Statement {
 		var parent_block = (Block) parent_node;
 		parent_block.replace_statement (this, block);
 
-		return block.check (analyzer);
+		return block.check (context);
 	}
 }
diff --git a/vala/valaifstatement.vala b/vala/valaifstatement.vala
index 8cb1bac29..7655ffd15 100644
--- a/vala/valaifstatement.vala
+++ b/vala/valaifstatement.vala
@@ -102,20 +102,20 @@ public class Vala.IfStatement : CodeNode, Statement {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		condition.target_type = analyzer.bool_type.copy ();
+		condition.target_type = context.analyzer.bool_type.copy ();
 
-		condition.check (analyzer);
+		condition.check (context);
 
-		true_statement.check (analyzer);
+		true_statement.check (context);
 		if (false_statement != null) {
-			false_statement.check (analyzer);
+			false_statement.check (context);
 		}
 
 		if (condition.error) {
@@ -124,7 +124,7 @@ public class Vala.IfStatement : CodeNode, Statement {
 			return false;
 		}
 
-		if (condition.value_type == null || !condition.value_type.compatible (analyzer.bool_type)) {
+		if (condition.value_type == null || !condition.value_type.compatible (context.analyzer.bool_type)) {
 			error = true;
 			Report.error (condition.source_reference, "Condition must be boolean");
 			return false;
diff --git a/vala/valainitializerlist.vala b/vala/valainitializerlist.vala
index 5028caf27..5ed9ba86f 100644
--- a/vala/valainitializerlist.vala
+++ b/vala/valainitializerlist.vala
@@ -93,7 +93,7 @@ public class Vala.InitializerList : Expression {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -123,7 +123,7 @@ public class Vala.InitializerList : Expression {
 				old_parent_node.replace_expression (this, array_creation);
 
 				checked = false;
-				return array_creation.check (analyzer);
+				return array_creation.check (context);
 			}
 
 			DataType inner_target_type;
@@ -171,7 +171,7 @@ public class Vala.InitializerList : Expression {
 		}
 
 		foreach (Expression expr in initializers) {
-			expr.check (analyzer);
+			expr.check (context);
 		}
 
 		bool error = false;
diff --git a/vala/valaintegerliteral.vala b/vala/valaintegerliteral.vala
index 35f794fab..4a5295b30 100644
--- a/vala/valaintegerliteral.vala
+++ b/vala/valaintegerliteral.vala
@@ -59,7 +59,7 @@ public class Vala.IntegerLiteral : Literal {
 		return true;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -122,9 +122,9 @@ public class Vala.IntegerLiteral : Literal {
 			}
 		}
 
-		var st = (Struct) analyzer.root_symbol.scope.lookup (type_name);
+		var st = (Struct) context.analyzer.root_symbol.scope.lookup (type_name);
 		// ensure attributes are already processed in case of bootstrapping dova-core
-		st.check (analyzer);
+		st.check (context);
 
 		value_type = new IntegerType (st, value, type_name);
 
diff --git a/vala/valainterface.vala b/vala/valainterface.vala
index a7aa6e821..f5f9d08a6 100644
--- a/vala/valainterface.vala
+++ b/vala/valainterface.vala
@@ -585,7 +585,7 @@ public class Vala.Interface : ObjectTypeSymbol {
 		return null;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -594,17 +594,17 @@ public class Vala.Interface : ObjectTypeSymbol {
 
 		process_attributes ();
 
-		var old_source_file = analyzer.current_source_file;
-		var old_symbol = analyzer.current_symbol;
+		var old_source_file = context.analyzer.current_source_file;
+		var old_symbol = context.analyzer.current_symbol;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
-		analyzer.current_symbol = this;
+		context.analyzer.current_symbol = this;
 
 		foreach (DataType prerequisite_reference in get_prerequisites ()) {
 			// check whether prerequisite is at least as accessible as the interface
-			if (!analyzer.is_type_accessible (this, prerequisite_reference)) {
+			if (!context.analyzer.is_type_accessible (this, prerequisite_reference)) {
 				error = true;
 				Report.error (source_reference, "prerequisite `%s` is less accessible than interface `%s`".printf (prerequisite_reference.to_string (), get_full_name ()));
 				return false;
@@ -640,51 +640,51 @@ public class Vala.Interface : ObjectTypeSymbol {
 		}
 
 		foreach (DataType type in prerequisites) {
-			type.check (analyzer);
+			type.check (context);
 		}
 
 		foreach (TypeParameter p in get_type_parameters ()) {
-			p.check (analyzer);
+			p.check (context);
 		}
 
 		foreach (Enum en in enums) {
-			en.check (analyzer);
+			en.check (context);
 		}
 
 		foreach (Method m in methods) {
-			m.check (analyzer);
+			m.check (context);
 		}
 		
 		foreach (Field f in fields) {
-			f.check (analyzer);
+			f.check (context);
 		}
 
 		foreach (Constant c in constants) {
-			c.check (analyzer);
+			c.check (context);
 		}
 
 		foreach (Property prop in properties) {
-			prop.check (analyzer);
+			prop.check (context);
 		}
 		
 		foreach (Signal sig in signals) {
-			sig.check (analyzer);
+			sig.check (context);
 		}
 		
 		foreach (Class cl in classes) {
-			cl.check (analyzer);
+			cl.check (context);
 		}
 		
 		foreach (Struct st in structs) {
-			st.check (analyzer);
+			st.check (context);
 		}
 
 		foreach (Delegate d in delegates) {
-			d.check (analyzer);
+			d.check (context);
 		}
 
-		analyzer.current_source_file = old_source_file;
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_source_file = old_source_file;
+		context.analyzer.current_symbol = old_symbol;
 
 		return !error;
 	}
diff --git a/vala/valalambdaexpression.vala b/vala/valalambdaexpression.vala
index ac702ac6d..38310334b 100644
--- a/vala/valalambdaexpression.vala
+++ b/vala/valalambdaexpression.vala
@@ -111,15 +111,15 @@ public class Vala.LambdaExpression : Expression {
 		return false;
 	}
 
-	string get_lambda_name (SemanticAnalyzer analyzer) {
-		var result = "_lambda%d_".printf (analyzer.next_lambda_id);
+	string get_lambda_name (CodeContext context) {
+		var result = "_lambda%d_".printf (context.analyzer.next_lambda_id);
 
-		analyzer.next_lambda_id++;
+		context.analyzer.next_lambda_id++;
 
 		return result;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -134,15 +134,15 @@ public class Vala.LambdaExpression : Expression {
 
 		var cb = (Delegate) ((DelegateType) target_type).delegate_symbol;
 		var return_type = cb.return_type.get_actual_type (target_type, null, this);
-		method = new Method (get_lambda_name (analyzer), return_type, source_reference);
+		method = new Method (get_lambda_name (context), return_type, source_reference);
 		// track usage for flow analyzer
 		method.used = true;
 		method.check_deprecated (source_reference);
 
-		if (!cb.has_target || !analyzer.is_in_instance_method ()) {
+		if (!cb.has_target || !context.analyzer.is_in_instance_method ()) {
 			method.binding = MemberBinding.STATIC;
 		} else {
-			var sym = analyzer.current_symbol;
+			var sym = context.analyzer.current_symbol;
 			while (method.this_parameter == null) {
 				if (sym is Property) {
 					var prop = (Property) sym;
@@ -161,7 +161,7 @@ public class Vala.LambdaExpression : Expression {
 				sym = sym.parent_symbol;
 			}
 		}
-		method.owner = analyzer.current_symbol.scope;
+		method.owner = context.analyzer.current_symbol.scope;
 
 		if (!(method.return_type is VoidType) && CodeContext.get ().profile == Profile.DOVA) {
 			method.result_var = new LocalVariable (method.return_type.copy (), "result", null, source_reference);
@@ -208,7 +208,7 @@ public class Vala.LambdaExpression : Expression {
 			block.scope.parent_scope = method.scope;
 
 			if (method.return_type.data_type != null) {
-				if (analyzer.context.profile == Profile.DOVA) {
+				if (context.profile == Profile.DOVA) {
 					block.add_statement (new ExpressionStatement (new Assignment (new MemberAccess.simple ("result", source_reference), expression_body, AssignmentOperator.SIMPLE, source_reference), source_reference));
 					block.add_statement (new ReturnStatement (null, source_reference));
 				} else {
@@ -225,7 +225,7 @@ public class Vala.LambdaExpression : Expression {
 		method.body.owner = method.scope;
 
 		// support use of generics in closures
-		var m = analyzer.find_parent_method (analyzer.current_symbol);
+		var m = context.analyzer.find_parent_method (context.analyzer.current_symbol);
 		if (m != null) {
 			foreach (var type_param in m.get_type_parameters ()) {
 				method.add_type_parameter (new TypeParameter (type_param.name, type_param.source_reference));
@@ -238,7 +238,7 @@ public class Vala.LambdaExpression : Expression {
 		/* lambda expressions should be usable like MemberAccess of a method */
 		symbol_reference = method;
 
-		method.check (analyzer);
+		method.check (context);
 
 		value_type = new MethodType (method);
 		value_type.value_owned = target_type.value_owned;
diff --git a/vala/valalistliteral.vala b/vala/valalistliteral.vala
index e3c6d6de9..b8759d697 100644
--- a/vala/valalistliteral.vala
+++ b/vala/valalistliteral.vala
@@ -62,7 +62,7 @@ public class Vala.ListLiteral : Literal {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -80,12 +80,12 @@ public class Vala.ListLiteral : Literal {
 				initializer.append (expr);
 			}
 
-			analyzer.replaced_nodes.add (this);
+			context.analyzer.replaced_nodes.add (this);
 			parent_node.replace_expression (this, initializer);
-			return initializer.check (analyzer);
+			return initializer.check (context);
 		}
 
-		var list_type = new ObjectType ((Class) analyzer.context.root.scope.lookup ("Dova").scope.lookup ("List"));
+		var list_type = new ObjectType ((Class) context.root.scope.lookup ("Dova").scope.lookup ("List"));
 		list_type.value_owned = true;
 
 		bool fixed_element_type = false;
@@ -101,7 +101,7 @@ public class Vala.ListLiteral : Literal {
 			if (fixed_element_type) {
 				expr.target_type = element_type;
 			}
-			if (!expr.check (analyzer)) {
+			if (!expr.check (context)) {
 				return false;
 			}
 
diff --git a/vala/valalocalvariable.vala b/vala/valalocalvariable.vala
index 4ed1ec226..4fd8daf9f 100644
--- a/vala/valalocalvariable.vala
+++ b/vala/valalocalvariable.vala
@@ -77,7 +77,7 @@ public class Vala.LocalVariable : Variable {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -90,13 +90,13 @@ public class Vala.LocalVariable : Variable {
 				Report.error (source_reference, "'void' not supported as variable type");
 				return false;
 			}
-			variable_type.check (analyzer);
+			variable_type.check (context);
 		}
 
 		if (initializer != null) {
 			initializer.target_type = variable_type;
 
-			initializer.check (analyzer);
+			initializer.check (context);
 		}
 
 		if (variable_type == null) {
@@ -171,11 +171,11 @@ public class Vala.LocalVariable : Variable {
 			}
 		}
 
-		analyzer.current_symbol.scope.add (name, this);
+		context.analyzer.current_symbol.scope.add (name, this);
 
 		// current_symbol is a Method if this is the `result'
 		// variable used for postconditions
-		var block = analyzer.current_symbol as Block;
+		var block = context.analyzer.current_symbol as Block;
 		if (block != null) {
 			block.add_local_variable (this);
 		}
diff --git a/vala/valalockstatement.vala b/vala/valalockstatement.vala
index 39ad4e049..e0d4216f9 100644
--- a/vala/valalockstatement.vala
+++ b/vala/valalockstatement.vala
@@ -57,7 +57,7 @@ public class Vala.LockStatement : CodeNode, Statement {
 		visitor.visit_lock_statement (this);
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (body != null) {
 			// if the statement isn't empty, it is converted into a try statement
 
@@ -71,7 +71,7 @@ public class Vala.LockStatement : CodeNode, Statement {
 			var parent_block = (Block) parent_node;
 			parent_block.replace_statement (this, block);
 
-			return block.check (analyzer);
+			return block.check (context);
 		}
 
 		if (checked) {
@@ -80,7 +80,7 @@ public class Vala.LockStatement : CodeNode, Statement {
 
 		checked = true;
 
-		resource.check (analyzer);
+		resource.check (context);
 
 		/* resource must be a member access and denote a Lockable */
 		if (!(resource is MemberAccess && resource.symbol_reference is Lockable)) {
@@ -91,7 +91,7 @@ public class Vala.LockStatement : CodeNode, Statement {
 		}
 
 		/* parent symbol must be the current class */
-		if (resource.symbol_reference.parent_symbol != analyzer.current_class) {
+		if (resource.symbol_reference.parent_symbol != context.analyzer.current_class) {
 			error = true;
 			resource.error = true;
 			Report.error (resource.source_reference, "Only members of the current class are lockable");
diff --git a/vala/valaloop.vala b/vala/valaloop.vala
index e73174d7b..5782070f9 100644
--- a/vala/valaloop.vala
+++ b/vala/valaloop.vala
@@ -61,14 +61,14 @@ public class Vala.Loop : CodeNode, Statement {
 		body.accept (visitor);
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		body.check (analyzer);
+		body.check (context);
 
 		add_error_types (body.get_error_types ());
 
diff --git a/vala/valamapliteral.vala b/vala/valamapliteral.vala
index 9d4fe1064..3d1170d99 100644
--- a/vala/valamapliteral.vala
+++ b/vala/valamapliteral.vala
@@ -77,14 +77,14 @@ public class Vala.MapLiteral : Literal {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		var map_type = new ObjectType ((Class) analyzer.context.root.scope.lookup ("Dova").scope.lookup ("Map"));
+		var map_type = new ObjectType ((Class) context.root.scope.lookup ("Dova").scope.lookup ("Map"));
 		map_type.value_owned = true;
 
 		bool fixed_element_type = false;
@@ -101,10 +101,10 @@ public class Vala.MapLiteral : Literal {
 				keys[i].target_type = map_key_type;
 				values[i].target_type = map_value_type;
 			}
-			if (!keys[i].check (analyzer)) {
+			if (!keys[i].check (context)) {
 				return false;
 			}
-			if (!values[i].check (analyzer)) {
+			if (!values[i].check (context)) {
 				return false;
 			}
 			if (map_key_type == null) {
diff --git a/vala/valamemberaccess.vala b/vala/valamemberaccess.vala
index e02955262..e8983185b 100644
--- a/vala/valamemberaccess.vala
+++ b/vala/valamemberaccess.vala
@@ -182,7 +182,7 @@ public class Vala.MemberAccess : Expression {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -190,11 +190,11 @@ public class Vala.MemberAccess : Expression {
 		checked = true;
 
 		if (inner != null) {
-			inner.check (analyzer);
+			inner.check (context);
 		}
 		
 		foreach (DataType type_arg in type_argument_list) {
-			type_arg.check (analyzer);
+			type_arg.check (context);
 		}
 
 		Symbol base_symbol = null;
@@ -205,24 +205,24 @@ public class Vala.MemberAccess : Expression {
 		symbol_reference = null;
 
 		if (qualified) {
-			base_symbol = analyzer.root_symbol;
-			symbol_reference = analyzer.root_symbol.scope.lookup (member_name);
+			base_symbol = context.analyzer.root_symbol;
+			symbol_reference = context.analyzer.root_symbol.scope.lookup (member_name);
 		} else if (inner == null) {
 			if (member_name == "this") {
-				if (!analyzer.is_in_instance_method ()) {
+				if (!context.analyzer.is_in_instance_method ()) {
 					error = true;
 					Report.error (source_reference, "This access invalid outside of instance methods");
 					return false;
 				}
 			}
 
-			base_symbol = analyzer.current_symbol;
+			base_symbol = context.analyzer.current_symbol;
 
 			// track whether method has been found to make sure that access
 			// to instance member is denied from within static lambda expressions
 			bool method_found = false;
 
-			var sym = analyzer.current_symbol;
+			var sym = context.analyzer.current_symbol;
 			while (sym != null && symbol_reference == null) {
 				if (!method_found) {
 					if (sym is CreationMethod) {
@@ -258,7 +258,7 @@ public class Vala.MemberAccess : Expression {
 					}
 				}
 
-				symbol_reference = analyzer.symbol_lookup_inherited (sym, member_name);
+				symbol_reference = context.analyzer.symbol_lookup_inherited (sym, member_name);
 
 				if (symbol_reference == null) {
 					if (sym is TypeSymbol) {
@@ -297,7 +297,7 @@ public class Vala.MemberAccess : Expression {
 				if (pointer_type != null && pointer_type.base_type is ValueType) {
 					// transform foo->bar to (*foo).bar
 					inner = new PointerIndirection (inner, source_reference);
-					inner.check (analyzer);
+					inner.check (context);
 					pointer_member_access = false;
 				}
 			}
@@ -446,17 +446,17 @@ public class Vala.MemberAccess : Expression {
 		bool klass = false;
 		bool generics = false;
 
-		if (!member.check (analyzer)) {
+		if (!member.check (context)) {
 			return false;
 		}
 
 		if (member is LocalVariable) {
 			var local = (LocalVariable) member;
 			var block = local.parent_symbol as Block;
-			if (block != null && analyzer.find_parent_method_or_property_accessor (block) != analyzer.current_method_or_property_accessor) {
+			if (block != null && context.analyzer.find_parent_method_or_property_accessor (block) != context.analyzer.current_method_or_property_accessor) {
 				// mark all methods between current method and the captured
 				// block as closures (to support nested closures)
-				Symbol sym = analyzer.current_method_or_property_accessor;
+				Symbol sym = context.analyzer.current_method_or_property_accessor;
 				while (sym != block) {
 					var method = sym as Method;
 					if (method != null) {
@@ -474,10 +474,10 @@ public class Vala.MemberAccess : Expression {
 		} else if (member is Parameter) {
 			var param = (Parameter) member;
 			var m = param.parent_symbol as Method;
-			if (m != null && m != analyzer.current_method_or_property_accessor && param != m.this_parameter) {
+			if (m != null && m != context.analyzer.current_method_or_property_accessor && param != m.this_parameter) {
 				// mark all methods between current method and the captured
 				// parameter as closures (to support nested closures)
-				Symbol sym = analyzer.current_method_or_property_accessor;
+				Symbol sym = context.analyzer.current_method_or_property_accessor;
 				while (sym != m) {
 					var method = sym as Method;
 					if (method != null) {
@@ -495,10 +495,10 @@ public class Vala.MemberAccess : Expression {
 				}
 			} else {
 				var acc = param.parent_symbol.parent_symbol as PropertyAccessor;
-				if (acc != null && acc != analyzer.current_method_or_property_accessor && param != acc.prop.this_parameter) {
+				if (acc != null && acc != context.analyzer.current_method_or_property_accessor && param != acc.prop.this_parameter) {
 					// mark all methods between current method and the captured
 					// parameter as closures (to support nested closures)
-					Symbol sym = analyzer.current_method_or_property_accessor;
+					Symbol sym = context.analyzer.current_method_or_property_accessor;
 					while (sym != m) {
 						var method = sym as Method;
 						if (method != null) {
@@ -530,10 +530,10 @@ public class Vala.MemberAccess : Expression {
 			if (m.is_async_callback) {
 				// ensure to use right callback method for virtual/abstract async methods
 				// and also for lambda expressions within async methods
-				var async_method = analyzer.current_async_method;
+				var async_method = context.analyzer.current_async_method;
 
-				if (async_method != analyzer.current_method) {
-					Symbol sym = analyzer.current_method;
+				if (async_method != context.analyzer.current_method) {
+					Symbol sym = context.analyzer.current_method;
 					while (sym != async_method) {
 						var method = sym as Method;
 						if (method != null) {
@@ -587,7 +587,7 @@ public class Vala.MemberAccess : Expression {
 			}
 		} else if (member is Property) {
 			var prop = (Property) member;
-			if (!prop.check (analyzer)) {
+			if (!prop.check (context)) {
 				error = true;
 				return false;
 			}
@@ -647,7 +647,7 @@ public class Vala.MemberAccess : Expression {
 			var target_type = (TypeSymbol) member.parent_symbol;
 
 			bool in_subtype = false;
-			for (Symbol this_symbol = analyzer.current_symbol; this_symbol != null; this_symbol = this_symbol.parent_symbol) {
+			for (Symbol this_symbol = context.analyzer.current_symbol; this_symbol != null; this_symbol = this_symbol.parent_symbol) {
 				if (this_symbol == target_type) {
 					// required for interfaces with non-abstract methods
 					// accessing protected interface members
@@ -671,7 +671,7 @@ public class Vala.MemberAccess : Expression {
 			var target_type = member.parent_symbol;
 
 			bool in_target_type = false;
-			for (Symbol this_symbol = analyzer.current_symbol; this_symbol != null; this_symbol = this_symbol.parent_symbol) {
+			for (Symbol this_symbol = context.analyzer.current_symbol; this_symbol != null; this_symbol = this_symbol.parent_symbol) {
 				if (target_type == this_symbol) {
 					in_target_type = true;
 					break;
@@ -711,7 +711,7 @@ public class Vala.MemberAccess : Expression {
 				// also set static type for prototype access
 				// required when using instance methods as delegates in constants
 				// TODO replace by MethodPrototype
-				value_type = analyzer.get_value_type_for_symbol (symbol_reference, lvalue);
+				value_type = context.analyzer.get_value_type_for_symbol (symbol_reference, lvalue);
 			} else if (symbol_reference is Field) {
 				value_type = new FieldPrototype ((Field) symbol_reference);
 			} else {
@@ -729,12 +729,12 @@ public class Vala.MemberAccess : Expression {
 				inner.symbol_reference = this_parameter;
 			}
 
-			if (analyzer.context.experimental_non_null && instance && inner.value_type.nullable &&
+			if (context.experimental_non_null && instance && inner.value_type.nullable &&
 			    !(inner.value_type is PointerType) && !(inner.value_type is GenericType)) {
 				Report.error (source_reference, "Access to instance member `%s' from nullable reference denied".printf (symbol_reference.get_full_name ()));
 			}
 
-			formal_value_type = analyzer.get_value_type_for_symbol (symbol_reference, lvalue);
+			formal_value_type = context.analyzer.get_value_type_for_symbol (symbol_reference, lvalue);
 			if (inner != null && formal_value_type != null) {
 				value_type = formal_value_type.get_actual_type (inner.value_type, null, this);
 			} else {
@@ -758,7 +758,7 @@ public class Vala.MemberAccess : Expression {
 				}
 
 				if (instance && base_method.parent_symbol is TypeSymbol) {
-					inner.target_type = analyzer.get_data_type_for_symbol ((TypeSymbol) base_method.parent_symbol);
+					inner.target_type = context.analyzer.get_data_type_for_symbol ((TypeSymbol) base_method.parent_symbol);
 				}
 			} else if (symbol_reference is Property) {
 				var prop = (Property) symbol_reference;
@@ -773,12 +773,12 @@ public class Vala.MemberAccess : Expression {
 				}
 
 				if (instance && base_property.parent_symbol != null) {
-					inner.target_type = analyzer.get_data_type_for_symbol ((TypeSymbol) base_property.parent_symbol);
+					inner.target_type = context.analyzer.get_data_type_for_symbol ((TypeSymbol) base_property.parent_symbol);
 				}
 			} else if ((symbol_reference is Field
 			            || symbol_reference is Signal)
 			           && instance && symbol_reference.parent_symbol != null) {
-				inner.target_type = analyzer.get_data_type_for_symbol ((TypeSymbol) symbol_reference.parent_symbol);
+				inner.target_type = context.analyzer.get_data_type_for_symbol ((TypeSymbol) symbol_reference.parent_symbol);
 			}
 		}
 
diff --git a/vala/valamemberinitializer.vala b/vala/valamemberinitializer.vala
index afcb230e4..c5e5d8255 100644
--- a/vala/valamemberinitializer.vala
+++ b/vala/valamemberinitializer.vala
@@ -68,8 +68,8 @@ public class Vala.MemberInitializer : CodeNode {
 		initializer.accept (visitor);
 	}
 	
-	public override bool check (SemanticAnalyzer analyzer) {
-		return initializer.check (analyzer);
+	public override bool check (CodeContext context) {
+		return initializer.check (context);
 	}
 
 	public override void emit (CodeGenerator codegen) {
diff --git a/vala/valamethod.vala b/vala/valamethod.vala
index dcdbdeb9c..f8fe91633 100644
--- a/vala/valamethod.vala
+++ b/vala/valamethod.vala
@@ -786,7 +786,7 @@ public class Vala.Method : Symbol {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -846,21 +846,21 @@ public class Vala.Method : Symbol {
 			Report.error (source_reference, "Non-abstract, non-extern methods must have bodies");
 		}
 
-		if (coroutine && !external_package && !analyzer.context.has_package ("gio-2.0")) {
+		if (coroutine && !external_package && !context.has_package ("gio-2.0")) {
 			error = true;
 			Report.error (source_reference, "gio-2.0 package required for async methods");
 			return false;
 		}
 
-		var old_source_file = analyzer.current_source_file;
-		var old_symbol = analyzer.current_symbol;
+		var old_source_file = context.analyzer.current_source_file;
+		var old_symbol = context.analyzer.current_symbol;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
-		analyzer.current_symbol = this;
+		context.analyzer.current_symbol = this;
 
-		return_type.check (analyzer);
+		return_type.check (context);
 
 		var init_attr = get_attribute ("ModuleInit");
 		if (init_attr != null) {
@@ -868,7 +868,7 @@ public class Vala.Method : Symbol {
 		}
 
 		if (return_type != null) {
-			return_type.check (analyzer);
+			return_type.check (context);
 		}
 
 		if (parameters.size == 1 && parameters[0].ellipsis && body != null) {
@@ -878,7 +878,7 @@ public class Vala.Method : Symbol {
 		}
 
 		foreach (Parameter param in parameters) {
-			param.check (analyzer);
+			param.check (context);
 			if (coroutine && param.direction == ParameterDirection.REF) {
 				error = true;
 				Report.error (param.source_reference, "Reference parameters are not supported for async methods");
@@ -886,10 +886,10 @@ public class Vala.Method : Symbol {
 		}
 
 		foreach (DataType error_type in get_error_types ()) {
-			error_type.check (analyzer);
+			error_type.check (context);
 
 			// check whether error type is at least as accessible as the method
-			if (!analyzer.is_type_accessible (this, error_type)) {
+			if (!context.analyzer.is_type_accessible (this, error_type)) {
 				error = true;
 				Report.error (source_reference, "error type `%s` is less accessible than method `%s`".printf (error_type.to_string (), get_full_name ()));
 				return false;
@@ -897,29 +897,29 @@ public class Vala.Method : Symbol {
 		}
 
 		if (result_var != null) {
-			result_var.check (analyzer);
+			result_var.check (context);
 		}
 
 		if (preconditions != null) {
 			foreach (Expression precondition in preconditions) {
-				precondition.check (analyzer);
+				precondition.check (context);
 			}
 		}
 
 		if (postconditions != null) {
 			foreach (Expression postcondition in postconditions) {
-				postcondition.check (analyzer);
+				postcondition.check (context);
 			}
 		}
 
 		if (body != null) {
-			body.check (analyzer);
+			body.check (context);
 		}
 
-		analyzer.current_source_file = old_source_file;
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_source_file = old_source_file;
+		context.analyzer.current_symbol = old_symbol;
 
-		if (analyzer.current_struct != null) {
+		if (context.analyzer.current_struct != null) {
 			if (is_abstract || is_virtual || overrides) {
 				error = true;
 				Report.error (source_reference, "A struct member `%s' cannot be marked as override, virtual, or abstract".printf (get_full_name ()));
@@ -938,7 +938,7 @@ public class Vala.Method : Symbol {
 		}
 
 		// check whether return type is at least as accessible as the method
-		if (!analyzer.is_type_accessible (this, return_type)) {
+		if (!context.analyzer.is_type_accessible (this, return_type)) {
 			error = true;
 			Report.error (source_reference, "return type `%s` is less accessible than method `%s`".printf (return_type.to_string (), get_full_name ()));
 			return false;
@@ -951,7 +951,7 @@ public class Vala.Method : Symbol {
 				return false;
 			}
 
-			if (!precondition.value_type.compatible (analyzer.bool_type)) {
+			if (!precondition.value_type.compatible (context.analyzer.bool_type)) {
 				error = true;
 				Report.error (precondition.source_reference, "Precondition must be boolean");
 				return false;
@@ -965,7 +965,7 @@ public class Vala.Method : Symbol {
 				return false;
 			}
 
-			if (!postcondition.value_type.compatible (analyzer.bool_type)) {
+			if (!postcondition.value_type.compatible (context.analyzer.bool_type)) {
 				error = true;
 				Report.error (postcondition.source_reference, "Postcondition must be boolean");
 				return false;
@@ -988,16 +988,16 @@ public class Vala.Method : Symbol {
 			}
 		}
 
-		if (is_possible_entry_point (analyzer)) {
-			if (analyzer.context.entry_point != null) {
+		if (is_possible_entry_point (context)) {
+			if (context.entry_point != null) {
 				error = true;
-				Report.error (source_reference, "program already has an entry point `%s'".printf (analyzer.context.entry_point.get_full_name ()));
+				Report.error (source_reference, "program already has an entry point `%s'".printf (context.entry_point.get_full_name ()));
 				return false;
 			}
 			entry_point = true;
-			analyzer.context.entry_point = this;
+			context.entry_point = this;
 
-			if (tree_can_fail && analyzer.context.profile != Profile.DOVA) {
+			if (tree_can_fail && context.profile != Profile.DOVA) {
 				Report.error (source_reference, "\"main\" method cannot throw errors");
 			}
 		}
@@ -1005,19 +1005,19 @@ public class Vala.Method : Symbol {
 		return !error;
 	}
 
-	bool is_possible_entry_point (SemanticAnalyzer analyzer) {
+	bool is_possible_entry_point (CodeContext context) {
 		if (external_package) {
 			return false;
 		}
 
-		if (analyzer.context.entry_point_name == null) {
+		if (context.entry_point_name == null) {
 			if (name == null || name != "main") {
 				// method must be called "main"
 				return false;
 			}
 		} else {
 			// custom entry point name
-			if (get_full_name () != analyzer.context.entry_point_name) {
+			if (get_full_name () != context.entry_point_name) {
 				return false;
 			}
 		}
@@ -1028,7 +1028,7 @@ public class Vala.Method : Symbol {
 		}
 		
 		if (return_type is VoidType) {
-		} else if (return_type.data_type == analyzer.int_type.data_type) {
+		} else if (return_type.data_type == context.analyzer.int_type.data_type) {
 		} else {
 			// return type must be void or int
 			return false;
@@ -1060,7 +1060,7 @@ public class Vala.Method : Symbol {
 		}
 		
 		var array_type = (ArrayType) param.variable_type;
-		if (array_type.element_type.data_type != analyzer.string_type.data_type) {
+		if (array_type.element_type.data_type != context.analyzer.string_type.data_type) {
 			// parameter must be an array of strings
 			return false;
 		}
diff --git a/vala/valamethodcall.vala b/vala/valamethodcall.vala
index 6709fc0a3..ea3c556c2 100644
--- a/vala/valamethodcall.vala
+++ b/vala/valamethodcall.vala
@@ -128,14 +128,14 @@ public class Vala.MethodCall : Expression {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!call.check (analyzer)) {
+		if (!call.check (context)) {
 			/* if method resolving didn't succeed, skip this check */
 			error = true;
 			return false;
@@ -166,9 +166,9 @@ public class Vala.MethodCall : Expression {
 
 		var mtype = call.value_type;
 
-		if (mtype is ObjectType || (analyzer.context.profile == Profile.GOBJECT && call.symbol_reference == analyzer.object_type)) {
+		if (mtype is ObjectType || (context.profile == Profile.GOBJECT && call.symbol_reference == context.analyzer.object_type)) {
 			// constructor chain-up
-			var cm = analyzer.find_current_method () as CreationMethod;
+			var cm = context.analyzer.find_current_method () as CreationMethod;
 			if (cm == null) {
 				error = true;
 				Report.error (source_reference, "invocation not supported in this context");
@@ -196,12 +196,12 @@ public class Vala.MethodCall : Expression {
 			} else {
 				// GObject chain up
 				var cl = cm.parent_symbol as Class;
-				if (cl == null || !cl.is_subtype_of (analyzer.object_type)) {
+				if (cl == null || !cl.is_subtype_of (context.analyzer.object_type)) {
 					error = true;
 					Report.error (source_reference, "chain up to `GLib.Object' not supported");
 					return false;
 				}
-				call.value_type = new ObjectType (analyzer.object_type);
+				call.value_type = new ObjectType (context.analyzer.object_type);
 				mtype = call.value_type;
 			}
 		}
@@ -219,7 +219,7 @@ public class Vala.MethodCall : Expression {
 			}
 
 			if (is_chainup ()) {
-				var cm = analyzer.find_current_method () as CreationMethod;
+				var cm = context.analyzer.find_current_method () as CreationMethod;
 				if (cm != null) {
 					if (cm.chain_up) {
 						error = true;
@@ -235,14 +235,14 @@ public class Vala.MethodCall : Expression {
 				struct_creation_expression.add_argument (arg);
 			}
 			struct_creation_expression.target_type = target_type;
-			analyzer.replaced_nodes.add (this);
+			context.analyzer.replaced_nodes.add (this);
 			parent_node.replace_expression (this, struct_creation_expression);
-			struct_creation_expression.check (analyzer);
+			struct_creation_expression.check (context);
 			return true;
 		} else if (call is MemberAccess
 		           && call.symbol_reference is CreationMethod) {
 			// constructor chain-up
-			var cm = analyzer.find_current_method () as CreationMethod;
+			var cm = context.analyzer.find_current_method () as CreationMethod;
 			if (cm == null) {
 				error = true;
 				Report.error (source_reference, "use `new' operator to create new objects");
@@ -365,7 +365,7 @@ public class Vala.MethodCall : Expression {
 				if (format_literal == null && args.size == params.size - 1) {
 					// insert "%s" to avoid issues with embedded %
 					format_literal = new StringLiteral ("\"%s\"");
-					format_literal.target_type = analyzer.string_type.copy ();
+					format_literal.target_type = context.analyzer.string_type.copy ();
 					argument_list.insert (args.size - 1, format_literal);
 
 					// recreate iterator and skip to right position
@@ -444,36 +444,36 @@ public class Vala.MethodCall : Expression {
 					if (c == 'd' || c == 'i' || c == 'c') {
 						// integer
 						if (length == -2) {
-							param_type = analyzer.int8_type;
+							param_type = context.analyzer.int8_type;
 						} else if (length == -1) {
-							param_type = analyzer.short_type;
+							param_type = context.analyzer.short_type;
 						} else if (length == 0) {
-							param_type = analyzer.int_type;
+							param_type = context.analyzer.int_type;
 						} else if (length == 1) {
-							param_type = analyzer.long_type;
+							param_type = context.analyzer.long_type;
 						} else if (length == 2) {
-							param_type = analyzer.ssize_t_type;
+							param_type = context.analyzer.ssize_t_type;
 						}
 					} else if (c == 'o' || c == 'u' || c == 'x' || c == 'X') {
 						// unsigned integer
 						if (length == -2) {
-							param_type = analyzer.uchar_type;
+							param_type = context.analyzer.uchar_type;
 						} else if (length == -1) {
-							param_type = analyzer.ushort_type;
+							param_type = context.analyzer.ushort_type;
 						} else if (length == 0) {
-							param_type = analyzer.uint_type;
+							param_type = context.analyzer.uint_type;
 						} else if (length == 1) {
-							param_type = analyzer.ulong_type;
+							param_type = context.analyzer.ulong_type;
 						} else if (length == 2) {
-							param_type = analyzer.size_t_type;
+							param_type = context.analyzer.size_t_type;
 						}
 					} else if (c == 'e' || c == 'E' || c == 'f' || c == 'F'
 					           || c == 'g' || c == 'G' || c == 'a' || c == 'A') {
 						// double
-						param_type = analyzer.double_type;
+						param_type = context.analyzer.double_type;
 					} else if (c == 's') {
 						// string
-						param_type = analyzer.string_type;
+						param_type = context.analyzer.string_type;
 					} else if (c == 'p') {
 						// pointer
 						param_type = new PointerType (new VoidType ());
@@ -506,7 +506,7 @@ public class Vala.MethodCall : Expression {
 		}
 
 		foreach (Expression arg in get_argument_list ()) {
-			arg.check (analyzer);
+			arg.check (context);
 		}
 
 		if (ret_type is VoidType) {
@@ -534,11 +534,11 @@ public class Vala.MethodCall : Expression {
 					error = true;
 					Report.error (source_reference, "yield expression requires async method");
 				}
-				if (analyzer.current_method == null || !analyzer.current_method.coroutine) {
+				if (context.analyzer.current_method == null || !context.analyzer.current_method.coroutine) {
 					error = true;
 					Report.error (source_reference, "yield expression not available outside async method");
 				}
-				analyzer.current_method.yield_count++;
+				context.analyzer.current_method.yield_count++;
 			}
 			if (m != null && m.coroutine && !is_yield_expression && ((MemberAccess) call).member_name != "end") {
 				// .begin call of async method, no error can happen here
@@ -662,7 +662,7 @@ public class Vala.MethodCall : Expression {
 			}
 		}
 
-		if (!analyzer.check_arguments (this, mtype, params, get_argument_list ())) {
+		if (!context.analyzer.check_arguments (this, mtype, params, get_argument_list ())) {
 			error = true;
 			return false;
 		}
@@ -670,8 +670,8 @@ public class Vala.MethodCall : Expression {
 		if (may_throw) {
 			if (parent_node is LocalVariable || parent_node is ExpressionStatement) {
 				// simple statements, no side effects after method call
-			} else if (!(analyzer.current_symbol is Block)) {
-				if (analyzer.context.profile != Profile.DOVA) {
+			} else if (!(context.analyzer.current_symbol is Block)) {
+				if (context.profile != Profile.DOVA) {
 					// can't handle errors in field initializers
 					Report.error (source_reference, "Field initializers must not throw errors");
 				}
@@ -684,22 +684,22 @@ public class Vala.MethodCall : Expression {
 				local.floating = true;
 				var decl = new DeclarationStatement (local, source_reference);
 
-				insert_statement (analyzer.insert_block, decl);
+				insert_statement (context.analyzer.insert_block, decl);
 
 				Expression temp_access = new MemberAccess.simple (local.name, source_reference);
 				temp_access.target_type = target_type;
 
 				// don't set initializer earlier as this changes parent_node and parent_statement
 				local.initializer = this;
-				decl.check (analyzer);
-				temp_access.check (analyzer);
+				decl.check (context);
+				temp_access.check (context);
 
 				// move temp variable to insert block to ensure the
 				// variable is in the same block as the declaration
 				// otherwise there will be scoping issues in the generated code
-				var block = (Block) analyzer.current_symbol;
+				var block = (Block) context.analyzer.current_symbol;
 				block.remove_local_variable (local);
-				analyzer.insert_block.add_local_variable (local);
+				context.analyzer.insert_block.add_local_variable (local);
 
 				old_parent_node.replace_expression (this, temp_access);
 			}
diff --git a/vala/valanamedargument.vala b/vala/valanamedargument.vala
index 6b6764982..c88e8fce7 100644
--- a/vala/valanamedargument.vala
+++ b/vala/valanamedargument.vala
@@ -61,7 +61,7 @@ public class Vala.NamedArgument : Expression {
 		return inner.is_pure ();
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -70,7 +70,7 @@ public class Vala.NamedArgument : Expression {
 
 		inner.target_type = target_type;
 
-		if (!inner.check (analyzer)) {
+		if (!inner.check (context)) {
 			error = true;
 			return false;
 		}
diff --git a/vala/valanamespace.vala b/vala/valanamespace.vala
index 38bf9966b..45abd68de 100644
--- a/vala/valanamespace.vala
+++ b/vala/valanamespace.vala
@@ -606,7 +606,7 @@ public class Vala.Namespace : Symbol {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -616,7 +616,7 @@ public class Vala.Namespace : Symbol {
 		process_attributes ();
 
 		foreach (Namespace ns in namespaces) {
-			ns.check (analyzer);
+			ns.check (context);
 		}
 
 		return !error;
diff --git a/vala/valanullliteral.vala b/vala/valanullliteral.vala
index 94be504d1..b5f95d064 100644
--- a/vala/valanullliteral.vala
+++ b/vala/valanullliteral.vala
@@ -50,7 +50,7 @@ public class Vala.NullLiteral : Literal {
 		return true;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
diff --git a/vala/valaobjectcreationexpression.vala b/vala/valaobjectcreationexpression.vala
index f95aba84d..dac7d74ef 100644
--- a/vala/valaobjectcreationexpression.vala
+++ b/vala/valaobjectcreationexpression.vala
@@ -143,7 +143,7 @@ public class Vala.ObjectCreationExpression : Expression {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -151,7 +151,7 @@ public class Vala.ObjectCreationExpression : Expression {
 		checked = true;
 
 		if (member_name != null) {
-			member_name.check (analyzer);
+			member_name.check (context);
 		}
 
 		TypeSymbol type = null;
@@ -260,7 +260,7 @@ public class Vala.ObjectCreationExpression : Expression {
 
 			if (symbol_reference != null && symbol_reference.access == SymbolAccessibility.PRIVATE) {
 				bool in_target_type = false;
-				for (Symbol this_symbol = analyzer.current_symbol; this_symbol != null; this_symbol = this_symbol.parent_symbol) {
+				for (Symbol this_symbol = context.analyzer.current_symbol; this_symbol != null; this_symbol = this_symbol.parent_symbol) {
 					if (this_symbol == cl) {
 						in_target_type = true;
 						break;
@@ -287,7 +287,7 @@ public class Vala.ObjectCreationExpression : Expression {
 
 			expected_num_type_args = st.get_type_parameters ().size;
 
-			if (!struct_creation && !analyzer.context.deprecated) {
+			if (!struct_creation && !context.deprecated) {
 				Report.warning (source_reference, "deprecated syntax, don't use `new' to initialize structs");
 			}
 
@@ -333,10 +333,10 @@ public class Vala.ObjectCreationExpression : Expression {
 			}
 
 			foreach (Expression arg in args) {
-				arg.check (analyzer);
+				arg.check (context);
 			}
 
-			analyzer.check_arguments (this, new MethodType (m), m.get_parameters (), args);
+			context.analyzer.check_arguments (this, new MethodType (m), m.get_parameters (), args);
 
 			foreach (DataType error_type in m.get_error_types ()) {
 				may_throw = true;
@@ -349,19 +349,19 @@ public class Vala.ObjectCreationExpression : Expression {
 			}
 		} else if (type_reference is ErrorType) {
 			if (type_reference != null) {
-				type_reference.check (analyzer);
+				type_reference.check (context);
 			}
 
 			if (member_name != null) {
-				member_name.check (analyzer);
+				member_name.check (context);
 			}
 		
 			foreach (Expression arg in argument_list) {
-				arg.check (analyzer);
+				arg.check (context);
 			}
 
 			foreach (MemberInitializer init in object_initializer) {
-				init.check (analyzer);
+				init.check (context);
 			}
 
 			if (get_argument_list ().size == 0) {
@@ -371,7 +371,7 @@ public class Vala.ObjectCreationExpression : Expression {
 				Iterator<Expression> arg_it = get_argument_list ().iterator ();
 				arg_it.next ();
 				var ex = arg_it.get ();
-				if (ex.value_type == null || !ex.value_type.compatible (analyzer.string_type)) {
+				if (ex.value_type == null || !ex.value_type.compatible (context.analyzer.string_type)) {
 					error = true;
 					Report.error (source_reference, "Invalid type for argument 1");
 				}
@@ -379,14 +379,14 @@ public class Vala.ObjectCreationExpression : Expression {
 		}
 
 		foreach (MemberInitializer init in get_object_initializer ()) {
-			analyzer.visit_member_initializer (init, type_reference);
+			context.analyzer.visit_member_initializer (init, type_reference);
 		}
 
 		if (may_throw) {
 			if (parent_node is LocalVariable || parent_node is ExpressionStatement) {
 				// simple statements, no side effects after method call
-			} else if (!(analyzer.current_symbol is Block)) {
-				if (analyzer.context.profile != Profile.DOVA) {
+			} else if (!(context.analyzer.current_symbol is Block)) {
+				if (context.profile != Profile.DOVA) {
 					// can't handle errors in field initializers
 					Report.error (source_reference, "Field initializers must not throw errors");
 				}
@@ -399,22 +399,22 @@ public class Vala.ObjectCreationExpression : Expression {
 				local.floating = true;
 				var decl = new DeclarationStatement (local, source_reference);
 
-				insert_statement (analyzer.insert_block, decl);
+				insert_statement (context.analyzer.insert_block, decl);
 
 				Expression temp_access = new MemberAccess.simple (local.name, source_reference);
 				temp_access.target_type = target_type;
 
 				// don't set initializer earlier as this changes parent_node and parent_statement
 				local.initializer = this;
-				decl.check (analyzer);
-				temp_access.check (analyzer);
+				decl.check (context);
+				temp_access.check (context);
 
 				// move temp variable to insert block to ensure the
 				// variable is in the same block as the declaration
 				// otherwise there will be scoping issues in the generated code
-				var block = (Block) analyzer.current_symbol;
+				var block = (Block) context.analyzer.current_symbol;
 				block.remove_local_variable (local);
-				analyzer.insert_block.add_local_variable (local);
+				context.analyzer.insert_block.add_local_variable (local);
 
 				old_parent_node.replace_expression (this, temp_access);
 			}
diff --git a/vala/valaobjecttype.vala b/vala/valaobjecttype.vala
index ad37f6242..42187567e 100644
--- a/vala/valaobjecttype.vala
+++ b/vala/valaobjecttype.vala
@@ -105,12 +105,12 @@ public class Vala.ObjectType : ReferenceType {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
-		if (!type_symbol.check (analyzer)) {
+	public override bool check (CodeContext context) {
+		if (!type_symbol.check (context)) {
 			return false;
 		}
 
-		if (analyzer.context.profile == Profile.DOVA && type_symbol.get_full_name () == "Dova.Tuple") {
+		if (context.profile == Profile.DOVA && type_symbol.get_full_name () == "Dova.Tuple") {
 			// tuples have variadic generics
 			return true;
 		}
diff --git a/vala/valaparameter.vala b/vala/valaparameter.vala
index 9d17377f6..d73e25c6e 100644
--- a/vala/valaparameter.vala
+++ b/vala/valaparameter.vala
@@ -216,7 +216,7 @@ public class Vala.Parameter : Variable {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -225,13 +225,13 @@ public class Vala.Parameter : Variable {
 
 		process_attributes ();
 
-		var old_source_file = analyzer.current_source_file;
-		var old_symbol = analyzer.current_symbol;
+		var old_source_file = context.analyzer.current_source_file;
+		var old_symbol = context.analyzer.current_symbol;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
-		analyzer.current_symbol = parent_symbol;
+		context.analyzer.current_symbol = parent_symbol;
 
 		if (variable_type != null) {
 			if (variable_type is VoidType) {
@@ -239,11 +239,11 @@ public class Vala.Parameter : Variable {
 				Report.error (source_reference, "'void' not supported as parameter type");
 				return false;
 			}
-			variable_type.check (analyzer);
+			variable_type.check (context);
 		}
 
 		if (!ellipsis) {
-			variable_type.check (analyzer);
+			variable_type.check (context);
 			
 			if (params_array && !(variable_type is ArrayType)) {
 				error = true;
@@ -253,7 +253,7 @@ public class Vala.Parameter : Variable {
 
 			if (initializer != null) {
 				initializer.target_type = variable_type.copy ();
-				initializer.check (analyzer);
+				initializer.check (context);
 			}
 		}
 
@@ -267,14 +267,14 @@ public class Vala.Parameter : Variable {
 
 		if (!ellipsis) {
 			// check whether parameter type is at least as accessible as the method
-			if (!analyzer.is_type_accessible (this, variable_type)) {
+			if (!context.analyzer.is_type_accessible (this, variable_type)) {
 				error = true;
 				Report.error (source_reference, "parameter type `%s` is less accessible than method `%s`".printf (variable_type.to_string (), parent_symbol.get_full_name ()));
 			}
 		}
 
-		analyzer.current_source_file = old_source_file;
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_source_file = old_source_file;
+		context.analyzer.current_symbol = old_symbol;
 
 		return !error;
 	}
diff --git a/vala/valapointerindirection.vala b/vala/valapointerindirection.vala
index 17295e4a5..424958bd8 100644
--- a/vala/valapointerindirection.vala
+++ b/vala/valapointerindirection.vala
@@ -69,14 +69,14 @@ public class Vala.PointerIndirection : Expression {
 		return inner.is_pure ();
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!inner.check (analyzer)) {
+		if (!inner.check (context)) {
 			return false;
 		}
 		if (inner.value_type == null) {
diff --git a/vala/valapointertype.vala b/vala/valapointertype.vala
index 9d11d8d34..d7da3d866 100644
--- a/vala/valapointertype.vala
+++ b/vala/valapointertype.vala
@@ -140,8 +140,8 @@ public class Vala.PointerType : DataType {
 		return false;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
-		error = !base_type.check (analyzer);
+	public override bool check (CodeContext context) {
+		error = !base_type.check (context);
 		return !error;
 	}
 }
diff --git a/vala/valapostfixexpression.vala b/vala/valapostfixexpression.vala
index 57969b0d3..065381ae0 100644
--- a/vala/valapostfixexpression.vala
+++ b/vala/valapostfixexpression.vala
@@ -64,14 +64,14 @@ public class Vala.PostfixExpression : Expression {
 		return false;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!inner.check (analyzer)) {
+		if (!inner.check (context)) {
 			error = true;
 			return false;
 		}
diff --git a/vala/valaproperty.vala b/vala/valaproperty.vala
index ae2d022b9..467cdf84e 100644
--- a/vala/valaproperty.vala
+++ b/vala/valaproperty.vala
@@ -419,7 +419,7 @@ public class Vala.Property : Symbol, Lockable {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -470,13 +470,13 @@ public class Vala.Property : Symbol, Lockable {
 			}
 		}
 
-		var old_source_file = analyzer.current_source_file;
-		var old_symbol = analyzer.current_symbol;
+		var old_source_file = context.analyzer.current_source_file;
+		var old_symbol = context.analyzer.current_symbol;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
-		analyzer.current_symbol = this;
+		context.analyzer.current_symbol = this;
 
 		if (property_type is VoidType) {
 			error = true;
@@ -484,21 +484,21 @@ public class Vala.Property : Symbol, Lockable {
 			return false;
 		}
 
-		property_type.check (analyzer);
+		property_type.check (context);
 
 		if (get_accessor != null) {
-			get_accessor.check (analyzer);
+			get_accessor.check (context);
 		}
 		if (set_accessor != null) {
-			set_accessor.check (analyzer);
+			set_accessor.check (context);
 		}
 
 		if (initializer != null) {
-			initializer.check (analyzer);
+			initializer.check (context);
 		}
 
 		// check whether property type is at least as accessible as the property
-		if (!analyzer.is_type_accessible (this, property_type)) {
+		if (!context.analyzer.is_type_accessible (this, property_type)) {
 			error = true;
 			Report.error (source_reference, "property type `%s` is less accessible than property `%s`".printf (property_type.to_string (), get_full_name ()));
 		}
@@ -524,8 +524,8 @@ public class Vala.Property : Symbol, Lockable {
 			Report.error (initializer.source_reference, "Expected initializer of type `%s' but got `%s'".printf (property_type.to_string (), initializer.value_type.to_string ()));
 		}
 
-		analyzer.current_source_file = old_source_file;
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_source_file = old_source_file;
+		context.analyzer.current_symbol = old_symbol;
 
 		return !error;
 	}
diff --git a/vala/valapropertyaccessor.vala b/vala/valapropertyaccessor.vala
index 2b5ed82cd..5579e8bd9 100644
--- a/vala/valapropertyaccessor.vala
+++ b/vala/valapropertyaccessor.vala
@@ -170,7 +170,7 @@ public class Vala.PropertyAccessor : Symbol {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -179,14 +179,14 @@ public class Vala.PropertyAccessor : Symbol {
 
 		process_attributes ();
 
-		if (!value_type.check (analyzer)) {
+		if (!value_type.check (context)) {
 			error = true;
 			return false;
 		}
 
-		var old_symbol = analyzer.current_symbol;
+		var old_symbol = context.analyzer.current_symbol;
 
-		analyzer.current_symbol = this;
+		context.analyzer.current_symbol = this;
 
 		if (prop.source_type == SourceFileType.SOURCE) {
 			if (body == null && !prop.interface_only && !prop.is_abstract) {
@@ -201,7 +201,7 @@ public class Vala.PropertyAccessor : Symbol {
 				body = new Block (source_reference);
 				var ma = new MemberAccess.simple ("_%s".printf (prop.name), source_reference);
 				if (readable) {
-					if (analyzer.context.profile == Profile.DOVA) {
+					if (context.profile == Profile.DOVA) {
 						body.add_statement (new ExpressionStatement (new Assignment (new MemberAccess.simple ("result", source_reference), ma, AssignmentOperator.SIMPLE, source_reference), source_reference));
 						body.add_statement (new ReturnStatement (null, source_reference));
 					} else {
@@ -215,19 +215,19 @@ public class Vala.PropertyAccessor : Symbol {
 		}
 
 		if (body != null) {
-			if (readable && analyzer.context.profile == Profile.DOVA) {
+			if (readable && context.profile == Profile.DOVA) {
 				result_var = new LocalVariable (value_type.copy (), "result", null, source_reference);
 				result_var.is_result = true;
 
-				result_var.check (analyzer);
+				result_var.check (context);
 			} else if (writable || construction) {
 				value_parameter = new Parameter ("value", value_type, source_reference);
 				body.scope.add (value_parameter.name, value_parameter);
 			}
 
-			body.check (analyzer);
+			body.check (context);
 
-			if (analyzer.context.profile != Profile.DOVA) {
+			if (context.profile != Profile.DOVA) {
 				foreach (DataType body_error_type in body.get_error_types ()) {
 					if (!((ErrorType) body_error_type).dynamic_error) {
 						Report.warning (body_error_type.source_reference, "unhandled error `%s'".printf (body_error_type.to_string()));
@@ -236,7 +236,7 @@ public class Vala.PropertyAccessor : Symbol {
 			}
 		}
 
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_symbol = old_symbol;
 
 		return !error;
 	}
diff --git a/vala/valarealliteral.vala b/vala/valarealliteral.vala
index f45560f9f..0acfb8893 100644
--- a/vala/valarealliteral.vala
+++ b/vala/valarealliteral.vala
@@ -70,16 +70,16 @@ public class Vala.RealLiteral : Literal {
 		return value;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		var st = (Struct) analyzer.root_symbol.scope.lookup (get_type_name ());
+		var st = (Struct) context.analyzer.root_symbol.scope.lookup (get_type_name ());
 		// ensure attributes are already processed in case of bootstrapping dova-core
-		st.check (analyzer);
+		st.check (context);
 
 		value_type = new FloatingType (st);
 
diff --git a/vala/valareferencetransferexpression.vala b/vala/valareferencetransferexpression.vala
index 945593fb7..5e34282c3 100644
--- a/vala/valareferencetransferexpression.vala
+++ b/vala/valareferencetransferexpression.vala
@@ -71,7 +71,7 @@ public class Vala.ReferenceTransferExpression : Expression {
 		return false;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -80,7 +80,7 @@ public class Vala.ReferenceTransferExpression : Expression {
 
 		inner.lvalue = true;
 
-		inner.check (analyzer);
+		inner.check (context);
 
 		if (inner.error) {
 			/* if there was an error in the inner expression, skip type check */
diff --git a/vala/valaregexliteral.vala b/vala/valaregexliteral.vala
index 8e4cdc62b..e8c9fa811 100644
--- a/vala/valaregexliteral.vala
+++ b/vala/valaregexliteral.vala
@@ -62,14 +62,14 @@ public class Vala.RegexLiteral : Literal {
 		return value;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!analyzer.context.experimental) {
+		if (!context.experimental) {
 			Report.warning (source_reference, "regular expression literals are experimental");
 		}
 
@@ -82,7 +82,7 @@ public class Vala.RegexLiteral : Literal {
 			return false;
 		}
 
-		value_type = analyzer.regex_type.copy ();
+		value_type = context.analyzer.regex_type.copy ();
 
 		return !error;
 	}
diff --git a/vala/valareturnstatement.vala b/vala/valareturnstatement.vala
index b8b2e8323..39aff8259 100644
--- a/vala/valareturnstatement.vala
+++ b/vala/valareturnstatement.vala
@@ -70,7 +70,7 @@ public class Vala.ReturnStatement : CodeNode, Statement {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -78,35 +78,35 @@ public class Vala.ReturnStatement : CodeNode, Statement {
 		checked = true;
 
 		if (return_expression != null) {
-			return_expression.target_type = analyzer.current_return_type;
+			return_expression.target_type = context.analyzer.current_return_type;
 		}
 
-		if (return_expression != null && !return_expression.check (analyzer)) {
+		if (return_expression != null && !return_expression.check (context)) {
 			// ignore inner error
 			error = true;
 			return false;
 		}
 
-		if (analyzer.current_return_type == null) {
+		if (context.analyzer.current_return_type == null) {
 			error = true;
 			Report.error (source_reference, "Return not allowed in this context");
 			return false;
 		}
 
-		if (analyzer.context.profile == Profile.DOVA) {
+		if (context.profile == Profile.DOVA) {
 			// no return expressions in Dova profile
 			return !error;
 		}
 
 		if (return_expression == null) {
-			if (!(analyzer.current_return_type is VoidType)) {
+			if (!(context.analyzer.current_return_type is VoidType)) {
 				error = true;
 				Report.error (source_reference, "Return without value in non-void function");
 			}
 			return !error;
 		}
 
-		if (analyzer.current_return_type is VoidType) {
+		if (context.analyzer.current_return_type is VoidType) {
 			Report.error (source_reference, "Return with value in void function");
 			return false;
 		}
@@ -117,14 +117,14 @@ public class Vala.ReturnStatement : CodeNode, Statement {
 			return false;
 		}
 
-		if (!return_expression.value_type.compatible (analyzer.current_return_type)) {
+		if (!return_expression.value_type.compatible (context.analyzer.current_return_type)) {
 			error = true;
-			Report.error (source_reference, "Return: Cannot convert from `%s' to `%s'".printf (return_expression.value_type.to_string (), analyzer.current_return_type.to_string ()));
+			Report.error (source_reference, "Return: Cannot convert from `%s' to `%s'".printf (return_expression.value_type.to_string (), context.analyzer.current_return_type.to_string ()));
 			return false;
 		}
 
 		if (return_expression.value_type.is_disposable () &&
-		    !analyzer.current_return_type.value_owned) {
+		    !context.analyzer.current_return_type.value_owned) {
 			error = true;
 			Report.error (source_reference, "Return value transfers ownership but method return type hasn't been declared to transfer ownership");
 			return false;
@@ -132,15 +132,15 @@ public class Vala.ReturnStatement : CodeNode, Statement {
 
 		var local = return_expression.symbol_reference as LocalVariable;
 		if (local != null && local.variable_type.is_disposable () &&
-		    !analyzer.current_return_type.value_owned) {
+		    !context.analyzer.current_return_type.value_owned) {
 			error = true;
 			Report.error (source_reference, "Local variable with strong reference used as return value and method return type has not been declared to transfer ownership");
 			return false;
 		}
 
 		if (return_expression is NullLiteral
-		    && !analyzer.current_return_type.nullable) {
-			Report.warning (source_reference, "`null' incompatible with return type `%s`".printf (analyzer.current_return_type.to_string ()));
+		    && !context.analyzer.current_return_type.nullable) {
+			Report.warning (source_reference, "`null' incompatible with return type `%s`".printf (context.analyzer.current_return_type.to_string ()));
 		}
 
 		add_error_types (return_expression.get_error_types ());
diff --git a/vala/valasemanticanalyzer.vala b/vala/valasemanticanalyzer.vala
index 32709cc4c..7891bc568 100644
--- a/vala/valasemanticanalyzer.vala
+++ b/vala/valasemanticanalyzer.vala
@@ -232,14 +232,14 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
 		}
 
 		current_symbol = root_symbol;
-		context.root.check (this);
+		context.root.check (context);
 		context.accept (this);
 	}
 
 	public override void visit_source_file (SourceFile file) {
 		current_source_file = file;
 
-		file.check (this);
+		file.check (context);
 	}
 
 	// check whether type is at least as accessible as the specified symbol
@@ -387,7 +387,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
 		bool ellipsis = false;
 		int i = 0;
 		foreach (Parameter param in params) {
-			if (!param.check (this)) {
+			if (!param.check (context)) {
 				return false;
 			}
 
@@ -799,7 +799,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
 		init.initializer.formal_target_type = member_type;
 		init.initializer.target_type = init.initializer.formal_target_type.get_actual_type (type, null, init);;
 
-		init.check (this);
+		init.check (context);
 
 		if (init.initializer.value_type == null || !init.initializer.value_type.compatible (init.initializer.target_type)) {
 			init.error = true;
diff --git a/vala/valasetliteral.vala b/vala/valasetliteral.vala
index 5ae8e94bb..d0f122891 100644
--- a/vala/valasetliteral.vala
+++ b/vala/valasetliteral.vala
@@ -62,14 +62,14 @@ public class Vala.SetLiteral : Literal {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		var set_type = new ObjectType ((Class) analyzer.context.root.scope.lookup ("Dova").scope.lookup ("Set"));
+		var set_type = new ObjectType ((Class) context.root.scope.lookup ("Dova").scope.lookup ("Set"));
 		set_type.value_owned = true;
 
 		bool fixed_element_type = false;
@@ -85,7 +85,7 @@ public class Vala.SetLiteral : Literal {
 			if (fixed_element_type) {
 				expr.target_type = element_type;
 			}
-			if (!expr.check (analyzer)) {
+			if (!expr.check (context)) {
 				return false;
 			}
 
diff --git a/vala/valasignal.vala b/vala/valasignal.vala
index 7e2a01aef..6530c449d 100644
--- a/vala/valasignal.vala
+++ b/vala/valasignal.vala
@@ -266,7 +266,7 @@ public class Vala.Signal : Symbol, Lockable {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -275,10 +275,10 @@ public class Vala.Signal : Symbol, Lockable {
 
 		process_attributes ();
 
-		return_type.check (analyzer);
+		return_type.check (context);
 		
 		foreach (Parameter param in parameters) {
-			param.check (analyzer);
+			param.check (context);
 		}
 
 		if (!is_virtual && body != null) {
@@ -305,7 +305,7 @@ public class Vala.Signal : Symbol, Lockable {
 			var cl = parent_symbol as ObjectTypeSymbol;
 
 			cl.add_hidden_method (default_handler);
-			default_handler.check (analyzer);
+			default_handler.check (context);
 		}
 
 
diff --git a/vala/valasizeofexpression.vala b/vala/valasizeofexpression.vala
index 10643890c..01fda86c5 100644
--- a/vala/valasizeofexpression.vala
+++ b/vala/valasizeofexpression.vala
@@ -71,16 +71,16 @@ public class Vala.SizeofExpression : Expression {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		type_reference.check (analyzer);
+		type_reference.check (context);
 
-		value_type = analyzer.ulong_type;
+		value_type = context.analyzer.ulong_type;
 
 		return !error;
 	}
diff --git a/vala/valasliceexpression.vala b/vala/valasliceexpression.vala
index 77c574397..4680a1bff 100644
--- a/vala/valasliceexpression.vala
+++ b/vala/valasliceexpression.vala
@@ -98,24 +98,24 @@ public class Vala.SliceExpression : Expression {
 		return false;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!container.check (analyzer)) {
+		if (!container.check (context)) {
 			error = true;
 			return false;
 		}
 
-		if (!start.check (analyzer)) {
+		if (!start.check (context)) {
 			error = true;
 			return false;
 		}
 
-		if (!stop.check (analyzer)) {
+		if (!stop.check (context)) {
 			error = true;
 			return false;
 		}
@@ -153,7 +153,7 @@ public class Vala.SliceExpression : Expression {
 				slice_call.add_argument (stop);
 				slice_call.target_type = this.target_type;
 				parent_node.replace_expression (this, slice_call);
-				return slice_call.check (analyzer);
+				return slice_call.check (context);
 			}
 
 			error = true;
diff --git a/vala/valasourcefile.vala b/vala/valasourcefile.vala
index 90433589b..931f02010 100644
--- a/vala/valasourcefile.vala
+++ b/vala/valasourcefile.vala
@@ -312,9 +312,9 @@ public class Vala.SourceFile {
 		return mapped_file.get_length ();
 	}
 
-	public bool check (SemanticAnalyzer analyzer) {
+	public bool check (CodeContext context) {
 		foreach (CodeNode node in nodes) {
-			node.check (analyzer);
+			node.check (context);
 		}
 		return true;
 	}
diff --git a/vala/valastringliteral.vala b/vala/valastringliteral.vala
index e0234bd30..69fc4d79b 100644
--- a/vala/valastringliteral.vala
+++ b/vala/valastringliteral.vala
@@ -77,14 +77,14 @@ public class Vala.StringLiteral : Literal {
 		return value;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		value_type = analyzer.string_type.copy ();
+		value_type = context.analyzer.string_type.copy ();
 
 		return !error;
 	}
diff --git a/vala/valastruct.vala b/vala/valastruct.vala
index 906ce41d9..cab1b820a 100644
--- a/vala/valastruct.vala
+++ b/vala/valastruct.vala
@@ -817,7 +817,7 @@ public class Vala.Struct : TypeSymbol {
 		return false;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -826,16 +826,16 @@ public class Vala.Struct : TypeSymbol {
 
 		process_attributes ();
 
-		var old_source_file = analyzer.current_source_file;
-		var old_symbol = analyzer.current_symbol;
+		var old_source_file = context.analyzer.current_source_file;
+		var old_symbol = context.analyzer.current_symbol;
 
 		if (source_reference != null) {
-			analyzer.current_source_file = source_reference.file;
+			context.analyzer.current_source_file = source_reference.file;
 		}
-		analyzer.current_symbol = this;
+		context.analyzer.current_symbol = this;
 
 		if (base_type != null) {
-			base_type.check (analyzer);
+			base_type.check (context);
 
 			if (!(base_type is ValueType)) {
 				error = true;
@@ -845,11 +845,11 @@ public class Vala.Struct : TypeSymbol {
 		}
 
 		foreach (TypeParameter p in type_parameters) {
-			p.check (analyzer);
+			p.check (context);
 		}
 
 		foreach (Field f in fields) {
-			f.check (analyzer);
+			f.check (context);
 
 			if (f.binding == MemberBinding.INSTANCE && is_recursive_value_type (f.variable_type)) {
 				error = true;
@@ -865,15 +865,15 @@ public class Vala.Struct : TypeSymbol {
 		}
 
 		foreach (Constant c in constants) {
-			c.check (analyzer);
+			c.check (context);
 		}
 
 		foreach (Method m in methods) {
-			m.check (analyzer);
+			m.check (context);
 		}
 
 		foreach (Property prop in properties) {
-			prop.check (analyzer);
+			prop.check (context);
 		}
 
 		if (!external && !external_package) {
@@ -891,8 +891,8 @@ public class Vala.Struct : TypeSymbol {
 			}
 		}
 
-		analyzer.current_source_file = old_source_file;
-		analyzer.current_symbol = old_symbol;
+		context.analyzer.current_source_file = old_source_file;
+		context.analyzer.current_symbol = old_symbol;
 
 		return !error;
 	}
diff --git a/vala/valaswitchlabel.vala b/vala/valaswitchlabel.vala
index 2a15d96c0..9468b0ed3 100644
--- a/vala/valaswitchlabel.vala
+++ b/vala/valaswitchlabel.vala
@@ -67,9 +67,9 @@ public class Vala.SwitchLabel : CodeNode {
 		}
 	}
 	
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (expression != null) {
-			expression.check (analyzer);
+			expression.check (context);
 
 			var switch_statement = (SwitchStatement) section.parent_node;
 			if (!expression.is_constant ()) {
diff --git a/vala/valaswitchsection.vala b/vala/valaswitchsection.vala
index c8faae564..ce8180507 100644
--- a/vala/valaswitchsection.vala
+++ b/vala/valaswitchsection.vala
@@ -81,7 +81,7 @@ public class Vala.SwitchSection : Block {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -89,18 +89,18 @@ public class Vala.SwitchSection : Block {
 		checked = true;
 
 		foreach (SwitchLabel label in get_labels ()) {
-			label.check (analyzer);
+			label.check (context);
 		}
 
-		owner = analyzer.current_symbol.scope;
+		owner = context.analyzer.current_symbol.scope;
 
-		var old_symbol = analyzer.current_symbol;
-		var old_insert_block = analyzer.insert_block;
-		analyzer.current_symbol = this;
-		analyzer.insert_block = this;
+		var old_symbol = context.analyzer.current_symbol;
+		var old_insert_block = context.analyzer.insert_block;
+		context.analyzer.current_symbol = this;
+		context.analyzer.insert_block = this;
 
 		foreach (Statement st in get_statements ()) {
-			st.check (analyzer);
+			st.check (context);
 		}
 
 		foreach (LocalVariable local in get_local_variables ()) {
@@ -112,8 +112,8 @@ public class Vala.SwitchSection : Block {
 			add_error_types (stmt.get_error_types ());
 		}
 
-		analyzer.current_symbol = old_symbol;
-		analyzer.insert_block = old_insert_block;
+		context.analyzer.current_symbol = old_symbol;
+		context.analyzer.insert_block = old_insert_block;
 
 		return !error;
 	}
diff --git a/vala/valaswitchstatement.vala b/vala/valaswitchstatement.vala
index c2066c51c..6509d49f1 100644
--- a/vala/valaswitchstatement.vala
+++ b/vala/valaswitchstatement.vala
@@ -93,14 +93,14 @@ public class Vala.SwitchStatement : CodeNode, Statement {
 		}
 	}
 	
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (!expression.check (analyzer)) {
+		if (!expression.check (context)) {
 			error = true;
 			return false;
 		}
@@ -108,7 +108,7 @@ public class Vala.SwitchStatement : CodeNode, Statement {
 		if (expression.value_type == null ||
 		    (!(expression.value_type is IntegerType) &&
 		     !(expression.value_type is EnumValueType) &&
-		     !expression.value_type.compatible (analyzer.string_type))) {
+		     !expression.value_type.compatible (context.analyzer.string_type))) {
 			Report.error (expression.source_reference, "Integer or string expression expected");
 			error = true;
 			return false;
@@ -119,7 +119,7 @@ public class Vala.SwitchStatement : CodeNode, Statement {
 
 		var labelset = new HashSet<string> (str_hash, str_equal);
 		foreach (SwitchSection section in sections) {
-			section.check (analyzer);
+			section.check (context);
 
 			// check for duplicate literal case labels
 			// FIXME: make it work for all constant expressions
diff --git a/vala/valatemplate.vala b/vala/valatemplate.vala
index c329c5ca1..d11c0c87c 100644
--- a/vala/valatemplate.vala
+++ b/vala/valatemplate.vala
@@ -58,7 +58,7 @@ public class Vala.Template : Expression {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -72,7 +72,7 @@ public class Vala.Template : Expression {
 		} else {
 			expr = stringify (expression_list[0]);
 			if (expression_list.size > 1) {
-				if (analyzer.context.profile == Profile.DOVA) {
+				if (context.profile == Profile.DOVA) {
 					// varargs concat not yet supported
 					for (int i = 1; i < expression_list.size; i++) {
 						expr = new BinaryExpression (BinaryOperator.PLUS, expr, stringify (expression_list[i]), source_reference);
@@ -88,9 +88,9 @@ public class Vala.Template : Expression {
 		}
 		expr.target_type = target_type;
 
-		analyzer.replaced_nodes.add (this);
+		context.analyzer.replaced_nodes.add (this);
 		parent_node.replace_expression (this, expr);
-		return expr.check (analyzer);
+		return expr.check (context);
 	}
 }
 
diff --git a/vala/valathrowstatement.vala b/vala/valathrowstatement.vala
index 444df3cd9..2667db6aa 100644
--- a/vala/valathrowstatement.vala
+++ b/vala/valathrowstatement.vala
@@ -72,22 +72,22 @@ public class Vala.ThrowStatement : CodeNode, Statement {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (analyzer.context.profile == Profile.GOBJECT) {
+		if (context.profile == Profile.GOBJECT) {
 			error_expression.target_type = new ErrorType (null, null, source_reference);
 		} else {
-			error_expression.target_type = analyzer.error_type.copy ();
+			error_expression.target_type = context.analyzer.error_type.copy ();
 		}
 		error_expression.target_type.value_owned = true;
 
 		if (error_expression != null) {
-			if (!error_expression.check (analyzer)) {
+			if (!error_expression.check (context)) {
 				error = true;
 				return false;
 			}
@@ -98,7 +98,7 @@ public class Vala.ThrowStatement : CodeNode, Statement {
 				return false;
 			}
 
-			if (analyzer.context.profile == Profile.GOBJECT && !(error_expression.value_type is ErrorType)) {
+			if (context.profile == Profile.GOBJECT && !(error_expression.value_type is ErrorType)) {
 				Report.error (error_expression.source_reference, "`%s' is not an error type".printf (error_expression.value_type.to_string ()));
 				error = true;
 				return false;
diff --git a/vala/valatrystatement.vala b/vala/valatrystatement.vala
index e5d3b2e2b..38000f516 100644
--- a/vala/valatrystatement.vala
+++ b/vala/valatrystatement.vala
@@ -104,14 +104,14 @@ public class Vala.TryStatement : CodeNode, Statement {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		body.check (analyzer);
+		body.check (context);
 
 		var error_types = new ArrayList<DataType> ();
 		foreach (DataType body_error_type in body.get_error_types ()) {
@@ -130,14 +130,14 @@ public class Vala.TryStatement : CodeNode, Statement {
 			}
 			handled_error_types.clear ();
 
-			clause.check (analyzer);
+			clause.check (context);
 			foreach (DataType body_error_type in clause.body.get_error_types ()) {
 				error_types.add (body_error_type);
 			}
 		}
 
 		if (finally_body != null) {
-			finally_body.check (analyzer);
+			finally_body.check (context);
 			foreach (DataType body_error_type in finally_body.get_error_types ()) {
 				error_types.add (body_error_type);
 			}
diff --git a/vala/valatuple.vala b/vala/valatuple.vala
index 2fcc45d2d..852215a4e 100644
--- a/vala/valatuple.vala
+++ b/vala/valatuple.vala
@@ -64,24 +64,24 @@ public class Vala.Tuple : Expression {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		if (analyzer.context.profile != Profile.DOVA) {
+		if (context.profile != Profile.DOVA) {
 			Report.error (source_reference, "tuples are not supported");
 			error = true;
 			return false;
 		}
 
-		value_type = new ObjectType ((Class) analyzer.context.root.scope.lookup ("Dova").scope.lookup ("Tuple"));
+		value_type = new ObjectType ((Class) context.root.scope.lookup ("Dova").scope.lookup ("Tuple"));
 		value_type.value_owned = true;
 
 		foreach (var expr in expression_list) {
-			if (!expr.check (analyzer)) {
+			if (!expr.check (context)) {
 				return false;
 			}
 			value_type.add_type_argument (expr.value_type.copy ());
diff --git a/vala/valatypecheck.vala b/vala/valatypecheck.vala
index 9208812e5..749401db5 100644
--- a/vala/valatypecheck.vala
+++ b/vala/valatypecheck.vala
@@ -93,16 +93,16 @@ public class Vala.TypeCheck : Expression {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		expression.check (analyzer);
+		expression.check (context);
 		
-		type_reference.check (analyzer);
+		type_reference.check (context);
 
 		if (type_reference.data_type == null) {
 			/* if type resolving didn't succeed, skip this check */
@@ -110,7 +110,7 @@ public class Vala.TypeCheck : Expression {
 			return false;
 		}
 
-		value_type = analyzer.bool_type;
+		value_type = context.analyzer.bool_type;
 
 		return !error;
 	}
diff --git a/vala/valatypeofexpression.vala b/vala/valatypeofexpression.vala
index d85f1867c..9efb1f55c 100644
--- a/vala/valatypeofexpression.vala
+++ b/vala/valatypeofexpression.vala
@@ -71,16 +71,16 @@ public class Vala.TypeofExpression : Expression {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		type_reference.check (analyzer);
+		type_reference.check (context);
 
-		value_type = analyzer.type_type;
+		value_type = context.analyzer.type_type;
 
 		return !error;
 	}
diff --git a/vala/valaunaryexpression.vala b/vala/valaunaryexpression.vala
index 51206c179..661a8fb53 100644
--- a/vala/valaunaryexpression.vala
+++ b/vala/valaunaryexpression.vala
@@ -137,7 +137,7 @@ public class Vala.UnaryExpression : Expression {
 		return null;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
@@ -149,7 +149,7 @@ public class Vala.UnaryExpression : Expression {
 			inner.target_type = target_type;
 		}
 
-		if (!inner.check (analyzer)) {
+		if (!inner.check (context)) {
 			/* if there was an error in the inner expression, skip type check */
 			error = true;
 			return false;
@@ -172,7 +172,7 @@ public class Vala.UnaryExpression : Expression {
 			value_type = inner.value_type;
 		} else if (operator == UnaryOperator.LOGICAL_NEGATION) {
 			// boolean type
-			if (!inner.value_type.compatible (analyzer.bool_type)) {
+			if (!inner.value_type.compatible (context.analyzer.bool_type)) {
 				error = true;
 				Report.error (source_reference, "Operator not supported for `%s'".printf (inner.value_type.to_string ()));
 				return false;
@@ -209,9 +209,9 @@ public class Vala.UnaryExpression : Expression {
 
 			var assignment = new Assignment (ma, bin, AssignmentOperator.SIMPLE, source_reference);
 			assignment.target_type = target_type;
-			analyzer.replaced_nodes.add (this);
+			context.analyzer.replaced_nodes.add (this);
 			parent_node.replace_expression (this, assignment);
-			assignment.check (analyzer);
+			assignment.check (context);
 			return true;
 		} else if (operator == UnaryOperator.REF || operator == UnaryOperator.OUT) {
 			var ea = inner as ElementAccess;
diff --git a/vala/valaunlockstatement.vala b/vala/valaunlockstatement.vala
index f86295582..ff2f40185 100644
--- a/vala/valaunlockstatement.vala
+++ b/vala/valaunlockstatement.vala
@@ -40,14 +40,14 @@ public class Vala.UnlockStatement : CodeNode, Statement {
 		visitor.visit_unlock_statement (this);
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (checked) {
 			return !error;
 		}
 
 		checked = true;
 
-		resource.check (analyzer);
+		resource.check (context);
 
 		/* resource must be a member access and denote a Lockable */
 		if (!(resource is MemberAccess && resource.symbol_reference is Lockable)) {
@@ -58,7 +58,7 @@ public class Vala.UnlockStatement : CodeNode, Statement {
 		}
 
 		/* parent symbol must be the current class */
-		if (resource.symbol_reference.parent_symbol != analyzer.current_class) {
+		if (resource.symbol_reference.parent_symbol != context.analyzer.current_class) {
 			error = true;
 			resource.error = true;
 			Report.error (resource.source_reference, "Only members of the current class are lockable");
diff --git a/vala/valavaluetype.vala b/vala/valavaluetype.vala
index c881c1ed7..baec19eb7 100644
--- a/vala/valavaluetype.vala
+++ b/vala/valavaluetype.vala
@@ -62,7 +62,7 @@ public abstract class Vala.ValueType : DataType {
 		return false;
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
-		return type_symbol.check (analyzer);
+	public override bool check (CodeContext context) {
+		return type_symbol.check (context);
 	}
 }
diff --git a/vala/valawhilestatement.vala b/vala/valawhilestatement.vala
index 8df427d84..267e35ed5 100644
--- a/vala/valawhilestatement.vala
+++ b/vala/valawhilestatement.vala
@@ -91,7 +91,7 @@ public class Vala.WhileStatement : CodeNode, Statement {
 		return (literal != null && !literal.value);
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		// convert to simple loop
 
 		if (always_true (condition)) {
@@ -112,7 +112,7 @@ public class Vala.WhileStatement : CodeNode, Statement {
 		var parent_block = (Block) parent_node;
 		parent_block.replace_statement (this, loop);
 
-		return loop.check (analyzer);
+		return loop.check (context);
 	}
 }
 
diff --git a/vala/valayieldstatement.vala b/vala/valayieldstatement.vala
index 0fd6e3454..8b2069f21 100644
--- a/vala/valayieldstatement.vala
+++ b/vala/valayieldstatement.vala
@@ -69,13 +69,13 @@ public class Vala.YieldStatement : CodeNode, Statement {
 		}
 	}
 
-	public override bool check (SemanticAnalyzer analyzer) {
+	public override bool check (CodeContext context) {
 		if (yield_expression != null) {
-			yield_expression.check (analyzer);
+			yield_expression.check (context);
 			error = yield_expression.error;
 		}
 
-		analyzer.current_method.yield_count++;
+		context.analyzer.current_method.yield_count++;
 
 		return !error;
 	}