+2008-11-10 Jürg Billeter <j@bitron.ch>
+
+ * vala/valaaddressofexpression.vala:
+ * vala/valaarraycreationexpression.vala:
+ * vala/valaassignment.vala:
+ * vala/valabinaryexpression.vala:
+ * vala/valablock.vala:
+ * vala/valacastexpression.vala:
+ * vala/valacatchclause.vala:
+ * vala/valaclass.vala:
+ * vala/valaconditionalexpression.vala:
+ * vala/valaconstant.vala:
+ * vala/valaconstructor.vala:
+ * vala/valacreationmethod.vala:
+ * vala/valadeclarationstatement.vala:
+ * vala/valadelegate.vala:
+ * vala/valadeletestatement.vala:
+ * vala/valadestructor.vala:
+ * vala/valadostatement.vala:
+ * vala/valaelementaccess.vala:
+ * vala/valaenum.vala:
+ * vala/valaenumvalue.vala:
+ * vala/valaerrorcode.vala:
+ * vala/valaerrordomain.vala:
+ * vala/valaexpressionstatement.vala:
+ * vala/valafield.vala:
+ * vala/valaforeachstatement.vala:
+ * vala/valaformalparameter.vala:
+ * vala/valaforstatement.vala:
+ * vala/valaifstatement.vala:
+ * vala/valainitializerlist.vala:
+ * vala/valainterface.vala:
+ * vala/valainvocationexpression.vala:
+ * vala/valalambdaexpression.vala:
+ * vala/valalocalvariable.vala:
+ * vala/valalockstatement.vala:
+ * vala/valamemberaccess.vala:
+ * vala/valamemberinitializer.vala:
+ * vala/valamethod.vala:
+ * vala/valanamespace.vala:
+ * vala/valaobjectcreationexpression.vala:
+ * vala/valaparenthesizedexpression.vala:
+ * vala/valapointerindirection.vala:
+ * vala/valapostfixexpression.vala:
+ * vala/valaproperty.vala:
+ * vala/valapropertyaccessor.vala:
+ * vala/valareferencetransferexpression.vala:
+ * vala/valareturnstatement.vala:
+ * vala/valasemanticanalyzer.vala:
+ * vala/valasignal.vala:
+ * vala/valasizeofexpression.vala:
+ * vala/valasourcefile.vala:
+ * vala/valastruct.vala:
+ * vala/valaswitchlabel.vala:
+ * vala/valaswitchsection.vala:
+ * vala/valaswitchstatement.vala:
+ * vala/valathrowstatement.vala:
+ * vala/valatrystatement.vala:
+ * vala/valatypecheck.vala:
+ * vala/valatypeofexpression.vala:
+ * vala/valaunaryexpression.vala:
+ * vala/valawhilestatement.vala:
+ * vala/valayieldstatement.vala:
+
+ Remove unnecessary accept calls in semantic analyzer
+
2008-11-10 Jürg Billeter <j@bitron.ch>
* vala/valaaddressofexpression.vala:
checked = true;
- if (inner.error) {
+ if (!inner.check (analyzer)) {
+ error = true;
return false;
}
if (!(inner.value_type is ValueType
private int create_sizes_from_initializer_list (SemanticAnalyzer analyzer, InitializerList il, int rank, Gee.List<Literal> sl) {
var init = new IntegerLiteral (il.size.to_string (), il.source_reference);
- init.accept (analyzer);
+ init.check (analyzer);
sl.add (init);
int subsize = -1;
var initlist = initializer_list;
if (element_type != null) {
- element_type.accept (analyzer);
+ element_type.check (analyzer);
}
foreach (Expression e in size) {
- e.accept (analyzer);
+ e.check (analyzer);
}
var calc_sizes = new ArrayList<Literal> ();
if (initlist != null) {
initlist.target_type = new ArrayType (element_type, rank, source_reference);
- initlist.accept (analyzer);
+ initlist.check (analyzer);
var ret = create_sizes_from_initializer_list (analyzer, initlist, rank, calc_sizes);
if (ret == -1) {
left.lvalue = true;
- left.accept (analyzer);
-
- if (left.error) {
+ if (!left.check (analyzer)) {
// skip on error in inner expression
error = true;
return false;
return false;
}
- right.accept (analyzer);
-
- if (right.error) {
+ if (!right.check (analyzer)) {
// skip on error in inner expression
error = true;
return false;
}
right = bin;
- right.accept (analyzer);
+ right.check (analyzer);
operator = AssignmentOperator.SIMPLE;
}
* increment calls */
}
} else {
- return false;
+ return true;
}
if (left.value_type != null) {
checked = true;
- if (left.error || right.error) {
+ if (!left.check (analyzer) || !right.check (analyzer)) {
/* if there were any errors in inner expressions, skip type check */
error = true;
return false;
owner = analyzer.current_symbol.scope;
analyzer.current_symbol = this;
- accept_children (analyzer);
+ foreach (Statement stmt in statement_list) {
+ stmt.check (analyzer);
+ }
foreach (LocalVariable local in get_local_variables ()) {
local.active = false;
}
- foreach (Statement stmt in get_statements()) {
+ foreach (Statement stmt in get_statements ()) {
add_error_types (stmt.get_error_types ());
}
checked = true;
- if (inner.error) {
+ if (!inner.check (analyzer)) {
error = true;
return false;
}
+ type_reference.check (analyzer);
+
// FIXME: check whether cast is allowed
analyzer.current_source_file.add_type_dependency (type_reference, SourceFileDependencyType.SOURCE);
error_type = new ErrorType (null, null, source_reference);
}
- accept_children (analyzer);
+ error_type.check (analyzer);
+
+ body.check (analyzer);
return !error;
}
analyzer.current_source_file.add_type_dependency (base_type_reference, SourceFileDependencyType.HEADER_FULL);
}
- accept_children (analyzer);
+ foreach (DataType type in base_types) {
+ type.check (analyzer);
+ }
+
+ foreach (TypeParameter p in type_parameters) {
+ p.check (analyzer);
+ }
+
+ /* process enums first to avoid order problems in C code */
+ foreach (Enum en in enums) {
+ en.check (analyzer);
+ }
+
+ foreach (Field f in fields) {
+ f.check (analyzer);
+ }
+
+ foreach (Constant c in constants) {
+ c.check (analyzer);
+ }
+
+ foreach (Method m in methods) {
+ m.check (analyzer);
+ }
+
+ foreach (Property prop in properties) {
+ prop.check (analyzer);
+ }
+
+ foreach (Signal sig in signals) {
+ sig.check (analyzer);
+ }
+
+ if (constructor != null) {
+ constructor.check (analyzer);
+ }
+
+ if (class_constructor != null) {
+ class_constructor.check (analyzer);
+ }
+
+ if (static_constructor != null) {
+ static_constructor.check (analyzer);
+ }
+
+ if (destructor != null) {
+ destructor.check (analyzer);
+ }
+
+ foreach (Class cl in classes) {
+ cl.check (analyzer);
+ }
+
+ foreach (Struct st in structs) {
+ st.check (analyzer);
+ }
+
+ foreach (Delegate d in delegates) {
+ d.check (analyzer);
+ }
/* compact classes cannot implement interfaces */
if (is_compact) {
checked = true;
- if (condition.error || false_expression.error || true_expression.error) {
+ if (!condition.check (analyzer) || !false_expression.check (analyzer) || !true_expression.check (analyzer)) {
return false;
}
process_attributes ();
- type_reference.accept (analyzer);
+ type_reference.check (analyzer);
if (!external_package) {
if (initializer == null) {
} else {
initializer.target_type = type_reference;
- initializer.accept (analyzer);
+ initializer.check (analyzer);
}
}
owner = analyzer.current_symbol.scope;
analyzer.current_symbol = this;
- accept_children (analyzer);
+ if (body != null) {
+ body.check (analyzer);
+ }
foreach (DataType body_error_type in body.get_error_types ()) {
Report.warning (body_error_type.source_reference, "unhandled error `%s'".printf (body_error_type.to_string()));
analyzer.current_symbol = this;
analyzer.current_return_type = return_type;
- accept_children (analyzer);
+ foreach (FormalParameter param in get_parameters()) {
+ param.check (analyzer);
+ }
+
+ foreach (DataType error_type in get_error_types ()) {
+ error_type.check (analyzer);
+ }
+
+ if (body != null) {
+ body.check (analyzer);
+ }
analyzer.current_symbol = old_symbol;
analyzer.current_return_type = old_return_type;
checked = true;
+ declaration.check (analyzer);
+
var local = declaration as LocalVariable;
if (local != null && local.initializer != null) {
foreach (DataType error_type in local.initializer.get_error_types ()) {
analyzer.current_source_file = source_reference.file;
}
- accept_children (analyzer);
+ foreach (TypeParameter p in type_parameters) {
+ p.check (analyzer);
+ }
+
+ return_type.check (analyzer);
+
+ foreach (FormalParameter param in parameters) {
+ param.check (analyzer);
+ }
analyzer.current_source_file = old_source_file;
checked = true;
- accept_children (analyzer);
-
- if (expression.error) {
+ if (!expression.check (analyzer)) {
// if there was an error in the inner expression, skip this check
return false;
}
owner = analyzer.current_symbol.scope;
analyzer.current_symbol = this;
- accept_children (analyzer);
+ if (body != null) {
+ body.check (analyzer);
+ }
analyzer.current_symbol = analyzer.current_symbol.parent_symbol;
checked = true;
- accept_children (analyzer);
+ body.check (analyzer);
- if (condition.error) {
+ if (!condition.check (analyzer)) {
/* if there was an error in the condition, skip this check */
error = true;
return false;
checked = true;
- container.accept (analyzer);
+ container.check (analyzer);
if (container.value_type == null) {
/* don't proceed if a child expression failed */
}
foreach (Expression index in get_indices ()) {
- index.accept (analyzer);
+ index.check (analyzer);
}
bool index_int_type_check = true;
analyzer.current_source_file = source_reference.file;
}
- accept_children (analyzer);
+ foreach (EnumValue value in values) {
+ value.check (analyzer);
+ }
+
+ foreach (Method m in methods) {
+ m.check (analyzer);
+ }
analyzer.current_source_file = old_source_file;
process_attributes ();
- accept_children (analyzer);
+ if (value != null) {
+ value.check (analyzer);
+ }
return !error;
}
checked = true;
- accept_children (analyzer);
+ if (value != null) {
+ value.check (analyzer);
+ }
return !error;
}
process_attributes ();
- accept_children (analyzer);
+ foreach (ErrorCode ecode in codes) {
+ ecode.check (analyzer);
+ }
+
+ foreach (Method m in methods) {
+ m.check (analyzer);
+ }
return !error;
}
checked = true;
- if (expression.error) {
+ if (!expression.check (analyzer)) {
// ignore inner error
error = true;
return false;
initializer.target_type = field_type;
}
- accept_children (analyzer);
+ field_type.check (analyzer);
+
+ if (initializer != null) {
+ initializer.check (analyzer);
+ }
if (binding == MemberBinding.INSTANCE && parent_symbol is Interface) {
error = true;
checked = true;
// analyze collection expression first, used for type inference
- collection.accept (analyzer);
-
- if (collection.error) {
+ if (!collection.check (analyzer)) {
// ignore inner error
error = true;
return false;
owner = analyzer.current_symbol.scope;
analyzer.current_symbol = this;
- body.accept (analyzer);
+ body.check (analyzer);
foreach (LocalVariable local in get_local_variables ()) {
local.active = false;
parameter_type.check (analyzer);
}
- accept_children (analyzer);
+ if (!ellipsis) {
+ parameter_type.check (analyzer);
+
+ if (default_expression != null) {
+ default_expression.check (analyzer);
+ }
+ }
if (analyzer.context.non_null && default_expression != null) {
if (default_expression is NullLiteral
checked = true;
- accept_children (analyzer);
+ foreach (Expression init_expr in initializer) {
+ init_expr.check (analyzer);
+ }
+
+ if (condition != null) {
+ condition.check (analyzer);
+ }
+
+ foreach (Expression it_expr in iterator) {
+ it_expr.check (analyzer);
+ }
+
+ body.check (analyzer);
if (condition != null && condition.error) {
/* if there was an error in the condition, skip this check */
checked = true;
- accept_children (analyzer);
+ condition.check (analyzer);
+
+ true_statement.check (analyzer);
+ if (false_statement != null) {
+ false_statement.check (analyzer);
+ }
if (condition.error) {
/* if there was an error in the condition, skip this check */
return false;
}
- accept_children (analyzer);
+ foreach (Expression expr in initializers) {
+ expr.check (analyzer);
+ }
bool error = false;
foreach (Expression e in get_initializers ()) {
}
}
- accept_children (analyzer);
+ foreach (DataType type in prerequisites) {
+ type.check (analyzer);
+ }
+
+ foreach (TypeParameter p in type_parameters) {
+ p.check (analyzer);
+ }
+
+ foreach (Enum en in enums) {
+ en.check (analyzer);
+ }
+
+ foreach (Method m in methods) {
+ m.check (analyzer);
+ }
+
+ foreach (Field f in fields) {
+ f.check (analyzer);
+ }
+
+ foreach (Property prop in properties) {
+ prop.check (analyzer);
+ }
+
+ foreach (Signal sig in signals) {
+ sig.check (analyzer);
+ }
+
+ foreach (Class cl in classes) {
+ cl.check (analyzer);
+ }
+
+ foreach (Struct st in structs) {
+ st.check (analyzer);
+ }
+
+ foreach (Delegate d in delegates) {
+ d.check (analyzer);
+ }
analyzer.current_source_file = old_source_file;
analyzer.current_symbol = old_symbol;
checked = true;
- call.accept (analyzer);
-
- if (call.error) {
+ if (!call.check (analyzer)) {
/* if method resolving didn't succeed, skip this check */
error = true;
return false;
struct_creation_expression.target_type = target_type;
analyzer.replaced_nodes.add (this);
parent_node.replace_expression (this, struct_creation_expression);
- struct_creation_expression.accept (analyzer);
+ struct_creation_expression.check (analyzer);
return false;
} else if (call is MemberAccess
&& call.symbol_reference is CreationMethod) {
}
foreach (Expression arg in get_argument_list ()) {
- arg.accept (analyzer);
+ arg.check (analyzer);
}
DataType ret_type;
/* lambda expressions should be usable like MemberAccess of a method */
symbol_reference = method;
- accept_children (analyzer);
+ if (method == null) {
+ if (expression_body != null) {
+ expression_body.check (analyzer);
+ } else if (statement_body != null) {
+ statement_body.check (analyzer);
+ }
+ } else {
+ method.check (analyzer);
+ }
value_type = new MethodType (method);
initializer.target_type = variable_type;
}
- accept_children (analyzer);
+ if (initializer != null) {
+ initializer.check (analyzer);
+ }
+
+ if (variable_type != null) {
+ variable_type.check (analyzer);
+ }
if (variable_type == null) {
/* var type */
checked = true;
+ resource.check (analyzer);
+ body.check (analyzer);
+
/* resource must be a member access and denote a Lockable */
if (!(resource is MemberAccess && resource.symbol_reference is Lockable)) {
error = true;
checked = true;
+ if (inner != null) {
+ inner.check (analyzer);
+ }
+
+ foreach (DataType type_arg in type_argument_list) {
+ type_arg.check (analyzer);
+ }
+
Symbol base_symbol = null;
FormalParameter this_parameter = null;
bool may_access_instance_members = false;
if (pointer_type != null && pointer_type.base_type is ValueType) {
// transform foo->bar to (*foo).bar
inner = new PointerIndirection (inner, source_reference);
- inner.accept (analyzer);
+ inner.check (analyzer);
pointer_member_access = false;
}
}
public override void accept (CodeVisitor visitor) {
initializer.accept (visitor);
}
+
+ public override bool check (SemanticAnalyzer analyzer) {
+ return initializer.check (analyzer);
+ }
}
}
analyzer.current_source_file.add_type_dependency (return_type, SourceFileDependencyType.SOURCE);
- accept_children (analyzer);
+ if (return_type != null) {
+ return_type.check (analyzer);
+ }
+
+ foreach (FormalParameter param in parameters) {
+ param.check (analyzer);
+ }
+
+ foreach (DataType error_type in get_error_types ()) {
+ error_type.check (analyzer);
+ }
+
+ if (result_var != null) {
+ result_var.variable_type.check (analyzer);
+ }
+
+ foreach (Expression precondition in preconditions) {
+ precondition.check (analyzer);
+ }
+
+ foreach (Expression postcondition in postconditions) {
+ postcondition.check (analyzer);
+ }
+
+ if (body != null) {
+ body.check (analyzer);
+ }
analyzer.current_symbol = old_symbol;
analyzer.current_return_type = old_return_type;
process_attributes ();
+ foreach (Namespace ns in namespaces) {
+ ns.check (analyzer);
+ }
+
return !error;
}
}
checked = true;
if (member_name != null) {
- member_name.accept (analyzer);
+ member_name.check (analyzer);
}
TypeSymbol type = null;
}
foreach (Expression arg in args) {
- arg.accept (analyzer);
+ arg.check (analyzer);
}
analyzer.check_arguments (this, new MethodType (m), m.get_parameters (), args);
add_error_type (call_error_type);
}
} else if (type_reference is ErrorType) {
- accept_children (analyzer);
+ if (type_reference != null) {
+ type_reference.check (analyzer);
+ }
+
+ if (member_name != null) {
+ member_name.check (analyzer);
+ }
+
+ foreach (Expression arg in argument_list) {
+ arg.check (analyzer);
+ }
+
+ foreach (MemberInitializer init in object_initializer) {
+ init.check (analyzer);
+ }
if (get_argument_list ().size == 0) {
error = true;
inner.target_type = target_type;
- accept_children (analyzer);
-
- if (inner.error) {
+ if (!inner.check (analyzer)) {
// ignore inner error
error = true;
return false;
checked = true;
- if (inner.error) {
+ if (!inner.check (analyzer)) {
return false;
}
if (inner.value_type == null) {
checked = true;
+ inner.check (analyzer);
+
value_type = inner.value_type;
return !error;
property_type.check (analyzer);
if (get_accessor != null) {
- get_accessor.accept (analyzer);
+ get_accessor.check (analyzer);
}
if (set_accessor != null) {
- set_accessor.accept (analyzer);
+ set_accessor.check (analyzer);
}
if (default_expression != null) {
- default_expression.accept (analyzer);
+ default_expression.check (analyzer);
}
// check whether property type is at least as accessible as the property
}
}
- accept_children (analyzer);
+ if (body != null) {
+ body.check (analyzer);
+ }
analyzer.current_return_type = old_return_type;
inner.lvalue = true;
- accept_children (analyzer);
+ inner.check (analyzer);
if (inner.error) {
/* if there was an error in the inner expression, skip type check */
return_expression.target_type = analyzer.current_return_type;
}
- accept_children (analyzer);
-
- if (return_expression != null && return_expression.error) {
+ if (return_expression != null && !return_expression.check (analyzer)) {
// ignore inner error
error = true;
return false;
}
current_symbol = root_symbol;
+ context.root.check (this);
context.accept (this);
}
next_lambda_id = 0;
- file.accept_children (this);
- }
-
- public override void visit_namespace (Namespace ns) {
- ns.check (this);
- }
-
- public override void visit_class (Class cl) {
- cl.check (this);
- }
-
- public override void visit_struct (Struct st) {
- st.check (this);
- }
-
- public override void visit_interface (Interface iface) {
- iface.check (this);
- }
-
- public override void visit_enum (Enum en) {
- en.check (this);
- }
-
- public override void visit_enum_value (EnumValue ev) {
- ev.check (this);
- }
-
- public override void visit_error_domain (ErrorDomain ed) {
- ed.check (this);
- }
-
- public override void visit_error_code (ErrorCode ec) {
- ec.check (this);
- }
-
- public override void visit_delegate (Delegate d) {
- d.check (this);
- }
-
- public override void visit_constant (Constant c) {
- c.check (this);
- }
-
- public override void visit_field (Field f) {
- f.check (this);
- }
-
- public override void visit_method (Method m) {
- m.check (this);
- }
-
- public override void visit_creation_method (CreationMethod m) {
- m.check (this);
- }
-
- public override void visit_formal_parameter (FormalParameter p) {
- p.check (this);
+ file.check (this);
}
// check whether type is at least as accessible as the specified symbol
return true;
}
- public override void visit_property (Property prop) {
- prop.check (this);
- }
-
- public override void visit_property_accessor (PropertyAccessor acc) {
- acc.check (this);
- }
-
- public override void visit_signal (Signal sig) {
- sig.check (this);
- }
-
- public override void visit_constructor (Constructor c) {
- c.check (this);
- }
-
- public override void visit_destructor (Destructor d) {
- d.check (this);
- }
-
- public override void visit_block (Block b) {
- b.check (this);
- }
-
- public override void visit_declaration_statement (DeclarationStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_local_variable (LocalVariable local) {
- local.check (this);
- }
-
- public override void visit_initializer_list (InitializerList list) {
- list.check (this);
- }
-
- public override void visit_expression_statement (ExpressionStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_if_statement (IfStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_switch_section (SwitchSection section) {
- section.check (this);
- }
-
- public override void visit_while_statement (WhileStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_do_statement (DoStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_for_statement (ForStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_foreach_statement (ForeachStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_return_statement (ReturnStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_yield_statement (YieldStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_throw_statement (ThrowStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_try_statement (TryStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_catch_clause (CatchClause clause) {
- clause.check (this);
- }
-
- public override void visit_lock_statement (LockStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_delete_statement (DeleteStatement stmt) {
- stmt.check (this);
- }
-
- public override void visit_array_creation_expression (ArrayCreationExpression expr) {
- expr.check (this);
- }
-
- public override void visit_boolean_literal (BooleanLiteral expr) {
- expr.check (this);
- }
-
- public override void visit_character_literal (CharacterLiteral expr) {
- expr.check (this);
- }
-
- public override void visit_integer_literal (IntegerLiteral expr) {
- expr.check (this);
- }
-
- public override void visit_real_literal (RealLiteral expr) {
- expr.check (this);
- }
-
- public override void visit_string_literal (StringLiteral expr) {
- expr.check (this);
- }
-
- public override void visit_null_literal (NullLiteral expr) {
- expr.check (this);
- }
-
public DataType? get_value_type_for_symbol (Symbol sym, bool lvalue) {
if (sym is Field) {
var f = (Field) sym;
return null;
}
- public override void visit_parenthesized_expression (ParenthesizedExpression expr) {
- expr.check (this);
- }
-
- public override void visit_member_access (MemberAccess expr) {
- expr.check (this);
- }
-
public static DataType get_data_type_for_symbol (TypeSymbol sym) {
DataType type = null;
return type;
}
- public override void visit_invocation_expression (InvocationExpression expr) {
- expr.check (this);
- }
-
public bool check_arguments (Expression expr, DataType mtype, Gee.List<FormalParameter> params, Gee.List<Expression> args) {
Expression prev_arg = null;
Iterator<Expression> arg_it = args.iterator ();
return actual_type;
}
- public override void visit_element_access (ElementAccess expr) {
- expr.check (this);
- }
-
public bool is_in_instance_method () {
var sym = current_symbol;
while (sym != null) {
return false;
}
- public override void visit_base_access (BaseAccess expr) {
- expr.check (this);
- }
-
- public override void visit_postfix_expression (PostfixExpression expr) {
- expr.check (this);
- }
-
- public override void visit_object_creation_expression (ObjectCreationExpression expr) {
- expr.check (this);
- }
-
public void visit_member_initializer (MemberInitializer init, DataType type) {
- init.accept (this);
+ init.check (this);
init.symbol_reference = symbol_lookup_inherited (type.data_type, init.name);
if (!(init.symbol_reference is Field || init.symbol_reference is Property)) {
}
}
- public override void visit_sizeof_expression (SizeofExpression expr) {
- expr.check (this);
- }
-
- public override void visit_typeof_expression (TypeofExpression expr) {
- expr.check (this);
- }
-
- public override void visit_unary_expression (UnaryExpression expr) {
- expr.check (this);
- }
-
- public override void visit_cast_expression (CastExpression expr) {
- expr.check (this);
- }
-
- public override void visit_pointer_indirection (PointerIndirection expr) {
- expr.check (this);
- }
-
- public override void visit_addressof_expression (AddressofExpression expr) {
- expr.check (this);
- }
-
- public override void visit_reference_transfer_expression (ReferenceTransferExpression expr) {
- expr.check (this);
- }
-
public DataType? get_arithmetic_result_type (DataType left_type, DataType right_type) {
if (!(left_type.data_type is Struct) || !(right_type.data_type is Struct)) {
// at least one operand not struct
}
}
- public override void visit_binary_expression (BinaryExpression expr) {
- expr.check (this);
- }
-
- public override void visit_type_check (TypeCheck expr) {
- expr.check (this);
- }
-
- public override void visit_conditional_expression (ConditionalExpression expr) {
- expr.check (this);
- }
-
public Method? find_current_method () {
var sym = current_symbol;
while (sym != null) {
}
return false;
}
-
- public override void visit_lambda_expression (LambdaExpression l) {
- l.check (this);
- }
-
- public override void visit_assignment (Assignment a) {
- a.check (this);
- }
}
process_attributes ();
- accept_children (analyzer);
+ return_type.check (analyzer);
+
+ foreach (FormalParameter param in parameters) {
+ param.check (analyzer);
+ }
return !error;
}
checked = true;
+ type_reference.check (analyzer);
+
value_type = analyzer.ulong_type;
return !error;
return mapped_file.get_length ();
}
+
+ public bool check (SemanticAnalyzer analyzer) {
+ foreach (CodeNode node in nodes) {
+ node.check (analyzer);
+ }
+ return true;
+ }
}
public enum Vala.SourceFileDependencyType {
analyzer.current_symbol = this;
analyzer.current_struct = this;
- accept_children (analyzer);
+ foreach (DataType type in base_types) {
+ type.check (analyzer);
+ }
+
+ foreach (TypeParameter p in type_parameters) {
+ p.check (analyzer);
+ }
+
+ foreach (Field f in fields) {
+ f.check (analyzer);
+ }
+
+ foreach (Constant c in constants) {
+ c.check (analyzer);
+ }
+
+ foreach (Method m in methods) {
+ m.check (analyzer);
+ }
if (!external && !external_package && get_base_types ().size == 0 && get_fields ().size == 0) {
Report.error (source_reference, "structs cannot be empty");
visitor.visit_switch_label (this);
}
+
+ public override bool check (SemanticAnalyzer analyzer) {
+ if (expression != null) {
+ expression.check (analyzer);
+ }
+
+ return true;
+ }
}
checked = true;
foreach (SwitchLabel label in get_labels ()) {
- label.accept (analyzer);
+ label.check (analyzer);
}
owner = analyzer.current_symbol.scope;
analyzer.current_symbol = this;
foreach (Statement st in get_statements ()) {
- st.accept (analyzer);
+ st.check (analyzer);
}
foreach (LocalVariable local in get_local_variables ()) {
expression = new_node;
}
}
+
+ public override bool check (SemanticAnalyzer analyzer) {
+ if (checked) {
+ return !error;
+ }
+
+ checked = true;
+
+ expression.check (analyzer);
+
+ foreach (SwitchSection section in sections) {
+ section.check (analyzer);
+ }
+
+ return !error;
+ }
}
error_expression.target_type = new ErrorType (null, null, source_reference);
error_expression.target_type.value_owned = true;
- accept_children (analyzer);
+ if (error_expression != null) {
+ error_expression.check (analyzer);
+ }
var error_type = error_expression.value_type.copy ();
error_type.source_reference = source_reference;
checked = true;
- accept_children (analyzer);
+ body.check (analyzer);
+
+ foreach (CatchClause clause in catch_clauses) {
+ clause.check (analyzer);
+ }
+
+ if (finally_body != null) {
+ finally_body.check (analyzer);
+ }
return !error;
}
checked = true;
+ expression.check (analyzer);
+
+ type_reference.check (analyzer);
+
if (type_reference.data_type == null) {
/* if type resolving didn't succeed, skip this check */
error = true;
checked = true;
+ type_reference.check (analyzer);
+
value_type = analyzer.type_type;
return !error;
inner.target_type = target_type;
}
- accept_children (analyzer);
-
- if (inner.error) {
+ if (!inner.check (analyzer)) {
/* if there was an error in the inner expression, skip type check */
error = true;
return false;
parenthexp.target_type = target_type;
analyzer.replaced_nodes.add (this);
parent_node.replace_expression (this, parenthexp);
- parenthexp.accept (analyzer);
+ parenthexp.check (analyzer);
return true;
} else if (operator == UnaryOperator.REF || operator == UnaryOperator.OUT) {
if (inner.symbol_reference is Field || inner.symbol_reference is FormalParameter || inner.symbol_reference is LocalVariable) {
checked = true;
- accept_children (analyzer);
+ condition.check (analyzer);
+
+ body.check (analyzer);
if (condition.error) {
/* if there was an error in the condition, skip this check */
public override bool check (SemanticAnalyzer analyzer) {
if (yield_expression != null) {
- yield_expression.accept (analyzer);
+ yield_expression.check (analyzer);
error = yield_expression.error;
}
projects / thirdparty / vala.git / commitdiff
