diff -Nru vala-0.52.6/aclocal.m4 vala-0.52.7/aclocal.m4 --- vala-0.52.6/aclocal.m4 2021-10-04 09:46:37.000000000 +0000 +++ vala-0.52.7/aclocal.m4 2021-10-30 08:23:51.000000000 +0000 @@ -1,4 +1,4 @@ -# generated automatically by aclocal 1.16.4 -*- Autoconf -*- +# generated automatically by aclocal 1.16.5 -*- Autoconf -*- # Copyright (C) 1996-2021 Free Software Foundation, Inc. @@ -35,7 +35,7 @@ [am__api_version='1.16' dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to dnl require some minimum version. Point them to the right macro. -m4_if([$1], [1.16.4], [], +m4_if([$1], [1.16.5], [], [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl ]) @@ -51,7 +51,7 @@ # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced. # This function is AC_REQUIREd by AM_INIT_AUTOMAKE. AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], -[AM_AUTOMAKE_VERSION([1.16.4])dnl +[AM_AUTOMAKE_VERSION([1.16.5])dnl m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) @@ -428,6 +428,10 @@ # release and drop the old call support. AC_DEFUN([AM_INIT_AUTOMAKE], [AC_PREREQ([2.65])dnl +m4_ifdef([_$0_ALREADY_INIT], + [m4_fatal([$0 expanded multiple times +]m4_defn([_$0_ALREADY_INIT]))], + [m4_define([_$0_ALREADY_INIT], m4_expansion_stack)])dnl dnl Autoconf wants to disallow AM_ names. We explicitly allow dnl the ones we care about. m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl diff -Nru vala-0.52.6/build-aux/ltmain.sh vala-0.52.7/build-aux/ltmain.sh --- vala-0.52.6/build-aux/ltmain.sh 2021-10-04 09:46:38.000000000 +0000 +++ vala-0.52.7/build-aux/ltmain.sh 2021-10-30 08:23:51.000000000 +0000 @@ -31,7 +31,7 @@ PROGRAM=libtool PACKAGE=libtool -VERSION="2.4.6 Debian-2.4.6-15" +VERSION="2.4.6 Debian-2.4.6-15build1" package_revision=2.4.6 @@ -2141,7 +2141,7 @@ compiler: $LTCC compiler flags: $LTCFLAGS linker: $LD (gnu? $with_gnu_ld) - version: $progname $scriptversion Debian-2.4.6-15 + version: $progname $scriptversion Debian-2.4.6-15build1 automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q` autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q` diff -Nru vala-0.52.6/ccode/Makefile.in vala-0.52.7/ccode/Makefile.in --- vala-0.52.6/ccode/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/ccode/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/ChangeLog vala-0.52.7/ChangeLog --- vala-0.52.6/ChangeLog 2021-10-04 09:48:40.000000000 +0000 +++ vala-0.52.7/ChangeLog 2021-10-30 08:25:30.000000000 +0000 @@ -1,3 +1,85 @@ +2021-10-30 Rico Tzschichholz + + Release 0.52.7 + +2021-10-24 Rico Tzschichholz + + tests: Add "throws error code" tests to increase coverage + + vala: Improve CodeWriter.visit_catch_clause() + Properly output general catch clause + + vala: Implement CodeWriter.visit_foreach_statement() + + parser: Make sure ErrorCodes are accessible as needed + + codegen: Use ErrorType.error_domain if possible + + vala: Report error for non ErrorType in throws + + tests: Add "no error type in catch" tests to increase coverage + + vala: Replace and drop UnaryExpression.find_member_access() + + tests: Add invalid "unary decrement" test to increase coverage + + tests: Add more invalid "(un)lock" tests to increase coverage + + vala: Correctly output signature of callable throwing error + + vala: Really check compatiblity of error types for delegate symbol + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1242 + +2021-10-19 Rico Tzschichholz + + vala: Set more missing source references of CodeNode instances + + tests: Split "Variant (de)serialization" test to trigger one error at a time + + tests: Extend "access virtual signal of interface" test to increase coverage + + tests: Add more invalid "member access" tests to increase coverage + + tests: Add "instance access to implicit to_string() method of enum" test + + tests: Add invalid "target/destroy access" tests to increase coverage + + parser: Don't bail parsing of yield expression on error + Reporting the error is enough to handle this properly. + + tests: Avoid causing unrelated errors in invalid test cases + + tests: Add more "type-arguments" tests to increase coverage + + tests: Rename invalid yield-return test to avoid conflict + + codegen: Actually free data when using "remove(_all)" on GLib.Queue/(S)List + When using e.g. GLib.List.remove() there is no context/feedback whether an + item was removed or needed manual free'ing. + + Replace such calls with custom wrappers where items required free'ing if + they were found. + + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1238 + + vala: More thorough check of ValueType and set CodeNode.error on failure + + vala: No need to run return_type.check() twice for method + + tests: Add more "type-arguments" tests to increase coverage + + tests/girwriter: Add missing type-argument + + gee: Add missing type-arguments + + girparser: Add support for "ref_/ref_sink_/unref_function" metadata for classes + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1233 + +2021-10-19 wxx <769218589@qq.com> + + vala: Parameter following ellipsis parameter is not allowed + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1237 + 2021-10-04 Rico Tzschichholz Release 0.52.6 diff -Nru vala-0.52.6/codegen/Makefile.in vala-0.52.7/codegen/Makefile.in --- vala-0.52.6/codegen/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/codegen/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/codegen/valaccodemethodcallmodule.c vala-0.52.7/codegen/valaccodemethodcallmodule.c --- vala-0.52.6/codegen/valaccodemethodcallmodule.c 2021-10-04 09:47:20.000000000 +0000 +++ vala-0.52.7/codegen/valaccodemethodcallmodule.c 2021-10-30 08:24:33.000000000 +0000 @@ -486,27 +486,34 @@ gboolean _tmp1887_; gboolean _tmp1911_; gboolean _tmp1912_; - gboolean _tmp1947_ = FALSE; - gboolean _tmp1948_ = FALSE; - ValaMethod* _tmp1949_; - gboolean _tmp1987_ = FALSE; - gboolean _tmp1988_ = FALSE; - gboolean _tmp1989_ = FALSE; - gboolean _tmp1990_ = FALSE; - gboolean _tmp1991_ = FALSE; - ValaMethod* _tmp1992_; - gboolean _tmp2009_ = FALSE; - gboolean _tmp2010_ = FALSE; - ValaMethod* _tmp2011_; - ValaMethod* _tmp2030_; - gboolean _tmp2140_ = FALSE; - ValaCodeNode* _tmp2141_; - ValaCodeNode* _tmp2142_; - ValaList* _tmp2242_; - ValaIterator* _tmp2243_; - gboolean _tmp2396_ = FALSE; - gboolean _tmp2397_ = FALSE; - ValaMethod* _tmp2398_; + ValaDataType* collection_type = NULL; + gboolean _tmp1942_ = FALSE; + ValaMemberAccess* _tmp1943_; + gboolean _tmp1952_ = FALSE; + gboolean _tmp1953_ = FALSE; + gboolean _tmp1954_ = FALSE; + ValaDataType* _tmp1955_; + gboolean _tmp2015_ = FALSE; + gboolean _tmp2016_ = FALSE; + ValaMethod* _tmp2017_; + gboolean _tmp2055_ = FALSE; + gboolean _tmp2056_ = FALSE; + gboolean _tmp2057_ = FALSE; + gboolean _tmp2058_ = FALSE; + gboolean _tmp2059_ = FALSE; + ValaMethod* _tmp2060_; + gboolean _tmp2077_ = FALSE; + gboolean _tmp2078_ = FALSE; + ValaMethod* _tmp2079_; + ValaMethod* _tmp2098_; + gboolean _tmp2208_ = FALSE; + ValaCodeNode* _tmp2209_; + ValaCodeNode* _tmp2210_; + ValaList* _tmp2310_; + ValaIterator* _tmp2311_; + gboolean _tmp2464_ = FALSE; + gboolean _tmp2465_ = FALSE; + ValaMethod* _tmp2466_; self = (ValaCCodeMethodCallModule*) base; g_return_if_fail (expr != NULL); _tmp0_ = vala_method_call_get_call (expr); @@ -6087,524 +6094,709 @@ ((ValaCCodeBaseModule*) self)->requires_assert = TRUE; _g_free0 (message); } - if (return_result_via_out_param) { - ValaCCodeFunction* _tmp1942_; - ValaCCodeFunction* _tmp1943_; - ValaCCodeExpression* _tmp1944_; - ValaCCodeExpression* _tmp1945_; - ValaCCodeExpression* _tmp1946_; - _tmp1942_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1943_ = _tmp1942_; - _tmp1944_ = ccall_expr; - vala_ccode_function_add_expression (_tmp1943_, _tmp1944_); - _tmp1945_ = out_param_ref; - _tmp1946_ = _vala_ccode_node_ref0 (_tmp1945_); - _vala_ccode_node_unref0 (ccall_expr); - ccall_expr = _tmp1946_; - } - _tmp1949_ = m; - if (_tmp1949_ != NULL) { - ValaMethod* _tmp1950_; - ValaMemberBinding _tmp1951_; - ValaMemberBinding _tmp1952_; - _tmp1950_ = m; - _tmp1951_ = vala_method_get_binding (_tmp1950_); - _tmp1952_ = _tmp1951_; - _tmp1948_ = _tmp1952_ == VALA_MEMBER_BINDING_INSTANCE; + collection_type = NULL; + _tmp1943_ = ma; + if (_tmp1943_ != NULL) { + ValaMemberAccess* _tmp1944_; + ValaExpression* _tmp1945_; + ValaExpression* _tmp1946_; + _tmp1944_ = ma; + _tmp1945_ = vala_member_access_get_inner (_tmp1944_); + _tmp1946_ = _tmp1945_; + _tmp1942_ = _tmp1946_ != NULL; } else { - _tmp1948_ = FALSE; + _tmp1942_ = FALSE; } - if (_tmp1948_) { - ValaMethod* _tmp1953_; - gboolean _tmp1954_; - gboolean _tmp1955_; - _tmp1953_ = m; - _tmp1954_ = vala_method_get_returns_modified_pointer (_tmp1953_); - _tmp1955_ = _tmp1954_; - _tmp1947_ = _tmp1955_; - } else { - _tmp1947_ = FALSE; + if (_tmp1942_) { + ValaMemberAccess* _tmp1947_; + ValaExpression* _tmp1948_; + ValaExpression* _tmp1949_; + ValaDataType* _tmp1950_; + ValaDataType* _tmp1951_; + _tmp1947_ = ma; + _tmp1948_ = vala_member_access_get_inner (_tmp1947_); + _tmp1949_ = _tmp1948_; + _tmp1950_ = vala_expression_get_value_type (_tmp1949_); + _tmp1951_ = _tmp1950_; + collection_type = _tmp1951_; } - if (_tmp1947_) { + _tmp1955_ = collection_type; + if (_tmp1955_ != NULL) { gboolean _tmp1956_ = FALSE; gboolean _tmp1957_ = FALSE; - ValaMemberAccess* _tmp1958_; - _tmp1958_ = ma; - if (_tmp1958_ != NULL) { - ValaMemberAccess* _tmp1959_; - ValaExpression* _tmp1960_; - ValaExpression* _tmp1961_; - ValaSymbol* _tmp1962_; - ValaSymbol* _tmp1963_; - _tmp1959_ = ma; - _tmp1960_ = vala_member_access_get_inner (_tmp1959_); - _tmp1961_ = _tmp1960_; - _tmp1962_ = vala_expression_get_symbol_reference (_tmp1961_); - _tmp1963_ = _tmp1962_; - _tmp1957_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1963_, VALA_TYPE_PROPERTY); + ValaDataType* _tmp1958_; + ValaTypeSymbol* _tmp1959_; + ValaTypeSymbol* _tmp1960_; + ValaClass* _tmp1961_; + _tmp1958_ = collection_type; + _tmp1959_ = vala_data_type_get_type_symbol (_tmp1958_); + _tmp1960_ = _tmp1959_; + _tmp1961_ = ((ValaCCodeBaseModule*) self)->glist_type; + if (_tmp1960_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1961_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) { + _tmp1957_ = TRUE; } else { - _tmp1957_ = FALSE; + ValaDataType* _tmp1962_; + ValaTypeSymbol* _tmp1963_; + ValaTypeSymbol* _tmp1964_; + ValaClass* _tmp1965_; + _tmp1962_ = collection_type; + _tmp1963_ = vala_data_type_get_type_symbol (_tmp1962_); + _tmp1964_ = _tmp1963_; + _tmp1965_ = ((ValaCCodeBaseModule*) self)->gslist_type; + _tmp1957_ = _tmp1964_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1965_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol); } if (_tmp1957_) { - ValaMemberAccess* _tmp1964_; - ValaExpression* _tmp1965_; - ValaExpression* _tmp1966_; - _tmp1964_ = ma; - _tmp1965_ = vala_member_access_get_inner (_tmp1964_); - _tmp1966_ = _tmp1965_; - _tmp1956_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1966_, VALA_TYPE_MEMBER_ACCESS); + _tmp1956_ = TRUE; } else { - _tmp1956_ = FALSE; + ValaDataType* _tmp1966_; + ValaTypeSymbol* _tmp1967_; + ValaTypeSymbol* _tmp1968_; + ValaClass* _tmp1969_; + _tmp1966_ = collection_type; + _tmp1967_ = vala_data_type_get_type_symbol (_tmp1966_); + _tmp1968_ = _tmp1967_; + _tmp1969_ = ((ValaCCodeBaseModule*) self)->gqueue_type; + _tmp1956_ = _tmp1968_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1969_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol); } - if (_tmp1956_) { - ValaProperty* prop = NULL; - ValaMemberAccess* _tmp1967_; - ValaExpression* _tmp1968_; - ValaExpression* _tmp1969_; - ValaSymbol* _tmp1970_; - ValaSymbol* _tmp1971_; - ValaProperty* _tmp1972_; - ValaProperty* _tmp1973_; + _tmp1954_ = _tmp1956_; + } else { + _tmp1954_ = FALSE; + } + if (_tmp1954_) { + gboolean _tmp1970_ = FALSE; + ValaMemberAccess* _tmp1971_; + const gchar* _tmp1972_; + const gchar* _tmp1973_; + _tmp1971_ = ma; + _tmp1972_ = vala_member_access_get_member_name (_tmp1971_); + _tmp1973_ = _tmp1972_; + if (g_strcmp0 (_tmp1973_, "remove") == 0) { + _tmp1970_ = TRUE; + } else { ValaMemberAccess* _tmp1974_; - ValaExpression* _tmp1975_; - ValaExpression* _tmp1976_; - ValaExpression* _tmp1977_; - ValaExpression* _tmp1978_; - ValaDataType* _tmp1979_; - ValaDataType* _tmp1980_; - ValaCCodeExpression* _tmp1981_; - ValaGLibValue* _tmp1982_; - ValaGLibValue* _tmp1983_; - _tmp1967_ = ma; - _tmp1968_ = vala_member_access_get_inner (_tmp1967_); - _tmp1969_ = _tmp1968_; - _tmp1970_ = vala_expression_get_symbol_reference (_tmp1969_); - _tmp1971_ = _tmp1970_; - _tmp1972_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1971_, VALA_TYPE_PROPERTY, ValaProperty)); - prop = _tmp1972_; - _tmp1973_ = prop; + const gchar* _tmp1975_; + const gchar* _tmp1976_; _tmp1974_ = ma; - _tmp1975_ = vala_member_access_get_inner (_tmp1974_); + _tmp1975_ = vala_member_access_get_member_name (_tmp1974_); _tmp1976_ = _tmp1975_; - _tmp1977_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp1976_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); - _tmp1978_ = _tmp1977_; - _tmp1979_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp1980_ = _tmp1979_; - _tmp1981_ = ccall_expr; - _tmp1982_ = vala_glib_value_new (_tmp1980_, _tmp1981_, FALSE); - _tmp1983_ = _tmp1982_; - vala_ccode_base_module_store_property ((ValaCCodeBaseModule*) self, _tmp1973_, _tmp1978_, (ValaTargetValue*) _tmp1983_); - _vala_target_value_unref0 (_tmp1983_); + _tmp1970_ = g_strcmp0 (_tmp1976_, "remove_all") == 0; + } + _tmp1953_ = _tmp1970_; + } else { + _tmp1953_ = FALSE; + } + if (_tmp1953_) { + ValaDataType* _tmp1977_; + ValaCodeContext* _tmp1978_; + ValaCodeContext* _tmp1979_; + _tmp1977_ = collection_type; + _tmp1978_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); + _tmp1979_ = _tmp1978_; + _tmp1952_ = vala_data_type_check_type_arguments (_tmp1977_, _tmp1979_, FALSE); + } else { + _tmp1952_ = FALSE; + } + if (_tmp1952_) { + ValaMethod* remove_method = NULL; + ValaDataType* _tmp1980_; + ValaTypeSymbol* _tmp1981_; + ValaTypeSymbol* _tmp1982_; + ValaScope* _tmp1983_; + ValaScope* _tmp1984_; + ValaMemberAccess* _tmp1985_; + const gchar* _tmp1986_; + const gchar* _tmp1987_; + gchar* _tmp1988_; + gchar* _tmp1989_; + ValaSymbol* _tmp1990_; + ValaMethod* _tmp1991_; + ValaDataType* type_arg = NULL; + ValaDataType* _tmp1992_; + ValaList* _tmp1993_; + gpointer _tmp1994_; + gboolean _tmp1995_ = FALSE; + ValaMethod* _tmp1996_; + _tmp1980_ = collection_type; + _tmp1981_ = vala_data_type_get_type_symbol (_tmp1980_); + _tmp1982_ = _tmp1981_; + _tmp1983_ = vala_symbol_get_scope ((ValaSymbol*) _tmp1982_); + _tmp1984_ = _tmp1983_; + _tmp1985_ = ma; + _tmp1986_ = vala_member_access_get_member_name (_tmp1985_); + _tmp1987_ = _tmp1986_; + _tmp1988_ = g_strconcat (_tmp1987_, "_full", NULL); + _tmp1989_ = _tmp1988_; + _tmp1990_ = vala_scope_lookup (_tmp1984_, _tmp1989_); + _tmp1991_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1990_, VALA_TYPE_METHOD, ValaMethod); + _g_free0 (_tmp1989_); + remove_method = _tmp1991_; + _tmp1992_ = collection_type; + _tmp1993_ = vala_data_type_get_type_arguments (_tmp1992_); + _tmp1994_ = vala_list_get (_tmp1993_, 0); + type_arg = (ValaDataType*) _tmp1994_; + _tmp1996_ = remove_method; + if (_tmp1996_ != NULL) { + ValaDataType* _tmp1997_; + _tmp1997_ = type_arg; + _tmp1995_ = vala_ccode_base_module_requires_destroy (_tmp1997_); + } else { + _tmp1995_ = FALSE; + } + if (_tmp1995_) { + ValaMethod* _tmp1998_; + ValaCCodeFunctionCall* _tmp2000_; + ValaMethod* _tmp2001_; + gchar* _tmp2002_; + gchar* _tmp2003_; + ValaCCodeIdentifier* _tmp2004_; + ValaCCodeIdentifier* _tmp2005_; + ValaCCodeFunctionCall* _tmp2006_; + ValaDataType* _tmp2007_; + ValaCCodeExpression* _tmp2008_; + ValaCCodeExpression* _tmp2009_; + _tmp1998_ = remove_method; + if (vala_ccode_base_module_add_generated_external_symbol ((ValaCCodeBaseModule*) self, (ValaSymbol*) _tmp1998_)) { + ValaMethod* _tmp1999_; + _tmp1999_ = remove_method; + vala_code_visitor_visit_method ((ValaCodeVisitor*) self, _tmp1999_); + } + _tmp2000_ = ccall; + _tmp2001_ = remove_method; + _tmp2002_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2001_); + _tmp2003_ = _tmp2002_; + _tmp2004_ = vala_ccode_identifier_new (_tmp2003_); + _tmp2005_ = _tmp2004_; + vala_ccode_function_call_set_call (_tmp2000_, (ValaCCodeExpression*) _tmp2005_); + _vala_ccode_node_unref0 (_tmp2005_); + _g_free0 (_tmp2003_); + _tmp2006_ = ccall; + _tmp2007_ = type_arg; + _tmp2008_ = vala_ccode_base_module_get_destroy0_func_expression ((ValaCCodeBaseModule*) self, _tmp2007_, FALSE); + _tmp2009_ = _tmp2008_; + vala_ccode_function_call_add_argument (_tmp2006_, _tmp2009_); + _vala_ccode_node_unref0 (_tmp2009_); + } + _vala_code_node_unref0 (type_arg); + _vala_code_node_unref0 (remove_method); + } + if (return_result_via_out_param) { + ValaCCodeFunction* _tmp2010_; + ValaCCodeFunction* _tmp2011_; + ValaCCodeExpression* _tmp2012_; + ValaCCodeExpression* _tmp2013_; + ValaCCodeExpression* _tmp2014_; + _tmp2010_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2011_ = _tmp2010_; + _tmp2012_ = ccall_expr; + vala_ccode_function_add_expression (_tmp2011_, _tmp2012_); + _tmp2013_ = out_param_ref; + _tmp2014_ = _vala_ccode_node_ref0 (_tmp2013_); + _vala_ccode_node_unref0 (ccall_expr); + ccall_expr = _tmp2014_; + } + _tmp2017_ = m; + if (_tmp2017_ != NULL) { + ValaMethod* _tmp2018_; + ValaMemberBinding _tmp2019_; + ValaMemberBinding _tmp2020_; + _tmp2018_ = m; + _tmp2019_ = vala_method_get_binding (_tmp2018_); + _tmp2020_ = _tmp2019_; + _tmp2016_ = _tmp2020_ == VALA_MEMBER_BINDING_INSTANCE; + } else { + _tmp2016_ = FALSE; + } + if (_tmp2016_) { + ValaMethod* _tmp2021_; + gboolean _tmp2022_; + gboolean _tmp2023_; + _tmp2021_ = m; + _tmp2022_ = vala_method_get_returns_modified_pointer (_tmp2021_); + _tmp2023_ = _tmp2022_; + _tmp2015_ = _tmp2023_; + } else { + _tmp2015_ = FALSE; + } + if (_tmp2015_) { + gboolean _tmp2024_ = FALSE; + gboolean _tmp2025_ = FALSE; + ValaMemberAccess* _tmp2026_; + _tmp2026_ = ma; + if (_tmp2026_ != NULL) { + ValaMemberAccess* _tmp2027_; + ValaExpression* _tmp2028_; + ValaExpression* _tmp2029_; + ValaSymbol* _tmp2030_; + ValaSymbol* _tmp2031_; + _tmp2027_ = ma; + _tmp2028_ = vala_member_access_get_inner (_tmp2027_); + _tmp2029_ = _tmp2028_; + _tmp2030_ = vala_expression_get_symbol_reference (_tmp2029_); + _tmp2031_ = _tmp2030_; + _tmp2025_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2031_, VALA_TYPE_PROPERTY); + } else { + _tmp2025_ = FALSE; + } + if (_tmp2025_) { + ValaMemberAccess* _tmp2032_; + ValaExpression* _tmp2033_; + ValaExpression* _tmp2034_; + _tmp2032_ = ma; + _tmp2033_ = vala_member_access_get_inner (_tmp2032_); + _tmp2034_ = _tmp2033_; + _tmp2024_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2034_, VALA_TYPE_MEMBER_ACCESS); + } else { + _tmp2024_ = FALSE; + } + if (_tmp2024_) { + ValaProperty* prop = NULL; + ValaMemberAccess* _tmp2035_; + ValaExpression* _tmp2036_; + ValaExpression* _tmp2037_; + ValaSymbol* _tmp2038_; + ValaSymbol* _tmp2039_; + ValaProperty* _tmp2040_; + ValaProperty* _tmp2041_; + ValaMemberAccess* _tmp2042_; + ValaExpression* _tmp2043_; + ValaExpression* _tmp2044_; + ValaExpression* _tmp2045_; + ValaExpression* _tmp2046_; + ValaDataType* _tmp2047_; + ValaDataType* _tmp2048_; + ValaCCodeExpression* _tmp2049_; + ValaGLibValue* _tmp2050_; + ValaGLibValue* _tmp2051_; + _tmp2035_ = ma; + _tmp2036_ = vala_member_access_get_inner (_tmp2035_); + _tmp2037_ = _tmp2036_; + _tmp2038_ = vala_expression_get_symbol_reference (_tmp2037_); + _tmp2039_ = _tmp2038_; + _tmp2040_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2039_, VALA_TYPE_PROPERTY, ValaProperty)); + prop = _tmp2040_; + _tmp2041_ = prop; + _tmp2042_ = ma; + _tmp2043_ = vala_member_access_get_inner (_tmp2042_); + _tmp2044_ = _tmp2043_; + _tmp2045_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp2044_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); + _tmp2046_ = _tmp2045_; + _tmp2047_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2048_ = _tmp2047_; + _tmp2049_ = ccall_expr; + _tmp2050_ = vala_glib_value_new (_tmp2048_, _tmp2049_, FALSE); + _tmp2051_ = _tmp2050_; + vala_ccode_base_module_store_property ((ValaCCodeBaseModule*) self, _tmp2041_, _tmp2046_, (ValaTargetValue*) _tmp2051_); + _vala_target_value_unref0 (_tmp2051_); _vala_ccode_node_unref0 (ccall_expr); ccall_expr = NULL; _vala_code_node_unref0 (prop); } else { - ValaCCodeExpression* _tmp1984_; - ValaCCodeExpression* _tmp1985_; - ValaCCodeAssignment* _tmp1986_; - _tmp1984_ = instance; - _tmp1985_ = ccall_expr; - _tmp1986_ = vala_ccode_assignment_new (_tmp1984_, _tmp1985_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); + ValaCCodeExpression* _tmp2052_; + ValaCCodeExpression* _tmp2053_; + ValaCCodeAssignment* _tmp2054_; + _tmp2052_ = instance; + _tmp2053_ = ccall_expr; + _tmp2054_ = vala_ccode_assignment_new (_tmp2052_, _tmp2053_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); _vala_ccode_node_unref0 (ccall_expr); - ccall_expr = (ValaCCodeExpression*) _tmp1986_; + ccall_expr = (ValaCCodeExpression*) _tmp2054_; } } - _tmp1992_ = m; - if (_tmp1992_ != NULL) { - ValaMethod* _tmp1993_; - _tmp1993_ = m; - _tmp1991_ = vala_get_ccode_simple_generics (_tmp1993_); + _tmp2060_ = m; + if (_tmp2060_ != NULL) { + ValaMethod* _tmp2061_; + _tmp2061_ = m; + _tmp2059_ = vala_get_ccode_simple_generics (_tmp2061_); } else { - _tmp1991_ = FALSE; + _tmp2059_ = FALSE; } - if (_tmp1991_) { - ValaMethod* _tmp1994_; - ValaDataType* _tmp1995_; - ValaDataType* _tmp1996_; - _tmp1994_ = m; - _tmp1995_ = vala_callable_get_return_type ((ValaCallable*) _tmp1994_); - _tmp1996_ = _tmp1995_; - _tmp1990_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1996_, VALA_TYPE_GENERIC_TYPE); + if (_tmp2059_) { + ValaMethod* _tmp2062_; + ValaDataType* _tmp2063_; + ValaDataType* _tmp2064_; + _tmp2062_ = m; + _tmp2063_ = vala_callable_get_return_type ((ValaCallable*) _tmp2062_); + _tmp2064_ = _tmp2063_; + _tmp2058_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2064_, VALA_TYPE_GENERIC_TYPE); } else { - _tmp1990_ = FALSE; + _tmp2058_ = FALSE; } - if (_tmp1990_) { - ValaDataType* _tmp1997_; - ValaDataType* _tmp1998_; - _tmp1997_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp1998_ = _tmp1997_; - _tmp1989_ = vala_data_type_is_real_struct_type (_tmp1998_); + if (_tmp2058_) { + ValaDataType* _tmp2065_; + ValaDataType* _tmp2066_; + _tmp2065_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2066_ = _tmp2065_; + _tmp2057_ = vala_data_type_is_real_struct_type (_tmp2066_); } else { - _tmp1989_ = FALSE; + _tmp2057_ = FALSE; } - if (_tmp1989_) { - ValaDataType* _tmp1999_; - ValaDataType* _tmp2000_; - gboolean _tmp2001_; - gboolean _tmp2002_; - _tmp1999_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp2000_ = _tmp1999_; - _tmp2001_ = vala_data_type_get_nullable (_tmp2000_); - _tmp2002_ = _tmp2001_; - _tmp1988_ = !_tmp2002_; + if (_tmp2057_) { + ValaDataType* _tmp2067_; + ValaDataType* _tmp2068_; + gboolean _tmp2069_; + gboolean _tmp2070_; + _tmp2067_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2068_ = _tmp2067_; + _tmp2069_ = vala_data_type_get_nullable (_tmp2068_); + _tmp2070_ = _tmp2069_; + _tmp2056_ = !_tmp2070_; } else { - _tmp1988_ = FALSE; + _tmp2056_ = FALSE; } - if (_tmp1988_) { - ValaDataType* _tmp2003_; - ValaDataType* _tmp2004_; - _tmp2003_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp2004_ = _tmp2003_; - _tmp1987_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp2004_, VALA_TYPE_POINTER_TYPE); + if (_tmp2056_) { + ValaDataType* _tmp2071_; + ValaDataType* _tmp2072_; + _tmp2071_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2072_ = _tmp2071_; + _tmp2055_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp2072_, VALA_TYPE_POINTER_TYPE); } else { - _tmp1987_ = FALSE; + _tmp2055_ = FALSE; } - if (_tmp1987_) { - ValaCCodeExpression* _tmp2005_; - ValaCCodeParenthesizedExpression* _tmp2006_; - ValaCCodeParenthesizedExpression* _tmp2007_; - ValaCCodeUnaryExpression* _tmp2008_; - _tmp2005_ = ccall_expr; - _tmp2006_ = vala_ccode_parenthesized_expression_new (_tmp2005_); - _tmp2007_ = _tmp2006_; - _tmp2008_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp2007_); + if (_tmp2055_) { + ValaCCodeExpression* _tmp2073_; + ValaCCodeParenthesizedExpression* _tmp2074_; + ValaCCodeParenthesizedExpression* _tmp2075_; + ValaCCodeUnaryExpression* _tmp2076_; + _tmp2073_ = ccall_expr; + _tmp2074_ = vala_ccode_parenthesized_expression_new (_tmp2073_); + _tmp2075_ = _tmp2074_; + _tmp2076_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp2075_); _vala_ccode_node_unref0 (ccall_expr); - ccall_expr = (ValaCCodeExpression*) _tmp2008_; - _vala_ccode_node_unref0 (_tmp2007_); + ccall_expr = (ValaCCodeExpression*) _tmp2076_; + _vala_ccode_node_unref0 (_tmp2075_); } - _tmp2011_ = m; - if (_tmp2011_ != NULL) { - ValaMethod* _tmp2012_; - gchar* _tmp2013_; - gchar* _tmp2014_; - _tmp2012_ = m; - _tmp2013_ = vala_get_ccode_type ((ValaCodeNode*) _tmp2012_); - _tmp2014_ = _tmp2013_; - _tmp2010_ = _tmp2014_ != NULL; - _g_free0 (_tmp2014_); + _tmp2079_ = m; + if (_tmp2079_ != NULL) { + ValaMethod* _tmp2080_; + gchar* _tmp2081_; + gchar* _tmp2082_; + _tmp2080_ = m; + _tmp2081_ = vala_get_ccode_type ((ValaCodeNode*) _tmp2080_); + _tmp2082_ = _tmp2081_; + _tmp2078_ = _tmp2082_ != NULL; + _g_free0 (_tmp2082_); } else { - _tmp2010_ = FALSE; + _tmp2078_ = FALSE; } - if (_tmp2010_) { - ValaMethod* _tmp2015_; - gchar* _tmp2016_; - gchar* _tmp2017_; - ValaMethod* _tmp2018_; - ValaDataType* _tmp2019_; - ValaDataType* _tmp2020_; - gchar* _tmp2021_; - gchar* _tmp2022_; - _tmp2015_ = m; - _tmp2016_ = vala_get_ccode_type ((ValaCodeNode*) _tmp2015_); - _tmp2017_ = _tmp2016_; - _tmp2018_ = m; - _tmp2019_ = vala_callable_get_return_type ((ValaCallable*) _tmp2018_); - _tmp2020_ = _tmp2019_; - _tmp2021_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2020_); - _tmp2022_ = _tmp2021_; - _tmp2009_ = g_strcmp0 (_tmp2017_, _tmp2022_) != 0; - _g_free0 (_tmp2022_); - _g_free0 (_tmp2017_); + if (_tmp2078_) { + ValaMethod* _tmp2083_; + gchar* _tmp2084_; + gchar* _tmp2085_; + ValaMethod* _tmp2086_; + ValaDataType* _tmp2087_; + ValaDataType* _tmp2088_; + gchar* _tmp2089_; + gchar* _tmp2090_; + _tmp2083_ = m; + _tmp2084_ = vala_get_ccode_type ((ValaCodeNode*) _tmp2083_); + _tmp2085_ = _tmp2084_; + _tmp2086_ = m; + _tmp2087_ = vala_callable_get_return_type ((ValaCallable*) _tmp2086_); + _tmp2088_ = _tmp2087_; + _tmp2089_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2088_); + _tmp2090_ = _tmp2089_; + _tmp2077_ = g_strcmp0 (_tmp2085_, _tmp2090_) != 0; + _g_free0 (_tmp2090_); + _g_free0 (_tmp2085_); } else { - _tmp2009_ = FALSE; + _tmp2077_ = FALSE; } - if (_tmp2009_) { - ValaCCodeExpression* _tmp2023_; - ValaMethod* _tmp2024_; - ValaDataType* _tmp2025_; - ValaDataType* _tmp2026_; - gchar* _tmp2027_; - gchar* _tmp2028_; - ValaCCodeCastExpression* _tmp2029_; - _tmp2023_ = ccall_expr; - _tmp2024_ = m; - _tmp2025_ = vala_callable_get_return_type ((ValaCallable*) _tmp2024_); - _tmp2026_ = _tmp2025_; - _tmp2027_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2026_); - _tmp2028_ = _tmp2027_; - _tmp2029_ = vala_ccode_cast_expression_new (_tmp2023_, _tmp2028_); + if (_tmp2077_) { + ValaCCodeExpression* _tmp2091_; + ValaMethod* _tmp2092_; + ValaDataType* _tmp2093_; + ValaDataType* _tmp2094_; + gchar* _tmp2095_; + gchar* _tmp2096_; + ValaCCodeCastExpression* _tmp2097_; + _tmp2091_ = ccall_expr; + _tmp2092_ = m; + _tmp2093_ = vala_callable_get_return_type ((ValaCallable*) _tmp2092_); + _tmp2094_ = _tmp2093_; + _tmp2095_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2094_); + _tmp2096_ = _tmp2095_; + _tmp2097_ = vala_ccode_cast_expression_new (_tmp2091_, _tmp2096_); _vala_ccode_node_unref0 (ccall_expr); - ccall_expr = (ValaCCodeExpression*) _tmp2029_; - _g_free0 (_tmp2028_); + ccall_expr = (ValaCCodeExpression*) _tmp2097_; + _g_free0 (_tmp2096_); } - _tmp2030_ = m; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2030_, VALA_TYPE_ARRAY_RESIZE_METHOD)) { + _tmp2098_ = m; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2098_, VALA_TYPE_ARRAY_RESIZE_METHOD)) { ValaIterator* arg_it = NULL; - ValaList* _tmp2031_; - ValaIterator* _tmp2032_; - ValaIterator* _tmp2033_; + ValaList* _tmp2099_; + ValaIterator* _tmp2100_; + ValaIterator* _tmp2101_; ValaCCodeExpression* new_size = NULL; - ValaIterator* _tmp2034_; - gpointer _tmp2035_; - ValaExpression* _tmp2036_; - ValaCCodeExpression* _tmp2037_; - ValaCCodeExpression* _tmp2038_; - ValaCCodeExpression* _tmp2039_; + ValaIterator* _tmp2102_; + gpointer _tmp2103_; + ValaExpression* _tmp2104_; + ValaCCodeExpression* _tmp2105_; + ValaCCodeExpression* _tmp2106_; + ValaCCodeExpression* _tmp2107_; ValaLocalVariable* temp_decl = NULL; - ValaDataType* _tmp2040_; - ValaLocalVariable* _tmp2041_; + ValaDataType* _tmp2108_; + ValaLocalVariable* _tmp2109_; ValaCCodeExpression* temp_ref = NULL; - ValaLocalVariable* _tmp2042_; - const gchar* _tmp2043_; - const gchar* _tmp2044_; - ValaCCodeExpression* _tmp2045_; - ValaLocalVariable* _tmp2046_; - ValaCCodeFile* _tmp2047_; + ValaLocalVariable* _tmp2110_; + const gchar* _tmp2111_; + const gchar* _tmp2112_; + ValaCCodeExpression* _tmp2113_; + ValaLocalVariable* _tmp2114_; + ValaCCodeFile* _tmp2115_; ValaCCodeExpression* clen = NULL; - ValaMemberAccess* _tmp2048_; - ValaExpression* _tmp2049_; - ValaExpression* _tmp2050_; - ValaCCodeExpression* _tmp2051_; + ValaMemberAccess* _tmp2116_; + ValaExpression* _tmp2117_; + ValaExpression* _tmp2118_; + ValaCCodeExpression* _tmp2119_; ValaCCodeExpression* celems = NULL; - ValaMemberAccess* _tmp2052_; - ValaExpression* _tmp2053_; - ValaExpression* _tmp2054_; - ValaCCodeExpression* _tmp2055_; - ValaCCodeExpression* _tmp2056_; + ValaMemberAccess* _tmp2120_; + ValaExpression* _tmp2121_; + ValaExpression* _tmp2122_; + ValaCCodeExpression* _tmp2123_; + ValaCCodeExpression* _tmp2124_; ValaArrayType* array_type = NULL; - ValaMemberAccess* _tmp2057_; - ValaExpression* _tmp2058_; - ValaExpression* _tmp2059_; - ValaDataType* _tmp2060_; - ValaDataType* _tmp2061_; - ValaArrayType* _tmp2062_; + ValaMemberAccess* _tmp2125_; + ValaExpression* _tmp2126_; + ValaExpression* _tmp2127_; + ValaDataType* _tmp2128_; + ValaDataType* _tmp2129_; + ValaArrayType* _tmp2130_; ValaCCodeIdentifier* csizeof = NULL; - ValaArrayType* _tmp2063_; - ValaDataType* _tmp2064_; - ValaDataType* _tmp2065_; - gchar* _tmp2066_; - gchar* _tmp2067_; - gchar* _tmp2068_; - gchar* _tmp2069_; - ValaCCodeIdentifier* _tmp2070_; - ValaCCodeIdentifier* _tmp2071_; + ValaArrayType* _tmp2131_; + ValaDataType* _tmp2132_; + ValaDataType* _tmp2133_; + gchar* _tmp2134_; + gchar* _tmp2135_; + gchar* _tmp2136_; + gchar* _tmp2137_; + ValaCCodeIdentifier* _tmp2138_; + ValaCCodeIdentifier* _tmp2139_; ValaCCodeBinaryExpression* cdelta = NULL; - ValaCCodeExpression* _tmp2072_; - ValaCCodeExpression* _tmp2073_; - ValaCCodeBinaryExpression* _tmp2074_; + ValaCCodeExpression* _tmp2140_; + ValaCCodeExpression* _tmp2141_; + ValaCCodeBinaryExpression* _tmp2142_; ValaCCodeBinaryExpression* ccheck = NULL; - ValaCCodeExpression* _tmp2075_; - ValaCCodeExpression* _tmp2076_; - ValaCCodeBinaryExpression* _tmp2077_; + ValaCCodeExpression* _tmp2143_; + ValaCCodeExpression* _tmp2144_; + ValaCCodeBinaryExpression* _tmp2145_; ValaCCodeFunctionCall* czero = NULL; - ValaCCodeIdentifier* _tmp2078_; - ValaCCodeIdentifier* _tmp2079_; - ValaCCodeFunctionCall* _tmp2080_; - ValaCCodeFunctionCall* _tmp2081_; - ValaCCodeFunctionCall* _tmp2082_; - ValaCCodeExpression* _tmp2083_; - ValaCCodeExpression* _tmp2084_; - ValaCCodeBinaryExpression* _tmp2085_; - ValaCCodeBinaryExpression* _tmp2086_; - ValaCCodeFunctionCall* _tmp2087_; - ValaCCodeConstant* _tmp2088_; - ValaCCodeConstant* _tmp2089_; - ValaCCodeFunctionCall* _tmp2090_; - ValaCCodeIdentifier* _tmp2091_; - ValaCCodeBinaryExpression* _tmp2092_; - ValaCCodeBinaryExpression* _tmp2093_; - ValaCCodeBinaryExpression* _tmp2094_; - ValaCCodeFunction* _tmp2095_; - ValaCCodeFunction* _tmp2096_; - ValaCCodeExpression* _tmp2097_; - ValaCCodeExpression* _tmp2098_; - ValaCCodeFunction* _tmp2099_; - ValaCCodeFunction* _tmp2100_; - ValaCCodeExpression* _tmp2101_; - ValaCCodeFunction* _tmp2102_; - ValaCCodeFunction* _tmp2103_; - ValaCCodeBinaryExpression* _tmp2104_; - ValaCCodeFunctionCall* _tmp2105_; - ValaCCodeConstant* _tmp2106_; - ValaCCodeConstant* _tmp2107_; - ValaCCodeConditionalExpression* _tmp2108_; - ValaCCodeConditionalExpression* _tmp2109_; - ValaCCodeFunction* _tmp2110_; - ValaCCodeFunction* _tmp2111_; - ValaMemberAccess* _tmp2112_; - ValaExpression* _tmp2113_; - ValaExpression* _tmp2114_; - ValaCCodeExpression* _tmp2115_; - ValaCCodeExpression* _tmp2116_; - ValaCCodeExpression* _tmp2117_; + ValaCCodeIdentifier* _tmp2146_; + ValaCCodeIdentifier* _tmp2147_; + ValaCCodeFunctionCall* _tmp2148_; + ValaCCodeFunctionCall* _tmp2149_; + ValaCCodeFunctionCall* _tmp2150_; + ValaCCodeExpression* _tmp2151_; + ValaCCodeExpression* _tmp2152_; + ValaCCodeBinaryExpression* _tmp2153_; + ValaCCodeBinaryExpression* _tmp2154_; + ValaCCodeFunctionCall* _tmp2155_; + ValaCCodeConstant* _tmp2156_; + ValaCCodeConstant* _tmp2157_; + ValaCCodeFunctionCall* _tmp2158_; + ValaCCodeIdentifier* _tmp2159_; + ValaCCodeBinaryExpression* _tmp2160_; + ValaCCodeBinaryExpression* _tmp2161_; + ValaCCodeBinaryExpression* _tmp2162_; + ValaCCodeFunction* _tmp2163_; + ValaCCodeFunction* _tmp2164_; + ValaCCodeExpression* _tmp2165_; + ValaCCodeExpression* _tmp2166_; + ValaCCodeFunction* _tmp2167_; + ValaCCodeFunction* _tmp2168_; + ValaCCodeExpression* _tmp2169_; + ValaCCodeFunction* _tmp2170_; + ValaCCodeFunction* _tmp2171_; + ValaCCodeBinaryExpression* _tmp2172_; + ValaCCodeFunctionCall* _tmp2173_; + ValaCCodeConstant* _tmp2174_; + ValaCCodeConstant* _tmp2175_; + ValaCCodeConditionalExpression* _tmp2176_; + ValaCCodeConditionalExpression* _tmp2177_; + ValaCCodeFunction* _tmp2178_; + ValaCCodeFunction* _tmp2179_; + ValaMemberAccess* _tmp2180_; + ValaExpression* _tmp2181_; + ValaExpression* _tmp2182_; + ValaCCodeExpression* _tmp2183_; + ValaCCodeExpression* _tmp2184_; + ValaCCodeExpression* _tmp2185_; ValaSymbol* array_var = NULL; - ValaMemberAccess* _tmp2118_; - ValaExpression* _tmp2119_; - ValaExpression* _tmp2120_; - ValaSymbol* _tmp2121_; - ValaSymbol* _tmp2122_; - ValaSymbol* _tmp2123_; - gboolean _tmp2124_ = FALSE; - gboolean _tmp2125_ = FALSE; - ValaSymbol* _tmp2126_; - _tmp2031_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) expr); - _tmp2032_ = vala_iterable_iterator ((ValaIterable*) _tmp2031_); - arg_it = _tmp2032_; - _tmp2033_ = arg_it; - vala_iterator_next (_tmp2033_); - _tmp2034_ = arg_it; - _tmp2035_ = vala_iterator_get (_tmp2034_); - _tmp2036_ = (ValaExpression*) _tmp2035_; - _tmp2037_ = vala_get_cvalue (_tmp2036_); - _tmp2038_ = _vala_ccode_node_ref0 (_tmp2037_); - _tmp2039_ = _tmp2038_; - _vala_code_node_unref0 (_tmp2036_); - new_size = _tmp2039_; - _tmp2040_ = ((ValaCCodeBaseModule*) self)->int_type; - _tmp2041_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp2040_, TRUE, NULL, FALSE); - temp_decl = _tmp2041_; - _tmp2042_ = temp_decl; - _tmp2043_ = vala_symbol_get_name ((ValaSymbol*) _tmp2042_); - _tmp2044_ = _tmp2043_; - _tmp2045_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp2044_); - temp_ref = _tmp2045_; - _tmp2046_ = temp_decl; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp2046_, FALSE); - _tmp2047_ = ((ValaCCodeBaseModule*) self)->cfile; - vala_ccode_file_add_include (_tmp2047_, "string.h", FALSE); - _tmp2048_ = ma; - _tmp2049_ = vala_member_access_get_inner (_tmp2048_); - _tmp2050_ = _tmp2049_; - _tmp2051_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp2050_, 1); - clen = _tmp2051_; - _tmp2052_ = ma; - _tmp2053_ = vala_member_access_get_inner (_tmp2052_); - _tmp2054_ = _tmp2053_; - _tmp2055_ = vala_get_cvalue (_tmp2054_); - _tmp2056_ = _vala_ccode_node_ref0 (_tmp2055_); - celems = _tmp2056_; - _tmp2057_ = ma; - _tmp2058_ = vala_member_access_get_inner (_tmp2057_); - _tmp2059_ = _tmp2058_; - _tmp2060_ = vala_expression_get_value_type (_tmp2059_); - _tmp2061_ = _tmp2060_; - _tmp2062_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2061_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp2062_; - _tmp2063_ = array_type; - _tmp2064_ = vala_array_type_get_element_type (_tmp2063_); - _tmp2065_ = _tmp2064_; - _tmp2066_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2065_); - _tmp2067_ = _tmp2066_; - _tmp2068_ = g_strdup_printf ("sizeof (%s)", _tmp2067_); - _tmp2069_ = _tmp2068_; - _tmp2070_ = vala_ccode_identifier_new (_tmp2069_); - _tmp2071_ = _tmp2070_; - _g_free0 (_tmp2069_); - _g_free0 (_tmp2067_); - csizeof = _tmp2071_; - _tmp2072_ = temp_ref; - _tmp2073_ = clen; - _tmp2074_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MINUS, _tmp2072_, _tmp2073_); - cdelta = _tmp2074_; - _tmp2075_ = temp_ref; - _tmp2076_ = clen; - _tmp2077_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, _tmp2075_, _tmp2076_); - ccheck = _tmp2077_; - _tmp2078_ = vala_ccode_identifier_new ("memset"); - _tmp2079_ = _tmp2078_; - _tmp2080_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2079_); - _tmp2081_ = _tmp2080_; - _vala_ccode_node_unref0 (_tmp2079_); - czero = _tmp2081_; - _tmp2082_ = czero; - _tmp2083_ = celems; - _tmp2084_ = clen; - _tmp2085_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, _tmp2083_, _tmp2084_); - _tmp2086_ = _tmp2085_; - vala_ccode_function_call_add_argument (_tmp2082_, (ValaCCodeExpression*) _tmp2086_); - _vala_ccode_node_unref0 (_tmp2086_); - _tmp2087_ = czero; - _tmp2088_ = vala_ccode_constant_new ("0"); - _tmp2089_ = _tmp2088_; - vala_ccode_function_call_add_argument (_tmp2087_, (ValaCCodeExpression*) _tmp2089_); - _vala_ccode_node_unref0 (_tmp2089_); - _tmp2090_ = czero; - _tmp2091_ = csizeof; - _tmp2092_ = cdelta; - _tmp2093_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) _tmp2091_, (ValaCCodeExpression*) _tmp2092_); - _tmp2094_ = _tmp2093_; - vala_ccode_function_call_add_argument (_tmp2090_, (ValaCCodeExpression*) _tmp2094_); - _vala_ccode_node_unref0 (_tmp2094_); - _tmp2095_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2096_ = _tmp2095_; - _tmp2097_ = temp_ref; - _tmp2098_ = new_size; - vala_ccode_function_add_assignment (_tmp2096_, _tmp2097_, _tmp2098_); - _tmp2099_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2100_ = _tmp2099_; - _tmp2101_ = ccall_expr; - vala_ccode_function_add_expression (_tmp2100_, _tmp2101_); - _tmp2102_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2103_ = _tmp2102_; - _tmp2104_ = ccheck; - _tmp2105_ = czero; - _tmp2106_ = vala_ccode_constant_new ("NULL"); + ValaMemberAccess* _tmp2186_; + ValaExpression* _tmp2187_; + ValaExpression* _tmp2188_; + ValaSymbol* _tmp2189_; + ValaSymbol* _tmp2190_; + ValaSymbol* _tmp2191_; + gboolean _tmp2192_ = FALSE; + gboolean _tmp2193_ = FALSE; + ValaSymbol* _tmp2194_; + _tmp2099_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) expr); + _tmp2100_ = vala_iterable_iterator ((ValaIterable*) _tmp2099_); + arg_it = _tmp2100_; + _tmp2101_ = arg_it; + vala_iterator_next (_tmp2101_); + _tmp2102_ = arg_it; + _tmp2103_ = vala_iterator_get (_tmp2102_); + _tmp2104_ = (ValaExpression*) _tmp2103_; + _tmp2105_ = vala_get_cvalue (_tmp2104_); + _tmp2106_ = _vala_ccode_node_ref0 (_tmp2105_); _tmp2107_ = _tmp2106_; - _tmp2108_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp2104_, (ValaCCodeExpression*) _tmp2105_, (ValaCCodeExpression*) _tmp2107_); - _tmp2109_ = _tmp2108_; - vala_ccode_function_add_expression (_tmp2103_, (ValaCCodeExpression*) _tmp2109_); - _vala_ccode_node_unref0 (_tmp2109_); - _vala_ccode_node_unref0 (_tmp2107_); - _tmp2110_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2111_ = _tmp2110_; - _tmp2112_ = ma; - _tmp2113_ = vala_member_access_get_inner (_tmp2112_); - _tmp2114_ = _tmp2113_; - _tmp2115_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp2114_, 1); - _tmp2116_ = _tmp2115_; - _tmp2117_ = temp_ref; - vala_ccode_function_add_assignment (_tmp2111_, _tmp2116_, _tmp2117_); - _vala_ccode_node_unref0 (_tmp2116_); - _tmp2118_ = ma; - _tmp2119_ = vala_member_access_get_inner (_tmp2118_); - _tmp2120_ = _tmp2119_; - _tmp2121_ = vala_expression_get_symbol_reference (_tmp2120_); + _vala_code_node_unref0 (_tmp2104_); + new_size = _tmp2107_; + _tmp2108_ = ((ValaCCodeBaseModule*) self)->int_type; + _tmp2109_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp2108_, TRUE, NULL, FALSE); + temp_decl = _tmp2109_; + _tmp2110_ = temp_decl; + _tmp2111_ = vala_symbol_get_name ((ValaSymbol*) _tmp2110_); + _tmp2112_ = _tmp2111_; + _tmp2113_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp2112_); + temp_ref = _tmp2113_; + _tmp2114_ = temp_decl; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp2114_, FALSE); + _tmp2115_ = ((ValaCCodeBaseModule*) self)->cfile; + vala_ccode_file_add_include (_tmp2115_, "string.h", FALSE); + _tmp2116_ = ma; + _tmp2117_ = vala_member_access_get_inner (_tmp2116_); + _tmp2118_ = _tmp2117_; + _tmp2119_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp2118_, 1); + clen = _tmp2119_; + _tmp2120_ = ma; + _tmp2121_ = vala_member_access_get_inner (_tmp2120_); _tmp2122_ = _tmp2121_; - _tmp2123_ = _vala_code_node_ref0 (_tmp2122_); - array_var = _tmp2123_; - _tmp2126_ = array_var; - if (_tmp2126_ != NULL) { - ValaSymbol* _tmp2127_; - _tmp2127_ = array_var; - _tmp2125_ = vala_symbol_is_internal_symbol (_tmp2127_); - } else { - _tmp2125_ = FALSE; - } - if (_tmp2125_) { - gboolean _tmp2128_ = FALSE; - ValaSymbol* _tmp2129_; - _tmp2129_ = array_var; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2129_, VALA_TYPE_LOCAL_VARIABLE)) { - _tmp2128_ = TRUE; - } else { - ValaSymbol* _tmp2130_; - _tmp2130_ = array_var; - _tmp2128_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2130_, VALA_TYPE_FIELD); - } - _tmp2124_ = _tmp2128_; - } else { - _tmp2124_ = FALSE; - } - if (_tmp2124_) { - ValaCCodeFunction* _tmp2131_; - ValaCCodeFunction* _tmp2132_; - ValaMemberAccess* _tmp2133_; - ValaExpression* _tmp2134_; - ValaExpression* _tmp2135_; - ValaTargetValue* _tmp2136_; - ValaTargetValue* _tmp2137_; - ValaCCodeExpression* _tmp2138_; - ValaCCodeExpression* _tmp2139_; - _tmp2131_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2132_ = _tmp2131_; - _tmp2133_ = ma; - _tmp2134_ = vala_member_access_get_inner (_tmp2133_); - _tmp2135_ = _tmp2134_; - _tmp2136_ = vala_expression_get_target_value (_tmp2135_); - _tmp2137_ = _tmp2136_; - _tmp2138_ = vala_get_array_size_cvalue (_tmp2137_); - _tmp2139_ = temp_ref; - vala_ccode_function_add_assignment (_tmp2132_, _tmp2138_, _tmp2139_); + _tmp2123_ = vala_get_cvalue (_tmp2122_); + _tmp2124_ = _vala_ccode_node_ref0 (_tmp2123_); + celems = _tmp2124_; + _tmp2125_ = ma; + _tmp2126_ = vala_member_access_get_inner (_tmp2125_); + _tmp2127_ = _tmp2126_; + _tmp2128_ = vala_expression_get_value_type (_tmp2127_); + _tmp2129_ = _tmp2128_; + _tmp2130_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2129_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp2130_; + _tmp2131_ = array_type; + _tmp2132_ = vala_array_type_get_element_type (_tmp2131_); + _tmp2133_ = _tmp2132_; + _tmp2134_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2133_); + _tmp2135_ = _tmp2134_; + _tmp2136_ = g_strdup_printf ("sizeof (%s)", _tmp2135_); + _tmp2137_ = _tmp2136_; + _tmp2138_ = vala_ccode_identifier_new (_tmp2137_); + _tmp2139_ = _tmp2138_; + _g_free0 (_tmp2137_); + _g_free0 (_tmp2135_); + csizeof = _tmp2139_; + _tmp2140_ = temp_ref; + _tmp2141_ = clen; + _tmp2142_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MINUS, _tmp2140_, _tmp2141_); + cdelta = _tmp2142_; + _tmp2143_ = temp_ref; + _tmp2144_ = clen; + _tmp2145_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, _tmp2143_, _tmp2144_); + ccheck = _tmp2145_; + _tmp2146_ = vala_ccode_identifier_new ("memset"); + _tmp2147_ = _tmp2146_; + _tmp2148_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2147_); + _tmp2149_ = _tmp2148_; + _vala_ccode_node_unref0 (_tmp2147_); + czero = _tmp2149_; + _tmp2150_ = czero; + _tmp2151_ = celems; + _tmp2152_ = clen; + _tmp2153_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, _tmp2151_, _tmp2152_); + _tmp2154_ = _tmp2153_; + vala_ccode_function_call_add_argument (_tmp2150_, (ValaCCodeExpression*) _tmp2154_); + _vala_ccode_node_unref0 (_tmp2154_); + _tmp2155_ = czero; + _tmp2156_ = vala_ccode_constant_new ("0"); + _tmp2157_ = _tmp2156_; + vala_ccode_function_call_add_argument (_tmp2155_, (ValaCCodeExpression*) _tmp2157_); + _vala_ccode_node_unref0 (_tmp2157_); + _tmp2158_ = czero; + _tmp2159_ = csizeof; + _tmp2160_ = cdelta; + _tmp2161_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) _tmp2159_, (ValaCCodeExpression*) _tmp2160_); + _tmp2162_ = _tmp2161_; + vala_ccode_function_call_add_argument (_tmp2158_, (ValaCCodeExpression*) _tmp2162_); + _vala_ccode_node_unref0 (_tmp2162_); + _tmp2163_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2164_ = _tmp2163_; + _tmp2165_ = temp_ref; + _tmp2166_ = new_size; + vala_ccode_function_add_assignment (_tmp2164_, _tmp2165_, _tmp2166_); + _tmp2167_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2168_ = _tmp2167_; + _tmp2169_ = ccall_expr; + vala_ccode_function_add_expression (_tmp2168_, _tmp2169_); + _tmp2170_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2171_ = _tmp2170_; + _tmp2172_ = ccheck; + _tmp2173_ = czero; + _tmp2174_ = vala_ccode_constant_new ("NULL"); + _tmp2175_ = _tmp2174_; + _tmp2176_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp2172_, (ValaCCodeExpression*) _tmp2173_, (ValaCCodeExpression*) _tmp2175_); + _tmp2177_ = _tmp2176_; + vala_ccode_function_add_expression (_tmp2171_, (ValaCCodeExpression*) _tmp2177_); + _vala_ccode_node_unref0 (_tmp2177_); + _vala_ccode_node_unref0 (_tmp2175_); + _tmp2178_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2179_ = _tmp2178_; + _tmp2180_ = ma; + _tmp2181_ = vala_member_access_get_inner (_tmp2180_); + _tmp2182_ = _tmp2181_; + _tmp2183_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp2182_, 1); + _tmp2184_ = _tmp2183_; + _tmp2185_ = temp_ref; + vala_ccode_function_add_assignment (_tmp2179_, _tmp2184_, _tmp2185_); + _vala_ccode_node_unref0 (_tmp2184_); + _tmp2186_ = ma; + _tmp2187_ = vala_member_access_get_inner (_tmp2186_); + _tmp2188_ = _tmp2187_; + _tmp2189_ = vala_expression_get_symbol_reference (_tmp2188_); + _tmp2190_ = _tmp2189_; + _tmp2191_ = _vala_code_node_ref0 (_tmp2190_); + array_var = _tmp2191_; + _tmp2194_ = array_var; + if (_tmp2194_ != NULL) { + ValaSymbol* _tmp2195_; + _tmp2195_ = array_var; + _tmp2193_ = vala_symbol_is_internal_symbol (_tmp2195_); + } else { + _tmp2193_ = FALSE; + } + if (_tmp2193_) { + gboolean _tmp2196_ = FALSE; + ValaSymbol* _tmp2197_; + _tmp2197_ = array_var; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2197_, VALA_TYPE_LOCAL_VARIABLE)) { + _tmp2196_ = TRUE; + } else { + ValaSymbol* _tmp2198_; + _tmp2198_ = array_var; + _tmp2196_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2198_, VALA_TYPE_FIELD); + } + _tmp2192_ = _tmp2196_; + } else { + _tmp2192_ = FALSE; + } + if (_tmp2192_) { + ValaCCodeFunction* _tmp2199_; + ValaCCodeFunction* _tmp2200_; + ValaMemberAccess* _tmp2201_; + ValaExpression* _tmp2202_; + ValaExpression* _tmp2203_; + ValaTargetValue* _tmp2204_; + ValaTargetValue* _tmp2205_; + ValaCCodeExpression* _tmp2206_; + ValaCCodeExpression* _tmp2207_; + _tmp2199_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2200_ = _tmp2199_; + _tmp2201_ = ma; + _tmp2202_ = vala_member_access_get_inner (_tmp2201_); + _tmp2203_ = _tmp2202_; + _tmp2204_ = vala_expression_get_target_value (_tmp2203_); + _tmp2205_ = _tmp2204_; + _tmp2206_ = vala_get_array_size_cvalue (_tmp2205_); + _tmp2207_ = temp_ref; + vala_ccode_function_add_assignment (_tmp2200_, _tmp2206_, _tmp2207_); } _vala_code_node_unref0 (array_var); _vala_ccode_node_unref0 (czero); @@ -6634,736 +6826,736 @@ _vala_ccode_node_unref0 (ccall); return; } - _tmp2141_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr); - _tmp2142_ = _tmp2141_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2142_, VALA_TYPE_EXPRESSION_STATEMENT)) { - ValaDataType* _tmp2143_; - ValaDataType* _tmp2144_; - _tmp2143_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp2144_ = _tmp2143_; - _tmp2140_ = !vala_data_type_is_disposable (_tmp2144_); + _tmp2209_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr); + _tmp2210_ = _tmp2209_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2210_, VALA_TYPE_EXPRESSION_STATEMENT)) { + ValaDataType* _tmp2211_; + ValaDataType* _tmp2212_; + _tmp2211_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2212_ = _tmp2211_; + _tmp2208_ = !vala_data_type_is_disposable (_tmp2212_); } else { - _tmp2140_ = FALSE; + _tmp2208_ = FALSE; } - if (_tmp2140_) { - gboolean _tmp2145_ = FALSE; - ValaCCodeExpression* _tmp2146_; - _tmp2146_ = ccall_expr; - if (_tmp2146_ != NULL) { - _tmp2145_ = !return_result_via_out_param; - } else { - _tmp2145_ = FALSE; - } - if (_tmp2145_) { - ValaCCodeFunction* _tmp2147_; - ValaCCodeFunction* _tmp2148_; - ValaCCodeExpression* _tmp2149_; - _tmp2147_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2148_ = _tmp2147_; - _tmp2149_ = ccall_expr; - vala_ccode_function_add_expression (_tmp2148_, _tmp2149_); + if (_tmp2208_) { + gboolean _tmp2213_ = FALSE; + ValaCCodeExpression* _tmp2214_; + _tmp2214_ = ccall_expr; + if (_tmp2214_ != NULL) { + _tmp2213_ = !return_result_via_out_param; + } else { + _tmp2213_ = FALSE; + } + if (_tmp2213_) { + ValaCCodeFunction* _tmp2215_; + ValaCCodeFunction* _tmp2216_; + ValaCCodeExpression* _tmp2217_; + _tmp2215_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2216_ = _tmp2215_; + _tmp2217_ = ccall_expr; + vala_ccode_function_add_expression (_tmp2216_, _tmp2217_); } } else { ValaDataType* result_type = NULL; - ValaDataType* _tmp2150_; - ValaDataType* _tmp2151_; - ValaDataType* _tmp2152_; - gboolean _tmp2153_ = FALSE; - ValaDataType* _tmp2154_; - ValaDataType* _tmp2155_; - gboolean _tmp2208_ = FALSE; - ValaMethod* _tmp2209_; - _tmp2150_ = itype; - _tmp2151_ = vala_data_type_get_return_type (_tmp2150_); - _tmp2152_ = _vala_code_node_ref0 (_tmp2151_); - result_type = _tmp2152_; - _tmp2154_ = vala_expression_get_formal_value_type ((ValaExpression*) expr); - _tmp2155_ = _tmp2154_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2155_, VALA_TYPE_GENERIC_TYPE)) { - ValaDataType* _tmp2156_; - ValaDataType* _tmp2157_; - _tmp2156_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp2157_ = _tmp2156_; - _tmp2153_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp2157_, VALA_TYPE_GENERIC_TYPE); + ValaDataType* _tmp2218_; + ValaDataType* _tmp2219_; + ValaDataType* _tmp2220_; + gboolean _tmp2221_ = FALSE; + ValaDataType* _tmp2222_; + ValaDataType* _tmp2223_; + gboolean _tmp2276_ = FALSE; + ValaMethod* _tmp2277_; + _tmp2218_ = itype; + _tmp2219_ = vala_data_type_get_return_type (_tmp2218_); + _tmp2220_ = _vala_code_node_ref0 (_tmp2219_); + result_type = _tmp2220_; + _tmp2222_ = vala_expression_get_formal_value_type ((ValaExpression*) expr); + _tmp2223_ = _tmp2222_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2223_, VALA_TYPE_GENERIC_TYPE)) { + ValaDataType* _tmp2224_; + ValaDataType* _tmp2225_; + _tmp2224_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2225_ = _tmp2224_; + _tmp2221_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp2225_, VALA_TYPE_GENERIC_TYPE); } else { - _tmp2153_ = FALSE; + _tmp2221_ = FALSE; } - if (_tmp2153_) { + if (_tmp2221_) { ValaTypeParameter* type_parameter = NULL; - ValaDataType* _tmp2158_; - ValaDataType* _tmp2159_; - ValaTypeParameter* _tmp2160_; - ValaTypeParameter* _tmp2161_; - ValaTypeParameter* _tmp2162_; + ValaDataType* _tmp2226_; + ValaDataType* _tmp2227_; + ValaTypeParameter* _tmp2228_; + ValaTypeParameter* _tmp2229_; + ValaTypeParameter* _tmp2230_; ValaStruct* st = NULL; - ValaTypeParameter* _tmp2163_; - ValaSymbol* _tmp2164_; - ValaSymbol* _tmp2165_; - ValaSymbol* _tmp2166_; - ValaSymbol* _tmp2167_; - ValaStruct* _tmp2168_; - gboolean _tmp2169_ = FALSE; - ValaTypeParameter* _tmp2170_; - ValaSymbol* _tmp2171_; - ValaSymbol* _tmp2172_; - ValaTypeSymbol* _tmp2173_; - gboolean _tmp2182_ = FALSE; - gboolean _tmp2183_ = FALSE; - ValaStruct* _tmp2184_; - _tmp2158_ = vala_expression_get_formal_value_type ((ValaExpression*) expr); - _tmp2159_ = _tmp2158_; - _tmp2160_ = vala_generic_type_get_type_parameter (G_TYPE_CHECK_INSTANCE_CAST (_tmp2159_, VALA_TYPE_GENERIC_TYPE, ValaGenericType)); - _tmp2161_ = _tmp2160_; - _tmp2162_ = _vala_code_node_ref0 (_tmp2161_); - type_parameter = _tmp2162_; - _tmp2163_ = type_parameter; - _tmp2164_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2163_); - _tmp2165_ = _tmp2164_; - _tmp2166_ = vala_symbol_get_parent_symbol (_tmp2165_); - _tmp2167_ = _tmp2166_; - _tmp2168_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2167_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp2167_) : NULL); - st = _tmp2168_; - _tmp2170_ = type_parameter; - _tmp2171_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2170_); - _tmp2172_ = _tmp2171_; - _tmp2173_ = ((ValaCCodeBaseModule*) self)->garray_type; - if (_tmp2172_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp2173_, VALA_TYPE_SYMBOL, ValaSymbol)) { - _tmp2169_ = TRUE; - } else { - gboolean _tmp2174_ = FALSE; - ValaStruct* _tmp2175_; - _tmp2175_ = st; - if (_tmp2175_ != NULL) { - ValaStruct* _tmp2176_; - gchar* _tmp2177_; - gchar* _tmp2178_; - _tmp2176_ = st; - _tmp2177_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2176_); - _tmp2178_ = _tmp2177_; - _tmp2174_ = g_strcmp0 (_tmp2178_, "va_list") == 0; - _g_free0 (_tmp2178_); + ValaTypeParameter* _tmp2231_; + ValaSymbol* _tmp2232_; + ValaSymbol* _tmp2233_; + ValaSymbol* _tmp2234_; + ValaSymbol* _tmp2235_; + ValaStruct* _tmp2236_; + gboolean _tmp2237_ = FALSE; + ValaTypeParameter* _tmp2238_; + ValaSymbol* _tmp2239_; + ValaSymbol* _tmp2240_; + ValaTypeSymbol* _tmp2241_; + gboolean _tmp2250_ = FALSE; + gboolean _tmp2251_ = FALSE; + ValaStruct* _tmp2252_; + _tmp2226_ = vala_expression_get_formal_value_type ((ValaExpression*) expr); + _tmp2227_ = _tmp2226_; + _tmp2228_ = vala_generic_type_get_type_parameter (G_TYPE_CHECK_INSTANCE_CAST (_tmp2227_, VALA_TYPE_GENERIC_TYPE, ValaGenericType)); + _tmp2229_ = _tmp2228_; + _tmp2230_ = _vala_code_node_ref0 (_tmp2229_); + type_parameter = _tmp2230_; + _tmp2231_ = type_parameter; + _tmp2232_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2231_); + _tmp2233_ = _tmp2232_; + _tmp2234_ = vala_symbol_get_parent_symbol (_tmp2233_); + _tmp2235_ = _tmp2234_; + _tmp2236_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2235_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp2235_) : NULL); + st = _tmp2236_; + _tmp2238_ = type_parameter; + _tmp2239_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2238_); + _tmp2240_ = _tmp2239_; + _tmp2241_ = ((ValaCCodeBaseModule*) self)->garray_type; + if (_tmp2240_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp2241_, VALA_TYPE_SYMBOL, ValaSymbol)) { + _tmp2237_ = TRUE; + } else { + gboolean _tmp2242_ = FALSE; + ValaStruct* _tmp2243_; + _tmp2243_ = st; + if (_tmp2243_ != NULL) { + ValaStruct* _tmp2244_; + gchar* _tmp2245_; + gchar* _tmp2246_; + _tmp2244_ = st; + _tmp2245_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2244_); + _tmp2246_ = _tmp2245_; + _tmp2242_ = g_strcmp0 (_tmp2246_, "va_list") == 0; + _g_free0 (_tmp2246_); } else { - _tmp2174_ = FALSE; + _tmp2242_ = FALSE; } - _tmp2169_ = _tmp2174_; + _tmp2237_ = _tmp2242_; } - if (_tmp2169_) { - ValaDataType* _tmp2179_; - ValaDataType* _tmp2180_; - ValaDataType* _tmp2181_; - _tmp2179_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp2180_ = _tmp2179_; - _tmp2181_ = _vala_code_node_ref0 (_tmp2180_); + if (_tmp2237_) { + ValaDataType* _tmp2247_; + ValaDataType* _tmp2248_; + ValaDataType* _tmp2249_; + _tmp2247_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2248_ = _tmp2247_; + _tmp2249_ = _vala_code_node_ref0 (_tmp2248_); _vala_code_node_unref0 (result_type); - result_type = _tmp2181_; + result_type = _tmp2249_; } - _tmp2184_ = st; - if (_tmp2184_ != NULL) { - ValaStruct* _tmp2185_; - gchar* _tmp2186_; - gchar* _tmp2187_; - _tmp2185_ = st; - _tmp2186_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2185_); - _tmp2187_ = _tmp2186_; - _tmp2183_ = g_strcmp0 (_tmp2187_, "va_list") == 0; - _g_free0 (_tmp2187_); - } else { - _tmp2183_ = FALSE; - } - if (_tmp2183_) { - ValaMemberAccess* _tmp2188_; - const gchar* _tmp2189_; - const gchar* _tmp2190_; - _tmp2188_ = ma; - _tmp2189_ = vala_member_access_get_member_name (_tmp2188_); - _tmp2190_ = _tmp2189_; - _tmp2182_ = g_strcmp0 (_tmp2190_, "arg") == 0; - } else { - _tmp2182_ = FALSE; - } - if (_tmp2182_) { - gboolean _tmp2191_ = FALSE; - ValaDataType* _tmp2192_; - _tmp2192_ = result_type; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2192_, VALA_TYPE_DELEGATE_TYPE)) { - ValaDataType* _tmp2193_; - ValaDelegate* _tmp2194_; - ValaDelegate* _tmp2195_; - gboolean _tmp2196_; - gboolean _tmp2197_; - _tmp2193_ = result_type; - _tmp2194_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp2193_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - _tmp2195_ = _tmp2194_; - _tmp2196_ = vala_delegate_get_has_target (_tmp2195_); - _tmp2197_ = _tmp2196_; - _tmp2191_ = _tmp2197_; + _tmp2252_ = st; + if (_tmp2252_ != NULL) { + ValaStruct* _tmp2253_; + gchar* _tmp2254_; + gchar* _tmp2255_; + _tmp2253_ = st; + _tmp2254_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2253_); + _tmp2255_ = _tmp2254_; + _tmp2251_ = g_strcmp0 (_tmp2255_, "va_list") == 0; + _g_free0 (_tmp2255_); + } else { + _tmp2251_ = FALSE; + } + if (_tmp2251_) { + ValaMemberAccess* _tmp2256_; + const gchar* _tmp2257_; + const gchar* _tmp2258_; + _tmp2256_ = ma; + _tmp2257_ = vala_member_access_get_member_name (_tmp2256_); + _tmp2258_ = _tmp2257_; + _tmp2250_ = g_strcmp0 (_tmp2258_, "arg") == 0; + } else { + _tmp2250_ = FALSE; + } + if (_tmp2250_) { + gboolean _tmp2259_ = FALSE; + ValaDataType* _tmp2260_; + _tmp2260_ = result_type; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2260_, VALA_TYPE_DELEGATE_TYPE)) { + ValaDataType* _tmp2261_; + ValaDelegate* _tmp2262_; + ValaDelegate* _tmp2263_; + gboolean _tmp2264_; + gboolean _tmp2265_; + _tmp2261_ = result_type; + _tmp2262_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp2261_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + _tmp2263_ = _tmp2262_; + _tmp2264_ = vala_delegate_get_has_target (_tmp2263_); + _tmp2265_ = _tmp2264_; + _tmp2259_ = _tmp2265_; } else { - _tmp2191_ = FALSE; + _tmp2259_ = FALSE; } - if (_tmp2191_) { + if (_tmp2259_) { ValaGLibValue* arg_value = NULL; - ValaTargetValue* _tmp2198_; - ValaTargetValue* _tmp2199_; - ValaGLibValue* _tmp2200_; - ValaCCodeExpression* _tmp2201_; - ValaGLibValue* _tmp2204_; - ValaCCodeExpression* _tmp2205_; + ValaTargetValue* _tmp2266_; + ValaTargetValue* _tmp2267_; + ValaGLibValue* _tmp2268_; + ValaCCodeExpression* _tmp2269_; + ValaGLibValue* _tmp2272_; + ValaCCodeExpression* _tmp2273_; vala_set_cvalue ((ValaExpression*) expr, NULL); - _tmp2198_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp2199_ = _tmp2198_; - arg_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp2199_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); - _tmp2200_ = arg_value; - _tmp2201_ = _tmp2200_->delegate_target_cvalue; - if (_tmp2201_ == NULL) { - ValaGLibValue* _tmp2202_; - ValaCCodeConstant* _tmp2203_; - _tmp2202_ = arg_value; - _tmp2203_ = vala_ccode_constant_new ("NULL"); - _vala_ccode_node_unref0 (_tmp2202_->delegate_target_cvalue); - _tmp2202_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp2203_; - } - _tmp2204_ = arg_value; - _tmp2205_ = _tmp2204_->delegate_target_destroy_notify_cvalue; - if (_tmp2205_ == NULL) { - ValaGLibValue* _tmp2206_; - ValaCCodeConstant* _tmp2207_; - _tmp2206_ = arg_value; - _tmp2207_ = vala_ccode_constant_new ("NULL"); - _vala_ccode_node_unref0 (_tmp2206_->delegate_target_destroy_notify_cvalue); - _tmp2206_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp2207_; + _tmp2266_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp2267_ = _tmp2266_; + arg_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp2267_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); + _tmp2268_ = arg_value; + _tmp2269_ = _tmp2268_->delegate_target_cvalue; + if (_tmp2269_ == NULL) { + ValaGLibValue* _tmp2270_; + ValaCCodeConstant* _tmp2271_; + _tmp2270_ = arg_value; + _tmp2271_ = vala_ccode_constant_new ("NULL"); + _vala_ccode_node_unref0 (_tmp2270_->delegate_target_cvalue); + _tmp2270_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp2271_; + } + _tmp2272_ = arg_value; + _tmp2273_ = _tmp2272_->delegate_target_destroy_notify_cvalue; + if (_tmp2273_ == NULL) { + ValaGLibValue* _tmp2274_; + ValaCCodeConstant* _tmp2275_; + _tmp2274_ = arg_value; + _tmp2275_ = vala_ccode_constant_new ("NULL"); + _vala_ccode_node_unref0 (_tmp2274_->delegate_target_destroy_notify_cvalue); + _tmp2274_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp2275_; } } } _vala_code_node_unref0 (st); _vala_code_node_unref0 (type_parameter); } - _tmp2209_ = m; - if (_tmp2209_ != NULL) { - ValaMethod* _tmp2210_; - _tmp2210_ = m; - _tmp2208_ = vala_method_get_format_arg_index (_tmp2210_) >= 0; - } else { - _tmp2208_ = FALSE; - } - if (_tmp2208_) { - ValaCCodeExpression* _tmp2211_; - _tmp2211_ = ccall_expr; - vala_set_cvalue ((ValaExpression*) expr, _tmp2211_); - } else { - gboolean _tmp2212_ = FALSE; - ValaMethod* _tmp2213_; - _tmp2213_ = m; - if (_tmp2213_ != NULL) { - ValaMethod* _tmp2214_; - _tmp2214_ = m; - _tmp2212_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp2214_, "CCode", "use_inplace", FALSE); - } else { - _tmp2212_ = FALSE; - } - if (_tmp2212_) { - ValaCCodeExpression* _tmp2215_; - _tmp2215_ = ccall_expr; - vala_set_cvalue ((ValaExpression*) expr, _tmp2215_); + _tmp2277_ = m; + if (_tmp2277_ != NULL) { + ValaMethod* _tmp2278_; + _tmp2278_ = m; + _tmp2276_ = vala_method_get_format_arg_index (_tmp2278_) >= 0; + } else { + _tmp2276_ = FALSE; + } + if (_tmp2276_) { + ValaCCodeExpression* _tmp2279_; + _tmp2279_ = ccall_expr; + vala_set_cvalue ((ValaExpression*) expr, _tmp2279_); + } else { + gboolean _tmp2280_ = FALSE; + ValaMethod* _tmp2281_; + _tmp2281_ = m; + if (_tmp2281_ != NULL) { + ValaMethod* _tmp2282_; + _tmp2282_ = m; + _tmp2280_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp2282_, "CCode", "use_inplace", FALSE); + } else { + _tmp2280_ = FALSE; + } + if (_tmp2280_) { + ValaCCodeExpression* _tmp2283_; + _tmp2283_ = ccall_expr; + vala_set_cvalue ((ValaExpression*) expr, _tmp2283_); } else { - gboolean _tmp2216_ = FALSE; - gboolean _tmp2217_ = FALSE; + gboolean _tmp2284_ = FALSE; + gboolean _tmp2285_ = FALSE; if (!return_result_via_out_param) { - _tmp2217_ = !vala_ccode_method_call_module_has_ref_out_argument (self, expr); + _tmp2285_ = !vala_ccode_method_call_module_has_ref_out_argument (self, expr); } else { - _tmp2217_ = FALSE; + _tmp2285_ = FALSE; } - if (_tmp2217_) { - gboolean _tmp2218_ = FALSE; - ValaDataType* _tmp2219_; - _tmp2219_ = result_type; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2219_, VALA_TYPE_VALUE_TYPE)) { - ValaDataType* _tmp2220_; - _tmp2220_ = result_type; - _tmp2218_ = !vala_data_type_is_disposable (_tmp2220_); + if (_tmp2285_) { + gboolean _tmp2286_ = FALSE; + ValaDataType* _tmp2287_; + _tmp2287_ = result_type; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2287_, VALA_TYPE_VALUE_TYPE)) { + ValaDataType* _tmp2288_; + _tmp2288_ = result_type; + _tmp2286_ = !vala_data_type_is_disposable (_tmp2288_); } else { - _tmp2218_ = FALSE; + _tmp2286_ = FALSE; } - _tmp2216_ = _tmp2218_; + _tmp2284_ = _tmp2286_; } else { - _tmp2216_ = FALSE; + _tmp2284_ = FALSE; } - if (_tmp2216_) { - ValaCCodeExpression* _tmp2221_; - _tmp2221_ = ccall_expr; - vala_set_cvalue ((ValaExpression*) expr, _tmp2221_); + if (_tmp2284_) { + ValaCCodeExpression* _tmp2289_; + _tmp2289_ = ccall_expr; + vala_set_cvalue ((ValaExpression*) expr, _tmp2289_); } else { if (!return_result_via_out_param) { ValaLocalVariable* temp_var = NULL; - ValaDataType* _tmp2222_; - ValaDataType* _tmp2223_; - gboolean _tmp2224_; - gboolean _tmp2225_; - ValaLocalVariable* _tmp2226_; + ValaDataType* _tmp2290_; + ValaDataType* _tmp2291_; + gboolean _tmp2292_; + gboolean _tmp2293_; + ValaLocalVariable* _tmp2294_; ValaCCodeExpression* temp_ref = NULL; - ValaLocalVariable* _tmp2227_; - const gchar* _tmp2228_; - const gchar* _tmp2229_; - ValaCCodeExpression* _tmp2230_; - ValaLocalVariable* _tmp2231_; - ValaCCodeFunction* _tmp2232_; - ValaCCodeFunction* _tmp2233_; - ValaCCodeExpression* _tmp2234_; - ValaCCodeExpression* _tmp2235_; - ValaCCodeExpression* _tmp2236_; - ValaTargetValue* _tmp2237_; - ValaTargetValue* _tmp2238_; - _tmp2222_ = result_type; - _tmp2223_ = result_type; - _tmp2224_ = vala_data_type_get_value_owned (_tmp2223_); - _tmp2225_ = _tmp2224_; - _tmp2226_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp2222_, _tmp2225_, NULL, FALSE); - temp_var = _tmp2226_; - _tmp2227_ = temp_var; - _tmp2228_ = vala_symbol_get_name ((ValaSymbol*) _tmp2227_); - _tmp2229_ = _tmp2228_; - _tmp2230_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp2229_); - temp_ref = _tmp2230_; - _tmp2231_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp2231_, FALSE); - _tmp2232_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2233_ = _tmp2232_; - _tmp2234_ = temp_ref; - _tmp2235_ = ccall_expr; - vala_ccode_function_add_assignment (_tmp2233_, _tmp2234_, _tmp2235_); - _tmp2236_ = temp_ref; - vala_set_cvalue ((ValaExpression*) expr, _tmp2236_); - _tmp2237_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp2238_ = _tmp2237_; - G_TYPE_CHECK_INSTANCE_CAST (_tmp2238_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE; + ValaLocalVariable* _tmp2295_; + const gchar* _tmp2296_; + const gchar* _tmp2297_; + ValaCCodeExpression* _tmp2298_; + ValaLocalVariable* _tmp2299_; + ValaCCodeFunction* _tmp2300_; + ValaCCodeFunction* _tmp2301_; + ValaCCodeExpression* _tmp2302_; + ValaCCodeExpression* _tmp2303_; + ValaCCodeExpression* _tmp2304_; + ValaTargetValue* _tmp2305_; + ValaTargetValue* _tmp2306_; + _tmp2290_ = result_type; + _tmp2291_ = result_type; + _tmp2292_ = vala_data_type_get_value_owned (_tmp2291_); + _tmp2293_ = _tmp2292_; + _tmp2294_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp2290_, _tmp2293_, NULL, FALSE); + temp_var = _tmp2294_; + _tmp2295_ = temp_var; + _tmp2296_ = vala_symbol_get_name ((ValaSymbol*) _tmp2295_); + _tmp2297_ = _tmp2296_; + _tmp2298_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp2297_); + temp_ref = _tmp2298_; + _tmp2299_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp2299_, FALSE); + _tmp2300_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2301_ = _tmp2300_; + _tmp2302_ = temp_ref; + _tmp2303_ = ccall_expr; + vala_ccode_function_add_assignment (_tmp2301_, _tmp2302_, _tmp2303_); + _tmp2304_ = temp_ref; + vala_set_cvalue ((ValaExpression*) expr, _tmp2304_); + _tmp2305_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp2306_ = _tmp2305_; + G_TYPE_CHECK_INSTANCE_CAST (_tmp2306_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE; _vala_ccode_node_unref0 (temp_ref); _vala_code_node_unref0 (temp_var); } else { - ValaCCodeExpression* _tmp2239_; - ValaTargetValue* _tmp2240_; - ValaTargetValue* _tmp2241_; - _tmp2239_ = ccall_expr; - vala_set_cvalue ((ValaExpression*) expr, _tmp2239_); - _tmp2240_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp2241_ = _tmp2240_; - G_TYPE_CHECK_INSTANCE_CAST (_tmp2241_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE; + ValaCCodeExpression* _tmp2307_; + ValaTargetValue* _tmp2308_; + ValaTargetValue* _tmp2309_; + _tmp2307_ = ccall_expr; + vala_set_cvalue ((ValaExpression*) expr, _tmp2307_); + _tmp2308_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp2309_ = _tmp2308_; + G_TYPE_CHECK_INSTANCE_CAST (_tmp2309_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE; } } } } _vala_code_node_unref0 (result_type); } - _tmp2242_ = params; - _tmp2243_ = vala_iterable_iterator ((ValaIterable*) _tmp2242_); + _tmp2310_ = params; + _tmp2311_ = vala_iterable_iterator ((ValaIterable*) _tmp2310_); _vala_iterator_unref0 (params_it); - params_it = _tmp2243_; + params_it = _tmp2311_; { ValaList* _arg_list = NULL; - ValaList* _tmp2244_; + ValaList* _tmp2312_; gint _arg_size = 0; - ValaList* _tmp2245_; - gint _tmp2246_; - gint _tmp2247_; + ValaList* _tmp2313_; + gint _tmp2314_; + gint _tmp2315_; gint _arg_index = 0; - _tmp2244_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) expr); - _arg_list = _tmp2244_; - _tmp2245_ = _arg_list; - _tmp2246_ = vala_collection_get_size ((ValaCollection*) _tmp2245_); - _tmp2247_ = _tmp2246_; - _arg_size = _tmp2247_; + _tmp2312_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) expr); + _arg_list = _tmp2312_; + _tmp2313_ = _arg_list; + _tmp2314_ = vala_collection_get_size ((ValaCollection*) _tmp2313_); + _tmp2315_ = _tmp2314_; + _arg_size = _tmp2315_; _arg_index = -1; while (TRUE) { - gint _tmp2248_; - gint _tmp2249_; + gint _tmp2316_; + gint _tmp2317_; ValaExpression* arg = NULL; - ValaList* _tmp2250_; - gpointer _tmp2251_; + ValaList* _tmp2318_; + gpointer _tmp2319_; ValaParameter* param = NULL; - ValaIterator* _tmp2252_; + ValaIterator* _tmp2320_; ValaUnaryExpression* unary = NULL; - ValaExpression* _tmp2255_; - ValaUnaryExpression* _tmp2256_; - gboolean _tmp2257_ = FALSE; - ValaUnaryExpression* _tmp2258_; - gboolean _tmp2316_ = FALSE; - ValaUnaryExpression* _tmp2317_; - ValaUnaryExpression* _tmp2321_; - ValaExpression* _tmp2322_; ValaExpression* _tmp2323_; - ValaDataType* _tmp2324_; - ValaDataType* _tmp2325_; - gboolean _tmp2335_ = FALSE; - ValaMemberAccess* _tmp2336_; - ValaSymbol* _tmp2337_; - ValaSymbol* _tmp2338_; - ValaUnaryExpression* _tmp2354_; - ValaExpression* _tmp2355_; - ValaExpression* _tmp2356_; - ValaTargetValue* _tmp2357_; - ValaTargetValue* _tmp2358_; - ValaUnaryExpression* _tmp2359_; - ValaTargetValue* _tmp2360_; - ValaTargetValue* _tmp2361_; - ValaUnaryExpression* _tmp2362_; - ValaExpression* _tmp2363_; - ValaExpression* _tmp2364_; - ValaDataType* _tmp2365_; - ValaDataType* _tmp2366_; - ValaExpression* _tmp2367_; - ValaTargetValue* _tmp2368_; - ValaTargetValue* _tmp2369_; - ValaSourceReference* _tmp2370_; - ValaSourceReference* _tmp2371_; - gboolean _tmp2372_ = FALSE; - ValaParameter* _tmp2373_; + ValaUnaryExpression* _tmp2324_; + gboolean _tmp2325_ = FALSE; + ValaUnaryExpression* _tmp2326_; + gboolean _tmp2384_ = FALSE; + ValaUnaryExpression* _tmp2385_; + ValaUnaryExpression* _tmp2389_; + ValaExpression* _tmp2390_; + ValaExpression* _tmp2391_; + ValaDataType* _tmp2392_; + ValaDataType* _tmp2393_; + gboolean _tmp2403_ = FALSE; + ValaMemberAccess* _tmp2404_; + ValaSymbol* _tmp2405_; + ValaSymbol* _tmp2406_; + ValaUnaryExpression* _tmp2422_; + ValaExpression* _tmp2423_; + ValaExpression* _tmp2424_; + ValaTargetValue* _tmp2425_; + ValaTargetValue* _tmp2426_; + ValaUnaryExpression* _tmp2427_; + ValaTargetValue* _tmp2428_; + ValaTargetValue* _tmp2429_; + ValaUnaryExpression* _tmp2430_; + ValaExpression* _tmp2431_; + ValaExpression* _tmp2432_; + ValaDataType* _tmp2433_; + ValaDataType* _tmp2434_; + ValaExpression* _tmp2435_; + ValaTargetValue* _tmp2436_; + ValaTargetValue* _tmp2437_; + ValaSourceReference* _tmp2438_; + ValaSourceReference* _tmp2439_; + gboolean _tmp2440_ = FALSE; + ValaParameter* _tmp2441_; _arg_index = _arg_index + 1; - _tmp2248_ = _arg_index; - _tmp2249_ = _arg_size; - if (!(_tmp2248_ < _tmp2249_)) { + _tmp2316_ = _arg_index; + _tmp2317_ = _arg_size; + if (!(_tmp2316_ < _tmp2317_)) { break; } - _tmp2250_ = _arg_list; - _tmp2251_ = vala_list_get (_tmp2250_, _arg_index); - arg = (ValaExpression*) _tmp2251_; + _tmp2318_ = _arg_list; + _tmp2319_ = vala_list_get (_tmp2318_, _arg_index); + arg = (ValaExpression*) _tmp2319_; param = NULL; - _tmp2252_ = params_it; - if (vala_iterator_next (_tmp2252_)) { - ValaIterator* _tmp2253_; - gpointer _tmp2254_; - _tmp2253_ = params_it; - _tmp2254_ = vala_iterator_get (_tmp2253_); + _tmp2320_ = params_it; + if (vala_iterator_next (_tmp2320_)) { + ValaIterator* _tmp2321_; + gpointer _tmp2322_; + _tmp2321_ = params_it; + _tmp2322_ = vala_iterator_get (_tmp2321_); _vala_code_node_unref0 (param); - param = (ValaParameter*) _tmp2254_; + param = (ValaParameter*) _tmp2322_; } - _tmp2255_ = arg; - _tmp2256_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2255_, VALA_TYPE_UNARY_EXPRESSION) ? ((ValaUnaryExpression*) _tmp2255_) : NULL); - unary = _tmp2256_; - _tmp2258_ = unary; - if (_tmp2258_ != NULL) { - ValaUnaryExpression* _tmp2259_; - ValaUnaryOperator _tmp2260_; - ValaUnaryOperator _tmp2261_; - _tmp2259_ = unary; - _tmp2260_ = vala_unary_expression_get_operator (_tmp2259_); - _tmp2261_ = _tmp2260_; - _tmp2257_ = _tmp2261_ == VALA_UNARY_OPERATOR_REF; - } else { - _tmp2257_ = FALSE; - } - if (_tmp2257_) { - gboolean _tmp2262_ = FALSE; - gboolean _tmp2263_ = FALSE; - gboolean _tmp2264_ = FALSE; - gboolean _tmp2265_ = FALSE; - ValaParameter* _tmp2266_; - _tmp2266_ = param; - if (_tmp2266_ != NULL) { - ValaParameter* _tmp2267_; - _tmp2267_ = param; - _tmp2265_ = vala_get_ccode_array_length ((ValaCodeNode*) _tmp2267_); + _tmp2323_ = arg; + _tmp2324_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2323_, VALA_TYPE_UNARY_EXPRESSION) ? ((ValaUnaryExpression*) _tmp2323_) : NULL); + unary = _tmp2324_; + _tmp2326_ = unary; + if (_tmp2326_ != NULL) { + ValaUnaryExpression* _tmp2327_; + ValaUnaryOperator _tmp2328_; + ValaUnaryOperator _tmp2329_; + _tmp2327_ = unary; + _tmp2328_ = vala_unary_expression_get_operator (_tmp2327_); + _tmp2329_ = _tmp2328_; + _tmp2325_ = _tmp2329_ == VALA_UNARY_OPERATOR_REF; + } else { + _tmp2325_ = FALSE; + } + if (_tmp2325_) { + gboolean _tmp2330_ = FALSE; + gboolean _tmp2331_ = FALSE; + gboolean _tmp2332_ = FALSE; + gboolean _tmp2333_ = FALSE; + ValaParameter* _tmp2334_; + _tmp2334_ = param; + if (_tmp2334_ != NULL) { + ValaParameter* _tmp2335_; + _tmp2335_ = param; + _tmp2333_ = vala_get_ccode_array_length ((ValaCodeNode*) _tmp2335_); } else { - _tmp2265_ = FALSE; + _tmp2333_ = FALSE; } - if (_tmp2265_) { - ValaParameter* _tmp2268_; - ValaDataType* _tmp2269_; - ValaDataType* _tmp2270_; - _tmp2268_ = param; - _tmp2269_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2268_); - _tmp2270_ = _tmp2269_; - _tmp2264_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2270_, VALA_TYPE_ARRAY_TYPE); + if (_tmp2333_) { + ValaParameter* _tmp2336_; + ValaDataType* _tmp2337_; + ValaDataType* _tmp2338_; + _tmp2336_ = param; + _tmp2337_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2336_); + _tmp2338_ = _tmp2337_; + _tmp2332_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2338_, VALA_TYPE_ARRAY_TYPE); } else { - _tmp2264_ = FALSE; + _tmp2332_ = FALSE; } - if (_tmp2264_) { - ValaParameter* _tmp2271_; - ValaDataType* _tmp2272_; - ValaDataType* _tmp2273_; - gboolean _tmp2274_; - gboolean _tmp2275_; - _tmp2271_ = param; - _tmp2272_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2271_); - _tmp2273_ = _tmp2272_; - _tmp2274_ = vala_array_type_get_fixed_length (G_TYPE_CHECK_INSTANCE_CAST (_tmp2273_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp2275_ = _tmp2274_; - _tmp2263_ = !_tmp2275_; + if (_tmp2332_) { + ValaParameter* _tmp2339_; + ValaDataType* _tmp2340_; + ValaDataType* _tmp2341_; + gboolean _tmp2342_; + gboolean _tmp2343_; + _tmp2339_ = param; + _tmp2340_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2339_); + _tmp2341_ = _tmp2340_; + _tmp2342_ = vala_array_type_get_fixed_length (G_TYPE_CHECK_INSTANCE_CAST (_tmp2341_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp2343_ = _tmp2342_; + _tmp2331_ = !_tmp2343_; } else { - _tmp2263_ = FALSE; + _tmp2331_ = FALSE; } - if (_tmp2263_) { - ValaParameter* _tmp2276_; - ValaDataType* _tmp2277_; - ValaDataType* _tmp2278_; - gint _tmp2279_; - gint _tmp2280_; - _tmp2276_ = param; - _tmp2277_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2276_); - _tmp2278_ = _tmp2277_; - _tmp2279_ = vala_array_type_get_rank (G_TYPE_CHECK_INSTANCE_CAST (_tmp2278_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp2280_ = _tmp2279_; - _tmp2262_ = _tmp2280_ == 1; + if (_tmp2331_) { + ValaParameter* _tmp2344_; + ValaDataType* _tmp2345_; + ValaDataType* _tmp2346_; + gint _tmp2347_; + gint _tmp2348_; + _tmp2344_ = param; + _tmp2345_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2344_); + _tmp2346_ = _tmp2345_; + _tmp2347_ = vala_array_type_get_rank (G_TYPE_CHECK_INSTANCE_CAST (_tmp2346_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp2348_ = _tmp2347_; + _tmp2330_ = _tmp2348_ == 1; } else { - _tmp2262_ = FALSE; + _tmp2330_ = FALSE; } - if (_tmp2262_) { + if (_tmp2330_) { ValaVariable* array_var = NULL; - ValaUnaryExpression* _tmp2281_; - ValaExpression* _tmp2282_; - ValaExpression* _tmp2283_; - ValaSymbol* _tmp2284_; - ValaSymbol* _tmp2285_; - gboolean _tmp2286_ = FALSE; - gboolean _tmp2287_ = FALSE; - gboolean _tmp2288_ = FALSE; - gboolean _tmp2289_ = FALSE; - ValaVariable* _tmp2290_; - _tmp2281_ = unary; - _tmp2282_ = vala_unary_expression_get_inner (_tmp2281_); - _tmp2283_ = _tmp2282_; - _tmp2284_ = vala_expression_get_symbol_reference (_tmp2283_); - _tmp2285_ = _tmp2284_; - array_var = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2285_, VALA_TYPE_VARIABLE) ? ((ValaVariable*) _tmp2285_) : NULL; - _tmp2290_ = array_var; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2290_, VALA_TYPE_LOCAL_VARIABLE)) { - _tmp2289_ = TRUE; + ValaUnaryExpression* _tmp2349_; + ValaExpression* _tmp2350_; + ValaExpression* _tmp2351_; + ValaSymbol* _tmp2352_; + ValaSymbol* _tmp2353_; + gboolean _tmp2354_ = FALSE; + gboolean _tmp2355_ = FALSE; + gboolean _tmp2356_ = FALSE; + gboolean _tmp2357_ = FALSE; + ValaVariable* _tmp2358_; + _tmp2349_ = unary; + _tmp2350_ = vala_unary_expression_get_inner (_tmp2349_); + _tmp2351_ = _tmp2350_; + _tmp2352_ = vala_expression_get_symbol_reference (_tmp2351_); + _tmp2353_ = _tmp2352_; + array_var = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2353_, VALA_TYPE_VARIABLE) ? ((ValaVariable*) _tmp2353_) : NULL; + _tmp2358_ = array_var; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2358_, VALA_TYPE_LOCAL_VARIABLE)) { + _tmp2357_ = TRUE; } else { - ValaVariable* _tmp2291_; - _tmp2291_ = array_var; - _tmp2289_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2291_, VALA_TYPE_FIELD); - } - if (_tmp2289_) { - ValaVariable* _tmp2292_; - _tmp2292_ = array_var; - _tmp2288_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp2292_); + ValaVariable* _tmp2359_; + _tmp2359_ = array_var; + _tmp2357_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2359_, VALA_TYPE_FIELD); + } + if (_tmp2357_) { + ValaVariable* _tmp2360_; + _tmp2360_ = array_var; + _tmp2356_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp2360_); } else { - _tmp2288_ = FALSE; + _tmp2356_ = FALSE; } - if (_tmp2288_) { - ValaVariable* _tmp2293_; - ValaDataType* _tmp2294_; - ValaDataType* _tmp2295_; - _tmp2293_ = array_var; - _tmp2294_ = vala_variable_get_variable_type (_tmp2293_); - _tmp2295_ = _tmp2294_; - _tmp2287_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2295_, VALA_TYPE_ARRAY_TYPE); + if (_tmp2356_) { + ValaVariable* _tmp2361_; + ValaDataType* _tmp2362_; + ValaDataType* _tmp2363_; + _tmp2361_ = array_var; + _tmp2362_ = vala_variable_get_variable_type (_tmp2361_); + _tmp2363_ = _tmp2362_; + _tmp2355_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2363_, VALA_TYPE_ARRAY_TYPE); } else { - _tmp2287_ = FALSE; + _tmp2355_ = FALSE; } - if (_tmp2287_) { - ValaVariable* _tmp2296_; - ValaDataType* _tmp2297_; - ValaDataType* _tmp2298_; - gboolean _tmp2299_; - gboolean _tmp2300_; - _tmp2296_ = array_var; - _tmp2297_ = vala_variable_get_variable_type (_tmp2296_); - _tmp2298_ = _tmp2297_; - _tmp2299_ = vala_array_type_get_fixed_length (G_TYPE_CHECK_INSTANCE_CAST (_tmp2298_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp2300_ = _tmp2299_; - _tmp2286_ = !_tmp2300_; + if (_tmp2355_) { + ValaVariable* _tmp2364_; + ValaDataType* _tmp2365_; + ValaDataType* _tmp2366_; + gboolean _tmp2367_; + gboolean _tmp2368_; + _tmp2364_ = array_var; + _tmp2365_ = vala_variable_get_variable_type (_tmp2364_); + _tmp2366_ = _tmp2365_; + _tmp2367_ = vala_array_type_get_fixed_length (G_TYPE_CHECK_INSTANCE_CAST (_tmp2366_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp2368_ = _tmp2367_; + _tmp2354_ = !_tmp2368_; } else { - _tmp2286_ = FALSE; + _tmp2354_ = FALSE; } - if (_tmp2286_) { - ValaCCodeFunction* _tmp2301_; - ValaCCodeFunction* _tmp2302_; - ValaUnaryExpression* _tmp2303_; - ValaExpression* _tmp2304_; - ValaExpression* _tmp2305_; - ValaTargetValue* _tmp2306_; - ValaTargetValue* _tmp2307_; - ValaCCodeExpression* _tmp2308_; - ValaUnaryExpression* _tmp2309_; - ValaExpression* _tmp2310_; - ValaExpression* _tmp2311_; - ValaTargetValue* _tmp2312_; - ValaTargetValue* _tmp2313_; - ValaCCodeExpression* _tmp2314_; - ValaCCodeExpression* _tmp2315_; - _tmp2301_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2302_ = _tmp2301_; - _tmp2303_ = unary; - _tmp2304_ = vala_unary_expression_get_inner (_tmp2303_); - _tmp2305_ = _tmp2304_; - _tmp2306_ = vala_expression_get_target_value (_tmp2305_); - _tmp2307_ = _tmp2306_; - _tmp2308_ = vala_get_array_size_cvalue (_tmp2307_); - _tmp2309_ = unary; - _tmp2310_ = vala_unary_expression_get_inner (_tmp2309_); - _tmp2311_ = _tmp2310_; - _tmp2312_ = vala_expression_get_target_value (_tmp2311_); - _tmp2313_ = _tmp2312_; - _tmp2314_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, _tmp2313_, 1); - _tmp2315_ = _tmp2314_; - vala_ccode_function_add_assignment (_tmp2302_, _tmp2308_, _tmp2315_); - _vala_ccode_node_unref0 (_tmp2315_); + if (_tmp2354_) { + ValaCCodeFunction* _tmp2369_; + ValaCCodeFunction* _tmp2370_; + ValaUnaryExpression* _tmp2371_; + ValaExpression* _tmp2372_; + ValaExpression* _tmp2373_; + ValaTargetValue* _tmp2374_; + ValaTargetValue* _tmp2375_; + ValaCCodeExpression* _tmp2376_; + ValaUnaryExpression* _tmp2377_; + ValaExpression* _tmp2378_; + ValaExpression* _tmp2379_; + ValaTargetValue* _tmp2380_; + ValaTargetValue* _tmp2381_; + ValaCCodeExpression* _tmp2382_; + ValaCCodeExpression* _tmp2383_; + _tmp2369_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2370_ = _tmp2369_; + _tmp2371_ = unary; + _tmp2372_ = vala_unary_expression_get_inner (_tmp2371_); + _tmp2373_ = _tmp2372_; + _tmp2374_ = vala_expression_get_target_value (_tmp2373_); + _tmp2375_ = _tmp2374_; + _tmp2376_ = vala_get_array_size_cvalue (_tmp2375_); + _tmp2377_ = unary; + _tmp2378_ = vala_unary_expression_get_inner (_tmp2377_); + _tmp2379_ = _tmp2378_; + _tmp2380_ = vala_expression_get_target_value (_tmp2379_); + _tmp2381_ = _tmp2380_; + _tmp2382_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, _tmp2381_, 1); + _tmp2383_ = _tmp2382_; + vala_ccode_function_add_assignment (_tmp2370_, _tmp2376_, _tmp2383_); + _vala_ccode_node_unref0 (_tmp2383_); } } } - _tmp2317_ = unary; - if (_tmp2317_ == NULL) { - _tmp2316_ = TRUE; - } else { - ValaUnaryExpression* _tmp2318_; - ValaUnaryOperator _tmp2319_; - ValaUnaryOperator _tmp2320_; - _tmp2318_ = unary; - _tmp2319_ = vala_unary_expression_get_operator (_tmp2318_); - _tmp2320_ = _tmp2319_; - _tmp2316_ = _tmp2320_ != VALA_UNARY_OPERATOR_OUT; + _tmp2385_ = unary; + if (_tmp2385_ == NULL) { + _tmp2384_ = TRUE; + } else { + ValaUnaryExpression* _tmp2386_; + ValaUnaryOperator _tmp2387_; + ValaUnaryOperator _tmp2388_; + _tmp2386_ = unary; + _tmp2387_ = vala_unary_expression_get_operator (_tmp2386_); + _tmp2388_ = _tmp2387_; + _tmp2384_ = _tmp2388_ != VALA_UNARY_OPERATOR_OUT; } - if (_tmp2316_) { + if (_tmp2384_) { _vala_code_node_unref0 (unary); _vala_code_node_unref0 (param); _vala_code_node_unref0 (arg); continue; } - _tmp2321_ = unary; - _tmp2322_ = vala_unary_expression_get_inner (_tmp2321_); - _tmp2323_ = _tmp2322_; - _tmp2324_ = vala_expression_get_value_type (_tmp2323_); - _tmp2325_ = _tmp2324_; - if (vala_ccode_base_module_requires_destroy (_tmp2325_)) { - ValaCCodeFunction* _tmp2326_; - ValaCCodeFunction* _tmp2327_; - ValaUnaryExpression* _tmp2328_; - ValaExpression* _tmp2329_; - ValaExpression* _tmp2330_; - ValaTargetValue* _tmp2331_; - ValaTargetValue* _tmp2332_; - ValaCCodeExpression* _tmp2333_; - ValaCCodeExpression* _tmp2334_; - _tmp2326_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2327_ = _tmp2326_; - _tmp2328_ = unary; - _tmp2329_ = vala_unary_expression_get_inner (_tmp2328_); - _tmp2330_ = _tmp2329_; - _tmp2331_ = vala_expression_get_target_value (_tmp2330_); - _tmp2332_ = _tmp2331_; - _tmp2333_ = vala_ccode_base_module_destroy_value ((ValaCCodeBaseModule*) self, _tmp2332_, FALSE); - _tmp2334_ = _tmp2333_; - vala_ccode_function_add_expression (_tmp2327_, _tmp2334_); - _vala_ccode_node_unref0 (_tmp2334_); - } - _tmp2336_ = ma; - _tmp2337_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp2336_); - _tmp2338_ = _tmp2337_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2338_, VALA_TYPE_DYNAMIC_METHOD)) { - ValaUnaryExpression* _tmp2339_; - ValaTargetValue* _tmp2340_; - ValaTargetValue* _tmp2341_; - ValaDataType* _tmp2342_; - ValaDataType* _tmp2343_; - _tmp2339_ = unary; - _tmp2340_ = vala_expression_get_target_value ((ValaExpression*) _tmp2339_); - _tmp2341_ = _tmp2340_; - _tmp2342_ = vala_target_value_get_value_type (_tmp2341_); - _tmp2343_ = _tmp2342_; - _tmp2335_ = _tmp2343_ == NULL; - } else { - _tmp2335_ = FALSE; - } - if (_tmp2335_) { - ValaUnaryExpression* _tmp2344_; - ValaTargetValue* _tmp2345_; - ValaTargetValue* _tmp2346_; - ValaUnaryExpression* _tmp2347_; - ValaExpression* _tmp2348_; - ValaExpression* _tmp2349_; - ValaDataType* _tmp2350_; - ValaDataType* _tmp2351_; - ValaDataType* _tmp2352_; - ValaDataType* _tmp2353_; - _tmp2344_ = unary; - _tmp2345_ = vala_expression_get_target_value ((ValaExpression*) _tmp2344_); - _tmp2346_ = _tmp2345_; - _tmp2347_ = unary; - _tmp2348_ = vala_unary_expression_get_inner (_tmp2347_); - _tmp2349_ = _tmp2348_; - _tmp2350_ = vala_expression_get_value_type (_tmp2349_); - _tmp2351_ = _tmp2350_; - _tmp2352_ = vala_data_type_copy (_tmp2351_); - _tmp2353_ = _tmp2352_; - vala_target_value_set_value_type (_tmp2346_, _tmp2353_); - _vala_code_node_unref0 (_tmp2353_); - } - _tmp2354_ = unary; - _tmp2355_ = vala_unary_expression_get_inner (_tmp2354_); - _tmp2356_ = _tmp2355_; - _tmp2357_ = vala_expression_get_target_value (_tmp2356_); - _tmp2358_ = _tmp2357_; - _tmp2359_ = unary; - _tmp2360_ = vala_expression_get_target_value ((ValaExpression*) _tmp2359_); - _tmp2361_ = _tmp2360_; - _tmp2362_ = unary; - _tmp2363_ = vala_unary_expression_get_inner (_tmp2362_); - _tmp2364_ = _tmp2363_; - _tmp2365_ = vala_expression_get_value_type (_tmp2364_); - _tmp2366_ = _tmp2365_; - _tmp2367_ = arg; - _tmp2368_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, _tmp2361_, _tmp2366_, (ValaCodeNode*) _tmp2367_); - _tmp2369_ = _tmp2368_; - _tmp2370_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); - _tmp2371_ = _tmp2370_; - vala_ccode_base_module_store_value ((ValaCCodeBaseModule*) self, _tmp2358_, _tmp2369_, _tmp2371_); - _vala_target_value_unref0 (_tmp2369_); - _tmp2373_ = param; - if (_tmp2373_ != NULL) { - ValaParameter* _tmp2374_; - _tmp2374_ = param; - _tmp2372_ = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp2374_); + _tmp2389_ = unary; + _tmp2390_ = vala_unary_expression_get_inner (_tmp2389_); + _tmp2391_ = _tmp2390_; + _tmp2392_ = vala_expression_get_value_type (_tmp2391_); + _tmp2393_ = _tmp2392_; + if (vala_ccode_base_module_requires_destroy (_tmp2393_)) { + ValaCCodeFunction* _tmp2394_; + ValaCCodeFunction* _tmp2395_; + ValaUnaryExpression* _tmp2396_; + ValaExpression* _tmp2397_; + ValaExpression* _tmp2398_; + ValaTargetValue* _tmp2399_; + ValaTargetValue* _tmp2400_; + ValaCCodeExpression* _tmp2401_; + ValaCCodeExpression* _tmp2402_; + _tmp2394_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2395_ = _tmp2394_; + _tmp2396_ = unary; + _tmp2397_ = vala_unary_expression_get_inner (_tmp2396_); + _tmp2398_ = _tmp2397_; + _tmp2399_ = vala_expression_get_target_value (_tmp2398_); + _tmp2400_ = _tmp2399_; + _tmp2401_ = vala_ccode_base_module_destroy_value ((ValaCCodeBaseModule*) self, _tmp2400_, FALSE); + _tmp2402_ = _tmp2401_; + vala_ccode_function_add_expression (_tmp2395_, _tmp2402_); + _vala_ccode_node_unref0 (_tmp2402_); + } + _tmp2404_ = ma; + _tmp2405_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp2404_); + _tmp2406_ = _tmp2405_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2406_, VALA_TYPE_DYNAMIC_METHOD)) { + ValaUnaryExpression* _tmp2407_; + ValaTargetValue* _tmp2408_; + ValaTargetValue* _tmp2409_; + ValaDataType* _tmp2410_; + ValaDataType* _tmp2411_; + _tmp2407_ = unary; + _tmp2408_ = vala_expression_get_target_value ((ValaExpression*) _tmp2407_); + _tmp2409_ = _tmp2408_; + _tmp2410_ = vala_target_value_get_value_type (_tmp2409_); + _tmp2411_ = _tmp2410_; + _tmp2403_ = _tmp2411_ == NULL; + } else { + _tmp2403_ = FALSE; + } + if (_tmp2403_) { + ValaUnaryExpression* _tmp2412_; + ValaTargetValue* _tmp2413_; + ValaTargetValue* _tmp2414_; + ValaUnaryExpression* _tmp2415_; + ValaExpression* _tmp2416_; + ValaExpression* _tmp2417_; + ValaDataType* _tmp2418_; + ValaDataType* _tmp2419_; + ValaDataType* _tmp2420_; + ValaDataType* _tmp2421_; + _tmp2412_ = unary; + _tmp2413_ = vala_expression_get_target_value ((ValaExpression*) _tmp2412_); + _tmp2414_ = _tmp2413_; + _tmp2415_ = unary; + _tmp2416_ = vala_unary_expression_get_inner (_tmp2415_); + _tmp2417_ = _tmp2416_; + _tmp2418_ = vala_expression_get_value_type (_tmp2417_); + _tmp2419_ = _tmp2418_; + _tmp2420_ = vala_data_type_copy (_tmp2419_); + _tmp2421_ = _tmp2420_; + vala_target_value_set_value_type (_tmp2414_, _tmp2421_); + _vala_code_node_unref0 (_tmp2421_); + } + _tmp2422_ = unary; + _tmp2423_ = vala_unary_expression_get_inner (_tmp2422_); + _tmp2424_ = _tmp2423_; + _tmp2425_ = vala_expression_get_target_value (_tmp2424_); + _tmp2426_ = _tmp2425_; + _tmp2427_ = unary; + _tmp2428_ = vala_expression_get_target_value ((ValaExpression*) _tmp2427_); + _tmp2429_ = _tmp2428_; + _tmp2430_ = unary; + _tmp2431_ = vala_unary_expression_get_inner (_tmp2430_); + _tmp2432_ = _tmp2431_; + _tmp2433_ = vala_expression_get_value_type (_tmp2432_); + _tmp2434_ = _tmp2433_; + _tmp2435_ = arg; + _tmp2436_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, _tmp2429_, _tmp2434_, (ValaCodeNode*) _tmp2435_); + _tmp2437_ = _tmp2436_; + _tmp2438_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); + _tmp2439_ = _tmp2438_; + vala_ccode_base_module_store_value ((ValaCCodeBaseModule*) self, _tmp2426_, _tmp2437_, _tmp2439_); + _vala_target_value_unref0 (_tmp2437_); + _tmp2441_ = param; + if (_tmp2441_ != NULL) { + ValaParameter* _tmp2442_; + _tmp2442_ = param; + _tmp2440_ = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp2442_); } else { - _tmp2372_ = FALSE; + _tmp2440_ = FALSE; } - if (_tmp2372_) { + if (_tmp2440_) { ValaCCodeFunctionCall* len_call = NULL; - ValaCCodeIdentifier* _tmp2375_; - ValaCCodeIdentifier* _tmp2376_; - ValaCCodeFunctionCall* _tmp2377_; - ValaCCodeFunctionCall* _tmp2378_; - ValaCCodeFunctionCall* _tmp2379_; - ValaUnaryExpression* _tmp2380_; - ValaExpression* _tmp2381_; - ValaExpression* _tmp2382_; - ValaTargetValue* _tmp2383_; - ValaTargetValue* _tmp2384_; - ValaCCodeExpression* _tmp2385_; - ValaCCodeFunction* _tmp2386_; - ValaCCodeFunction* _tmp2387_; - ValaUnaryExpression* _tmp2388_; - ValaExpression* _tmp2389_; - ValaExpression* _tmp2390_; - ValaTargetValue* _tmp2391_; - ValaTargetValue* _tmp2392_; - ValaCCodeExpression* _tmp2393_; - ValaCCodeExpression* _tmp2394_; - ValaCCodeFunctionCall* _tmp2395_; + ValaCCodeIdentifier* _tmp2443_; + ValaCCodeIdentifier* _tmp2444_; + ValaCCodeFunctionCall* _tmp2445_; + ValaCCodeFunctionCall* _tmp2446_; + ValaCCodeFunctionCall* _tmp2447_; + ValaUnaryExpression* _tmp2448_; + ValaExpression* _tmp2449_; + ValaExpression* _tmp2450_; + ValaTargetValue* _tmp2451_; + ValaTargetValue* _tmp2452_; + ValaCCodeExpression* _tmp2453_; + ValaCCodeFunction* _tmp2454_; + ValaCCodeFunction* _tmp2455_; + ValaUnaryExpression* _tmp2456_; + ValaExpression* _tmp2457_; + ValaExpression* _tmp2458_; + ValaTargetValue* _tmp2459_; + ValaTargetValue* _tmp2460_; + ValaCCodeExpression* _tmp2461_; + ValaCCodeExpression* _tmp2462_; + ValaCCodeFunctionCall* _tmp2463_; ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE; - _tmp2375_ = vala_ccode_identifier_new ("_vala_array_length"); - _tmp2376_ = _tmp2375_; - _tmp2377_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2376_); - _tmp2378_ = _tmp2377_; - _vala_ccode_node_unref0 (_tmp2376_); - len_call = _tmp2378_; - _tmp2379_ = len_call; - _tmp2380_ = unary; - _tmp2381_ = vala_unary_expression_get_inner (_tmp2380_); - _tmp2382_ = _tmp2381_; - _tmp2383_ = vala_expression_get_target_value (_tmp2382_); - _tmp2384_ = _tmp2383_; - _tmp2385_ = vala_get_cvalue_ (_tmp2384_); - vala_ccode_function_call_add_argument (_tmp2379_, _tmp2385_); - _tmp2386_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2387_ = _tmp2386_; - _tmp2388_ = unary; - _tmp2389_ = vala_unary_expression_get_inner (_tmp2388_); - _tmp2390_ = _tmp2389_; - _tmp2391_ = vala_expression_get_target_value (_tmp2390_); - _tmp2392_ = _tmp2391_; - _tmp2393_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, _tmp2392_, 1); - _tmp2394_ = _tmp2393_; - _tmp2395_ = len_call; - vala_ccode_function_add_assignment (_tmp2387_, _tmp2394_, (ValaCCodeExpression*) _tmp2395_); - _vala_ccode_node_unref0 (_tmp2394_); + _tmp2443_ = vala_ccode_identifier_new ("_vala_array_length"); + _tmp2444_ = _tmp2443_; + _tmp2445_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2444_); + _tmp2446_ = _tmp2445_; + _vala_ccode_node_unref0 (_tmp2444_); + len_call = _tmp2446_; + _tmp2447_ = len_call; + _tmp2448_ = unary; + _tmp2449_ = vala_unary_expression_get_inner (_tmp2448_); + _tmp2450_ = _tmp2449_; + _tmp2451_ = vala_expression_get_target_value (_tmp2450_); + _tmp2452_ = _tmp2451_; + _tmp2453_ = vala_get_cvalue_ (_tmp2452_); + vala_ccode_function_call_add_argument (_tmp2447_, _tmp2453_); + _tmp2454_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2455_ = _tmp2454_; + _tmp2456_ = unary; + _tmp2457_ = vala_unary_expression_get_inner (_tmp2456_); + _tmp2458_ = _tmp2457_; + _tmp2459_ = vala_expression_get_target_value (_tmp2458_); + _tmp2460_ = _tmp2459_; + _tmp2461_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, _tmp2460_, 1); + _tmp2462_ = _tmp2461_; + _tmp2463_ = len_call; + vala_ccode_function_add_assignment (_tmp2455_, _tmp2462_, (ValaCCodeExpression*) _tmp2463_); + _vala_ccode_node_unref0 (_tmp2462_); _vala_ccode_node_unref0 (len_call); } _vala_code_node_unref0 (unary); @@ -7371,116 +7563,116 @@ _vala_code_node_unref0 (arg); } } - _tmp2398_ = m; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2398_, VALA_TYPE_CREATION_METHOD)) { - ValaMethod* _tmp2399_; - ValaSymbol* _tmp2400_; - ValaSymbol* _tmp2401_; - _tmp2399_ = m; - _tmp2400_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2399_); - _tmp2401_ = _tmp2400_; - _tmp2397_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2401_, VALA_TYPE_CLASS); + _tmp2466_ = m; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2466_, VALA_TYPE_CREATION_METHOD)) { + ValaMethod* _tmp2467_; + ValaSymbol* _tmp2468_; + ValaSymbol* _tmp2469_; + _tmp2467_ = m; + _tmp2468_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2467_); + _tmp2469_ = _tmp2468_; + _tmp2465_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2469_, VALA_TYPE_CLASS); } else { - _tmp2397_ = FALSE; + _tmp2465_ = FALSE; } - if (_tmp2397_) { - gboolean _tmp2402_ = FALSE; - gboolean _tmp2403_ = FALSE; - ValaClass* _tmp2404_; - ValaClass* _tmp2405_; - gboolean _tmp2406_; - gboolean _tmp2407_; - _tmp2404_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp2405_ = _tmp2404_; - _tmp2406_ = vala_class_get_is_compact (_tmp2405_); - _tmp2407_ = _tmp2406_; - if (_tmp2407_) { - ValaClass* _tmp2408_; - ValaClass* _tmp2409_; - ValaClass* _tmp2410_; - ValaClass* _tmp2411_; - _tmp2408_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp2409_ = _tmp2408_; - _tmp2410_ = vala_class_get_base_class (_tmp2409_); - _tmp2411_ = _tmp2410_; - _tmp2403_ = _tmp2411_ != NULL; - } else { - _tmp2403_ = FALSE; - } - if (_tmp2403_) { - _tmp2402_ = TRUE; - } else { - ValaClass* _tmp2412_; - ValaClass* _tmp2413_; - ValaClass* _tmp2414_; - _tmp2412_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp2413_ = _tmp2412_; - _tmp2414_ = ((ValaCCodeBaseModule*) self)->gsource_type; - _tmp2402_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp2413_, (ValaTypeSymbol*) _tmp2414_); + if (_tmp2465_) { + gboolean _tmp2470_ = FALSE; + gboolean _tmp2471_ = FALSE; + ValaClass* _tmp2472_; + ValaClass* _tmp2473_; + gboolean _tmp2474_; + gboolean _tmp2475_; + _tmp2472_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp2473_ = _tmp2472_; + _tmp2474_ = vala_class_get_is_compact (_tmp2473_); + _tmp2475_ = _tmp2474_; + if (_tmp2475_) { + ValaClass* _tmp2476_; + ValaClass* _tmp2477_; + ValaClass* _tmp2478_; + ValaClass* _tmp2479_; + _tmp2476_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp2477_ = _tmp2476_; + _tmp2478_ = vala_class_get_base_class (_tmp2477_); + _tmp2479_ = _tmp2478_; + _tmp2471_ = _tmp2479_ != NULL; + } else { + _tmp2471_ = FALSE; } - _tmp2396_ = _tmp2402_; + if (_tmp2471_) { + _tmp2470_ = TRUE; + } else { + ValaClass* _tmp2480_; + ValaClass* _tmp2481_; + ValaClass* _tmp2482_; + _tmp2480_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp2481_ = _tmp2480_; + _tmp2482_ = ((ValaCCodeBaseModule*) self)->gsource_type; + _tmp2470_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp2481_, (ValaTypeSymbol*) _tmp2482_); + } + _tmp2464_ = _tmp2470_; } else { - _tmp2396_ = FALSE; + _tmp2464_ = FALSE; } - if (_tmp2396_) { + if (_tmp2464_) { ValaCCodeFunctionCall* cinitcall = NULL; - ValaClass* _tmp2415_; - ValaClass* _tmp2416_; - gchar* _tmp2417_; - gchar* _tmp2418_; - gchar* _tmp2419_; - gchar* _tmp2420_; - ValaCCodeIdentifier* _tmp2421_; - ValaCCodeIdentifier* _tmp2422_; - ValaCCodeFunctionCall* _tmp2423_; - ValaCCodeFunctionCall* _tmp2424_; - ValaCCodeFunctionCall* _tmp2425_; - ValaCCodeExpression* _tmp2426_; - ValaCCodeExpression* _tmp2427_; - ValaClass* _tmp2428_; - ValaClass* _tmp2429_; - gboolean _tmp2430_; - gboolean _tmp2431_; - ValaCCodeFunction* _tmp2435_; - ValaCCodeFunction* _tmp2436_; - ValaCCodeFunctionCall* _tmp2437_; - _tmp2415_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp2416_ = _tmp2415_; - _tmp2417_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp2416_, NULL); - _tmp2418_ = _tmp2417_; - _tmp2419_ = g_strdup_printf ("%s_instance_init", _tmp2418_); - _tmp2420_ = _tmp2419_; - _tmp2421_ = vala_ccode_identifier_new (_tmp2420_); - _tmp2422_ = _tmp2421_; - _tmp2423_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2422_); - _tmp2424_ = _tmp2423_; - _vala_ccode_node_unref0 (_tmp2422_); - _g_free0 (_tmp2420_); - _g_free0 (_tmp2418_); - cinitcall = _tmp2424_; - _tmp2425_ = cinitcall; - _tmp2426_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self); - _tmp2427_ = _tmp2426_; - vala_ccode_function_call_add_argument (_tmp2425_, _tmp2427_); - _vala_ccode_node_unref0 (_tmp2427_); - _tmp2428_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp2429_ = _tmp2428_; - _tmp2430_ = vala_class_get_is_compact (_tmp2429_); - _tmp2431_ = _tmp2430_; - if (!_tmp2431_) { - ValaCCodeFunctionCall* _tmp2432_; - ValaCCodeConstant* _tmp2433_; - ValaCCodeConstant* _tmp2434_; - _tmp2432_ = cinitcall; - _tmp2433_ = vala_ccode_constant_new ("NULL"); - _tmp2434_ = _tmp2433_; - vala_ccode_function_call_add_argument (_tmp2432_, (ValaCCodeExpression*) _tmp2434_); - _vala_ccode_node_unref0 (_tmp2434_); - } - _tmp2435_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2436_ = _tmp2435_; - _tmp2437_ = cinitcall; - vala_ccode_function_add_expression (_tmp2436_, (ValaCCodeExpression*) _tmp2437_); + ValaClass* _tmp2483_; + ValaClass* _tmp2484_; + gchar* _tmp2485_; + gchar* _tmp2486_; + gchar* _tmp2487_; + gchar* _tmp2488_; + ValaCCodeIdentifier* _tmp2489_; + ValaCCodeIdentifier* _tmp2490_; + ValaCCodeFunctionCall* _tmp2491_; + ValaCCodeFunctionCall* _tmp2492_; + ValaCCodeFunctionCall* _tmp2493_; + ValaCCodeExpression* _tmp2494_; + ValaCCodeExpression* _tmp2495_; + ValaClass* _tmp2496_; + ValaClass* _tmp2497_; + gboolean _tmp2498_; + gboolean _tmp2499_; + ValaCCodeFunction* _tmp2503_; + ValaCCodeFunction* _tmp2504_; + ValaCCodeFunctionCall* _tmp2505_; + _tmp2483_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp2484_ = _tmp2483_; + _tmp2485_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp2484_, NULL); + _tmp2486_ = _tmp2485_; + _tmp2487_ = g_strdup_printf ("%s_instance_init", _tmp2486_); + _tmp2488_ = _tmp2487_; + _tmp2489_ = vala_ccode_identifier_new (_tmp2488_); + _tmp2490_ = _tmp2489_; + _tmp2491_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2490_); + _tmp2492_ = _tmp2491_; + _vala_ccode_node_unref0 (_tmp2490_); + _g_free0 (_tmp2488_); + _g_free0 (_tmp2486_); + cinitcall = _tmp2492_; + _tmp2493_ = cinitcall; + _tmp2494_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self); + _tmp2495_ = _tmp2494_; + vala_ccode_function_call_add_argument (_tmp2493_, _tmp2495_); + _vala_ccode_node_unref0 (_tmp2495_); + _tmp2496_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp2497_ = _tmp2496_; + _tmp2498_ = vala_class_get_is_compact (_tmp2497_); + _tmp2499_ = _tmp2498_; + if (!_tmp2499_) { + ValaCCodeFunctionCall* _tmp2500_; + ValaCCodeConstant* _tmp2501_; + ValaCCodeConstant* _tmp2502_; + _tmp2500_ = cinitcall; + _tmp2501_ = vala_ccode_constant_new ("NULL"); + _tmp2502_ = _tmp2501_; + vala_ccode_function_call_add_argument (_tmp2500_, (ValaCCodeExpression*) _tmp2502_); + _vala_ccode_node_unref0 (_tmp2502_); + } + _tmp2503_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2504_ = _tmp2503_; + _tmp2505_ = cinitcall; + vala_ccode_function_add_expression (_tmp2504_, (ValaCCodeExpression*) _tmp2505_); _vala_ccode_node_unref0 (cinitcall); } _vala_ccode_node_unref0 (out_param_ref); diff -Nru vala-0.52.6/codegen/valaccodemethodcallmodule.vala vala-0.52.7/codegen/valaccodemethodcallmodule.vala --- vala-0.52.6/codegen/valaccodemethodcallmodule.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/codegen/valaccodemethodcallmodule.vala 2021-10-30 08:19:54.000000000 +0000 @@ -837,6 +837,28 @@ } + // Transform and add free function argument to GLib.[List,Queue,SList].remove[_all] calls + unowned DataType? collection_type = null; + if (ma != null && ma.inner != null) { + collection_type = ma.inner.value_type; + } + if (collection_type != null + && (collection_type.type_symbol == glist_type || collection_type.type_symbol == gslist_type || collection_type.type_symbol == gqueue_type) + && (ma.member_name == "remove" || ma.member_name == "remove_all") + //FIXME Perform stricter type argument check earlier + && collection_type.check_type_arguments (context)) { + var remove_method = (Method) collection_type.type_symbol.scope.lookup (ma.member_name + "_full"); + var type_arg = collection_type.get_type_arguments ()[0]; + if (remove_method != null && requires_destroy (type_arg)) { + // only add them once per source file + if (add_generated_external_symbol (remove_method)) { + visit_method (remove_method); + } + ccall.call = new CCodeIdentifier (get_ccode_name (remove_method)); + ccall.add_argument (get_destroy0_func_expression (type_arg)); + } + } + if (return_result_via_out_param) { ccode.add_expression (ccall_expr); ccall_expr = out_param_ref; diff -Nru vala-0.52.6/codegen/valagerrormodule.c vala-0.52.7/codegen/valagerrormodule.c --- vala-0.52.6/codegen/valagerrormodule.c 2021-10-04 09:47:20.000000000 +0000 +++ vala-0.52.7/codegen/valagerrormodule.c 2021-10-30 08:24:34.000000000 +0000 @@ -1146,147 +1146,140 @@ ValaDataType* _tmp79_; ValaDataType* _tmp80_; ValaErrorType* _tmp81_; - ValaErrorType* _tmp82_; + ValaErrorCode* _tmp82_; ValaErrorCode* _tmp83_; - ValaErrorCode* _tmp84_; - ValaCCodeFunction* _tmp129_; - ValaCCodeFunction* _tmp130_; - ValaCatchClause* _tmp131_; - gchar* _tmp132_; - gchar* _tmp133_; - ValaCCodeFunction* _tmp134_; - ValaCCodeFunction* _tmp135_; + ValaCCodeFunction* _tmp126_; + ValaCCodeFunction* _tmp127_; + ValaCatchClause* _tmp128_; + gchar* _tmp129_; + gchar* _tmp130_; + ValaCCodeFunction* _tmp131_; + ValaCCodeFunction* _tmp132_; _tmp78_ = clause; _tmp79_ = vala_catch_clause_get_error_type (_tmp78_); _tmp80_ = _tmp79_; - _tmp81_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp80_, VALA_TYPE_ERROR_TYPE) ? ((ValaErrorType*) _tmp80_) : NULL); - catch_type = _tmp81_; - _tmp82_ = catch_type; - _tmp83_ = vala_error_type_get_error_code (_tmp82_); - _tmp84_ = _tmp83_; - if (_tmp84_ != NULL) { + catch_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp80_, VALA_TYPE_ERROR_TYPE, ValaErrorType); + _tmp81_ = catch_type; + _tmp82_ = vala_error_type_get_error_code (_tmp81_); + _tmp83_ = _tmp82_; + if (_tmp83_ != NULL) { ValaCCodeFunctionCall* error_match = NULL; + ValaCCodeIdentifier* _tmp84_; ValaCCodeIdentifier* _tmp85_; - ValaCCodeIdentifier* _tmp86_; + ValaCCodeFunctionCall* _tmp86_; ValaCCodeFunctionCall* _tmp87_; ValaCCodeFunctionCall* _tmp88_; - ValaCCodeFunctionCall* _tmp89_; + ValaCCodeExpression* _tmp89_; ValaCCodeExpression* _tmp90_; - ValaCCodeExpression* _tmp91_; - ValaCCodeFunctionCall* _tmp92_; - ValaErrorType* _tmp93_; - ValaTypeSymbol* _tmp94_; - ValaTypeSymbol* _tmp95_; + ValaCCodeFunctionCall* _tmp91_; + ValaErrorType* _tmp92_; + ValaErrorDomain* _tmp93_; + ValaErrorDomain* _tmp94_; + gchar* _tmp95_; gchar* _tmp96_; - gchar* _tmp97_; + ValaCCodeIdentifier* _tmp97_; ValaCCodeIdentifier* _tmp98_; - ValaCCodeIdentifier* _tmp99_; - ValaCCodeFunctionCall* _tmp100_; - ValaErrorType* _tmp101_; + ValaCCodeFunctionCall* _tmp99_; + ValaErrorType* _tmp100_; + ValaErrorCode* _tmp101_; ValaErrorCode* _tmp102_; - ValaErrorCode* _tmp103_; + gchar* _tmp103_; gchar* _tmp104_; - gchar* _tmp105_; + ValaCCodeIdentifier* _tmp105_; ValaCCodeIdentifier* _tmp106_; - ValaCCodeIdentifier* _tmp107_; + ValaCCodeFunction* _tmp107_; ValaCCodeFunction* _tmp108_; - ValaCCodeFunction* _tmp109_; - ValaCCodeFunctionCall* _tmp110_; - _tmp85_ = vala_ccode_identifier_new ("g_error_matches"); - _tmp86_ = _tmp85_; - _tmp87_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp86_); - _tmp88_ = _tmp87_; - _vala_ccode_node_unref0 (_tmp86_); - error_match = _tmp88_; - _tmp89_ = error_match; - _tmp90_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); - _tmp91_ = _tmp90_; - vala_ccode_function_call_add_argument (_tmp89_, _tmp91_); - _vala_ccode_node_unref0 (_tmp91_); - _tmp92_ = error_match; - _tmp93_ = catch_type; - _tmp94_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp93_); - _tmp95_ = _tmp94_; - _tmp96_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp95_, NULL); - _tmp97_ = _tmp96_; - _tmp98_ = vala_ccode_identifier_new (_tmp97_); - _tmp99_ = _tmp98_; - vala_ccode_function_call_add_argument (_tmp92_, (ValaCCodeExpression*) _tmp99_); - _vala_ccode_node_unref0 (_tmp99_); - _g_free0 (_tmp97_); - _tmp100_ = error_match; - _tmp101_ = catch_type; - _tmp102_ = vala_error_type_get_error_code (_tmp101_); - _tmp103_ = _tmp102_; - _tmp104_ = vala_get_ccode_name ((ValaCodeNode*) _tmp103_); - _tmp105_ = _tmp104_; - _tmp106_ = vala_ccode_identifier_new (_tmp105_); - _tmp107_ = _tmp106_; - vala_ccode_function_call_add_argument (_tmp100_, (ValaCCodeExpression*) _tmp107_); - _vala_ccode_node_unref0 (_tmp107_); - _g_free0 (_tmp105_); - _tmp108_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp109_ = _tmp108_; - _tmp110_ = error_match; - vala_ccode_function_open_if (_tmp109_, (ValaCCodeExpression*) _tmp110_); + ValaCCodeFunctionCall* _tmp109_; + _tmp84_ = vala_ccode_identifier_new ("g_error_matches"); + _tmp85_ = _tmp84_; + _tmp86_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp85_); + _tmp87_ = _tmp86_; + _vala_ccode_node_unref0 (_tmp85_); + error_match = _tmp87_; + _tmp88_ = error_match; + _tmp89_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); + _tmp90_ = _tmp89_; + vala_ccode_function_call_add_argument (_tmp88_, _tmp90_); + _vala_ccode_node_unref0 (_tmp90_); + _tmp91_ = error_match; + _tmp92_ = catch_type; + _tmp93_ = vala_error_type_get_error_domain (_tmp92_); + _tmp94_ = _tmp93_; + _tmp95_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp94_, NULL); + _tmp96_ = _tmp95_; + _tmp97_ = vala_ccode_identifier_new (_tmp96_); + _tmp98_ = _tmp97_; + vala_ccode_function_call_add_argument (_tmp91_, (ValaCCodeExpression*) _tmp98_); + _vala_ccode_node_unref0 (_tmp98_); + _g_free0 (_tmp96_); + _tmp99_ = error_match; + _tmp100_ = catch_type; + _tmp101_ = vala_error_type_get_error_code (_tmp100_); + _tmp102_ = _tmp101_; + _tmp103_ = vala_get_ccode_name ((ValaCodeNode*) _tmp102_); + _tmp104_ = _tmp103_; + _tmp105_ = vala_ccode_identifier_new (_tmp104_); + _tmp106_ = _tmp105_; + vala_ccode_function_call_add_argument (_tmp99_, (ValaCCodeExpression*) _tmp106_); + _vala_ccode_node_unref0 (_tmp106_); + _g_free0 (_tmp104_); + _tmp107_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp108_ = _tmp107_; + _tmp109_ = error_match; + vala_ccode_function_open_if (_tmp108_, (ValaCCodeExpression*) _tmp109_); _vala_ccode_node_unref0 (error_match); } else { ValaCCodeBinaryExpression* ccond = NULL; + ValaCCodeExpression* _tmp110_; ValaCCodeExpression* _tmp111_; - ValaCCodeExpression* _tmp112_; + ValaCCodeMemberAccess* _tmp112_; ValaCCodeMemberAccess* _tmp113_; - ValaCCodeMemberAccess* _tmp114_; - ValaCatchClause* _tmp115_; - ValaDataType* _tmp116_; - ValaDataType* _tmp117_; - ValaTypeSymbol* _tmp118_; - ValaTypeSymbol* _tmp119_; - gchar* _tmp120_; - gchar* _tmp121_; - ValaCCodeIdentifier* _tmp122_; - ValaCCodeIdentifier* _tmp123_; - ValaCCodeBinaryExpression* _tmp124_; + ValaErrorType* _tmp114_; + ValaErrorDomain* _tmp115_; + ValaErrorDomain* _tmp116_; + gchar* _tmp117_; + gchar* _tmp118_; + ValaCCodeIdentifier* _tmp119_; + ValaCCodeIdentifier* _tmp120_; + ValaCCodeBinaryExpression* _tmp121_; + ValaCCodeBinaryExpression* _tmp122_; + ValaCCodeFunction* _tmp123_; + ValaCCodeFunction* _tmp124_; ValaCCodeBinaryExpression* _tmp125_; - ValaCCodeFunction* _tmp126_; - ValaCCodeFunction* _tmp127_; - ValaCCodeBinaryExpression* _tmp128_; - _tmp111_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); - _tmp112_ = _tmp111_; - _tmp113_ = vala_ccode_member_access_new_pointer (_tmp112_, "domain"); - _tmp114_ = _tmp113_; - _tmp115_ = clause; - _tmp116_ = vala_catch_clause_get_error_type (_tmp115_); - _tmp117_ = _tmp116_; - _tmp118_ = vala_data_type_get_type_symbol (_tmp117_); - _tmp119_ = _tmp118_; - _tmp120_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp119_, NULL); - _tmp121_ = _tmp120_; - _tmp122_ = vala_ccode_identifier_new (_tmp121_); - _tmp123_ = _tmp122_; - _tmp124_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp114_, (ValaCCodeExpression*) _tmp123_); - _tmp125_ = _tmp124_; - _vala_ccode_node_unref0 (_tmp123_); - _g_free0 (_tmp121_); - _vala_ccode_node_unref0 (_tmp114_); - _vala_ccode_node_unref0 (_tmp112_); - ccond = _tmp125_; - _tmp126_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp127_ = _tmp126_; - _tmp128_ = ccond; - vala_ccode_function_open_if (_tmp127_, (ValaCCodeExpression*) _tmp128_); + _tmp110_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); + _tmp111_ = _tmp110_; + _tmp112_ = vala_ccode_member_access_new_pointer (_tmp111_, "domain"); + _tmp113_ = _tmp112_; + _tmp114_ = catch_type; + _tmp115_ = vala_error_type_get_error_domain (_tmp114_); + _tmp116_ = _tmp115_; + _tmp117_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp116_, NULL); + _tmp118_ = _tmp117_; + _tmp119_ = vala_ccode_identifier_new (_tmp118_); + _tmp120_ = _tmp119_; + _tmp121_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp113_, (ValaCCodeExpression*) _tmp120_); + _tmp122_ = _tmp121_; + _vala_ccode_node_unref0 (_tmp120_); + _g_free0 (_tmp118_); + _vala_ccode_node_unref0 (_tmp113_); + _vala_ccode_node_unref0 (_tmp111_); + ccond = _tmp122_; + _tmp123_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp124_ = _tmp123_; + _tmp125_ = ccond; + vala_ccode_function_open_if (_tmp124_, (ValaCCodeExpression*) _tmp125_); _vala_ccode_node_unref0 (ccond); } - _tmp129_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp126_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp127_ = _tmp126_; + _tmp128_ = clause; + _tmp129_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp128_, "CCode", "cname", NULL); _tmp130_ = _tmp129_; - _tmp131_ = clause; - _tmp132_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp131_, "CCode", "cname", NULL); - _tmp133_ = _tmp132_; - vala_ccode_function_add_goto (_tmp130_, _tmp133_); - _g_free0 (_tmp133_); - _tmp134_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp135_ = _tmp134_; - vala_ccode_function_close (_tmp135_); - _vala_code_node_unref0 (catch_type); + vala_ccode_function_add_goto (_tmp127_, _tmp130_); + _g_free0 (_tmp130_); + _tmp131_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp132_ = _tmp131_; + vala_ccode_function_close (_tmp132_); } _vala_code_node_unref0 (clause); } @@ -1295,231 +1288,231 @@ } if (has_general_catch_clause) { } else { - ValaArrayList* _tmp136_; - gint _tmp137_; - gint _tmp138_; - _tmp136_ = error_types; - _tmp137_ = vala_collection_get_size ((ValaCollection*) _tmp136_); - _tmp138_ = _tmp137_; - if (_tmp138_ > 0) { - ValaCCodeFunction* _tmp139_; - ValaCCodeFunction* _tmp140_; - gint _tmp141_; - gint _tmp142_; - gchar* _tmp143_; - gchar* _tmp144_; - _tmp139_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp140_ = _tmp139_; - _tmp141_ = vala_ccode_base_module_get_current_try_id ((ValaCCodeBaseModule*) self); - _tmp142_ = _tmp141_; - _tmp143_ = g_strdup_printf ("__finally%d", _tmp142_); - _tmp144_ = _tmp143_; - vala_ccode_function_add_goto (_tmp140_, _tmp144_); - _g_free0 (_tmp144_); + ValaArrayList* _tmp133_; + gint _tmp134_; + gint _tmp135_; + _tmp133_ = error_types; + _tmp134_ = vala_collection_get_size ((ValaCollection*) _tmp133_); + _tmp135_ = _tmp134_; + if (_tmp135_ > 0) { + ValaCCodeFunction* _tmp136_; + ValaCCodeFunction* _tmp137_; + gint _tmp138_; + gint _tmp139_; + gchar* _tmp140_; + gchar* _tmp141_; + _tmp136_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp137_ = _tmp136_; + _tmp138_ = vala_ccode_base_module_get_current_try_id ((ValaCCodeBaseModule*) self); + _tmp139_ = _tmp138_; + _tmp140_ = g_strdup_printf ("__finally%d", _tmp139_); + _tmp141_ = _tmp140_; + vala_ccode_function_add_goto (_tmp137_, _tmp141_); + _g_free0 (_tmp141_); } else { if (vala_gerror_module_in_finally_block (self, node)) { } else { - ValaCCodeExpression* _tmp145_; - ValaCCodeExpression* _tmp146_; - ValaTryStatement* _tmp147_; - ValaTryStatement* _tmp148_; - _tmp145_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); - _tmp146_ = _tmp145_; - _tmp147_ = vala_ccode_base_module_get_current_try ((ValaCCodeBaseModule*) self); - _tmp148_ = _tmp147_; - vala_gerror_module_uncaught_error_statement (self, _tmp146_, TRUE, (ValaCodeNode*) _tmp148_); - _vala_ccode_node_unref0 (_tmp146_); + ValaCCodeExpression* _tmp142_; + ValaCCodeExpression* _tmp143_; + ValaTryStatement* _tmp144_; + ValaTryStatement* _tmp145_; + _tmp142_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); + _tmp143_ = _tmp142_; + _tmp144_ = vala_ccode_base_module_get_current_try ((ValaCCodeBaseModule*) self); + _tmp145_ = _tmp144_; + vala_gerror_module_uncaught_error_statement (self, _tmp143_, TRUE, (ValaCodeNode*) _tmp145_); + _vala_ccode_node_unref0 (_tmp143_); } } } _vala_iterable_unref0 (error_types); } else { - gboolean _tmp149_ = FALSE; - ValaMethod* _tmp150_; - ValaMethod* _tmp151_; - _tmp150_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self); - _tmp151_ = _tmp150_; - if (_tmp151_ != NULL) { - ValaMethod* _tmp152_; - ValaMethod* _tmp153_; - gboolean _tmp154_; - gboolean _tmp155_; - _tmp152_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self); - _tmp153_ = _tmp152_; - _tmp154_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp153_); - _tmp155_ = _tmp154_; - _tmp149_ = _tmp155_; + gboolean _tmp146_ = FALSE; + ValaMethod* _tmp147_; + ValaMethod* _tmp148_; + _tmp147_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self); + _tmp148_ = _tmp147_; + if (_tmp148_ != NULL) { + ValaMethod* _tmp149_; + ValaMethod* _tmp150_; + gboolean _tmp151_; + gboolean _tmp152_; + _tmp149_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self); + _tmp150_ = _tmp149_; + _tmp151_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp150_); + _tmp152_ = _tmp151_; + _tmp146_ = _tmp152_; } else { - _tmp149_ = FALSE; + _tmp146_ = FALSE; } - if (_tmp149_) { + if (_tmp146_) { ValaCCodeBinaryExpression* ccond = NULL; ValaArrayList* error_types = NULL; - GEqualFunc _tmp156_; + GEqualFunc _tmp153_; + ValaArrayList* _tmp154_; + ValaMethod* _tmp155_; + ValaMethod* _tmp156_; ValaArrayList* _tmp157_; - ValaMethod* _tmp158_; - ValaMethod* _tmp159_; - ValaArrayList* _tmp160_; - ValaCCodeBinaryExpression* _tmp190_; + ValaCCodeBinaryExpression* _tmp187_; ccond = NULL; - _tmp156_ = g_direct_equal; - _tmp157_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp156_); - error_types = _tmp157_; - _tmp158_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self); - _tmp159_ = _tmp158_; - _tmp160_ = error_types; - vala_code_node_get_error_types ((ValaCodeNode*) _tmp159_, (ValaCollection*) _tmp160_, NULL); + _tmp153_ = g_direct_equal; + _tmp154_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp153_); + error_types = _tmp154_; + _tmp155_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self); + _tmp156_ = _tmp155_; + _tmp157_ = error_types; + vala_code_node_get_error_types ((ValaCodeNode*) _tmp156_, (ValaCollection*) _tmp157_, NULL); { ValaArrayList* _error_type_list = NULL; - ValaArrayList* _tmp161_; + ValaArrayList* _tmp158_; gint _error_type_size = 0; - ValaArrayList* _tmp162_; - gint _tmp163_; - gint _tmp164_; + ValaArrayList* _tmp159_; + gint _tmp160_; + gint _tmp161_; gint _error_type_index = 0; - _tmp161_ = error_types; - _error_type_list = _tmp161_; - _tmp162_ = _error_type_list; - _tmp163_ = vala_collection_get_size ((ValaCollection*) _tmp162_); - _tmp164_ = _tmp163_; - _error_type_size = _tmp164_; + _tmp158_ = error_types; + _error_type_list = _tmp158_; + _tmp159_ = _error_type_list; + _tmp160_ = vala_collection_get_size ((ValaCollection*) _tmp159_); + _tmp161_ = _tmp160_; + _error_type_size = _tmp161_; _error_type_index = -1; while (TRUE) { - gint _tmp165_; - gint _tmp166_; + gint _tmp162_; + gint _tmp163_; ValaDataType* error_type = NULL; - ValaArrayList* _tmp167_; - gpointer _tmp168_; - ValaDataType* _tmp169_; - ValaErrorType* _tmp170_; + ValaArrayList* _tmp164_; + gpointer _tmp165_; + ValaDataType* _tmp166_; + ValaErrorType* _tmp167_; ValaCCodeBinaryExpression* domain_check = NULL; - ValaCCodeExpression* _tmp171_; - ValaCCodeExpression* _tmp172_; - ValaCCodeMemberAccess* _tmp173_; - ValaCCodeMemberAccess* _tmp174_; - ValaDataType* _tmp175_; - ValaTypeSymbol* _tmp176_; - ValaTypeSymbol* _tmp177_; - gchar* _tmp178_; - gchar* _tmp179_; - ValaCCodeIdentifier* _tmp180_; - ValaCCodeIdentifier* _tmp181_; - ValaCCodeBinaryExpression* _tmp182_; - ValaCCodeBinaryExpression* _tmp183_; - ValaCCodeBinaryExpression* _tmp184_; + ValaCCodeExpression* _tmp168_; + ValaCCodeExpression* _tmp169_; + ValaCCodeMemberAccess* _tmp170_; + ValaCCodeMemberAccess* _tmp171_; + ValaDataType* _tmp172_; + ValaErrorDomain* _tmp173_; + ValaErrorDomain* _tmp174_; + gchar* _tmp175_; + gchar* _tmp176_; + ValaCCodeIdentifier* _tmp177_; + ValaCCodeIdentifier* _tmp178_; + ValaCCodeBinaryExpression* _tmp179_; + ValaCCodeBinaryExpression* _tmp180_; + ValaCCodeBinaryExpression* _tmp181_; _error_type_index = _error_type_index + 1; - _tmp165_ = _error_type_index; - _tmp166_ = _error_type_size; - if (!(_tmp165_ < _tmp166_)) { + _tmp162_ = _error_type_index; + _tmp163_ = _error_type_size; + if (!(_tmp162_ < _tmp163_)) { break; } - _tmp167_ = _error_type_list; - _tmp168_ = vala_list_get ((ValaList*) _tmp167_, _error_type_index); - error_type = (ValaDataType*) _tmp168_; - _tmp169_ = error_type; - _tmp170_ = ((ValaCCodeBaseModule*) self)->gerror_type; - if (vala_data_type_equals (_tmp169_, (ValaDataType*) _tmp170_)) { + _tmp164_ = _error_type_list; + _tmp165_ = vala_list_get ((ValaList*) _tmp164_, _error_type_index); + error_type = (ValaDataType*) _tmp165_; + _tmp166_ = error_type; + _tmp167_ = ((ValaCCodeBaseModule*) self)->gerror_type; + if (vala_data_type_equals (_tmp166_, (ValaDataType*) _tmp167_)) { _vala_ccode_node_unref0 (ccond); ccond = NULL; _vala_code_node_unref0 (error_type); break; } - _tmp171_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); - _tmp172_ = _tmp171_; - _tmp173_ = vala_ccode_member_access_new_pointer (_tmp172_, "domain"); + _tmp168_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); + _tmp169_ = _tmp168_; + _tmp170_ = vala_ccode_member_access_new_pointer (_tmp169_, "domain"); + _tmp171_ = _tmp170_; + _tmp172_ = error_type; + _tmp173_ = vala_error_type_get_error_domain (G_TYPE_CHECK_INSTANCE_CAST (_tmp172_, VALA_TYPE_ERROR_TYPE, ValaErrorType)); _tmp174_ = _tmp173_; - _tmp175_ = error_type; - _tmp176_ = vala_data_type_get_type_symbol (_tmp175_); - _tmp177_ = _tmp176_; - _tmp178_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp177_, NULL); - _tmp179_ = _tmp178_; - _tmp180_ = vala_ccode_identifier_new (_tmp179_); - _tmp181_ = _tmp180_; - _tmp182_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp174_, (ValaCCodeExpression*) _tmp181_); - _tmp183_ = _tmp182_; - _vala_ccode_node_unref0 (_tmp181_); - _g_free0 (_tmp179_); - _vala_ccode_node_unref0 (_tmp174_); - _vala_ccode_node_unref0 (_tmp172_); - domain_check = _tmp183_; - _tmp184_ = ccond; - if (_tmp184_ == NULL) { + _tmp175_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp174_, NULL); + _tmp176_ = _tmp175_; + _tmp177_ = vala_ccode_identifier_new (_tmp176_); + _tmp178_ = _tmp177_; + _tmp179_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp171_, (ValaCCodeExpression*) _tmp178_); + _tmp180_ = _tmp179_; + _vala_ccode_node_unref0 (_tmp178_); + _g_free0 (_tmp176_); + _vala_ccode_node_unref0 (_tmp171_); + _vala_ccode_node_unref0 (_tmp169_); + domain_check = _tmp180_; + _tmp181_ = ccond; + if (_tmp181_ == NULL) { + ValaCCodeBinaryExpression* _tmp182_; + ValaCCodeBinaryExpression* _tmp183_; + _tmp182_ = domain_check; + _tmp183_ = _vala_ccode_node_ref0 (_tmp182_); + _vala_ccode_node_unref0 (ccond); + ccond = _tmp183_; + } else { + ValaCCodeBinaryExpression* _tmp184_; ValaCCodeBinaryExpression* _tmp185_; ValaCCodeBinaryExpression* _tmp186_; + _tmp184_ = ccond; _tmp185_ = domain_check; - _tmp186_ = _vala_ccode_node_ref0 (_tmp185_); + _tmp186_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_OR, (ValaCCodeExpression*) _tmp184_, (ValaCCodeExpression*) _tmp185_); _vala_ccode_node_unref0 (ccond); ccond = _tmp186_; - } else { - ValaCCodeBinaryExpression* _tmp187_; - ValaCCodeBinaryExpression* _tmp188_; - ValaCCodeBinaryExpression* _tmp189_; - _tmp187_ = ccond; - _tmp188_ = domain_check; - _tmp189_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_OR, (ValaCCodeExpression*) _tmp187_, (ValaCCodeExpression*) _tmp188_); - _vala_ccode_node_unref0 (ccond); - ccond = _tmp189_; } _vala_ccode_node_unref0 (domain_check); _vala_code_node_unref0 (error_type); } } - _tmp190_ = ccond; - if (_tmp190_ != NULL) { - ValaCCodeFunction* _tmp191_; - ValaCCodeFunction* _tmp192_; - ValaCCodeBinaryExpression* _tmp193_; - ValaCCodeExpression* _tmp194_; + _tmp187_ = ccond; + if (_tmp187_ != NULL) { + ValaCCodeFunction* _tmp188_; + ValaCCodeFunction* _tmp189_; + ValaCCodeBinaryExpression* _tmp190_; + ValaCCodeExpression* _tmp191_; + ValaCCodeExpression* _tmp192_; + ValaCCodeFunction* _tmp193_; + ValaCCodeFunction* _tmp194_; ValaCCodeExpression* _tmp195_; - ValaCCodeFunction* _tmp196_; + ValaCCodeExpression* _tmp196_; ValaCCodeFunction* _tmp197_; - ValaCCodeExpression* _tmp198_; - ValaCCodeExpression* _tmp199_; - ValaCCodeFunction* _tmp200_; - ValaCCodeFunction* _tmp201_; - _tmp191_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + ValaCCodeFunction* _tmp198_; + _tmp188_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp189_ = _tmp188_; + _tmp190_ = ccond; + vala_ccode_function_open_if (_tmp189_, (ValaCCodeExpression*) _tmp190_); + _tmp191_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); _tmp192_ = _tmp191_; - _tmp193_ = ccond; - vala_ccode_function_open_if (_tmp192_, (ValaCCodeExpression*) _tmp193_); - _tmp194_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); - _tmp195_ = _tmp194_; - vala_gerror_module_return_with_exception (self, _tmp195_); - _vala_ccode_node_unref0 (_tmp195_); - _tmp196_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp197_ = _tmp196_; - vala_ccode_function_add_else (_tmp197_); - _tmp198_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); - _tmp199_ = _tmp198_; - vala_gerror_module_uncaught_error_statement (self, _tmp199_, FALSE, NULL); - _vala_ccode_node_unref0 (_tmp199_); - _tmp200_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp201_ = _tmp200_; - vala_ccode_function_close (_tmp201_); + vala_gerror_module_return_with_exception (self, _tmp192_); + _vala_ccode_node_unref0 (_tmp192_); + _tmp193_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp194_ = _tmp193_; + vala_ccode_function_add_else (_tmp194_); + _tmp195_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); + _tmp196_ = _tmp195_; + vala_gerror_module_uncaught_error_statement (self, _tmp196_, FALSE, NULL); + _vala_ccode_node_unref0 (_tmp196_); + _tmp197_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp198_ = _tmp197_; + vala_ccode_function_close (_tmp198_); } else { - ValaCCodeExpression* _tmp202_; - ValaCCodeExpression* _tmp203_; - _tmp202_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); - _tmp203_ = _tmp202_; - vala_gerror_module_return_with_exception (self, _tmp203_); - _vala_ccode_node_unref0 (_tmp203_); + ValaCCodeExpression* _tmp199_; + ValaCCodeExpression* _tmp200_; + _tmp199_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); + _tmp200_ = _tmp199_; + vala_gerror_module_return_with_exception (self, _tmp200_); + _vala_ccode_node_unref0 (_tmp200_); } _vala_iterable_unref0 (error_types); _vala_ccode_node_unref0 (ccond); } else { - ValaCCodeExpression* _tmp204_; - ValaCCodeExpression* _tmp205_; - _tmp204_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); - _tmp205_ = _tmp204_; - vala_gerror_module_uncaught_error_statement (self, _tmp205_, FALSE, NULL); - _vala_ccode_node_unref0 (_tmp205_); + ValaCCodeExpression* _tmp201_; + ValaCCodeExpression* _tmp202_; + _tmp201_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); + _tmp202_ = _tmp201_; + vala_gerror_module_uncaught_error_statement (self, _tmp202_, FALSE, NULL); + _vala_ccode_node_unref0 (_tmp202_); } } if (!always_fails) { - ValaCCodeFunction* _tmp206_; - ValaCCodeFunction* _tmp207_; - _tmp206_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp207_ = _tmp206_; - vala_ccode_function_close (_tmp207_); + ValaCCodeFunction* _tmp203_; + ValaCCodeFunction* _tmp204_; + _tmp203_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp204_ = _tmp203_; + vala_ccode_function_close (_tmp204_); } } diff -Nru vala-0.52.6/codegen/valagerrormodule.vala vala-0.52.7/codegen/valagerrormodule.vala --- vala-0.52.6/codegen/valagerrormodule.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/codegen/valagerrormodule.vala 2021-10-30 08:19:54.000000000 +0000 @@ -227,13 +227,13 @@ ccode.add_goto (clause.get_attribute_string ("CCode", "cname")); break; } else { - var catch_type = clause.error_type as ErrorType; + unowned ErrorType catch_type = (ErrorType) clause.error_type; if (catch_type.error_code != null) { /* catch clause specifies a specific error code */ var error_match = new CCodeFunctionCall (new CCodeIdentifier ("g_error_matches")); error_match.add_argument (get_inner_error_cexpression ()); - error_match.add_argument (new CCodeIdentifier (get_ccode_upper_case_name (catch_type.type_symbol))); + error_match.add_argument (new CCodeIdentifier (get_ccode_upper_case_name (catch_type.error_domain))); error_match.add_argument (new CCodeIdentifier (get_ccode_name (catch_type.error_code))); ccode.open_if (error_match); @@ -241,7 +241,7 @@ /* catch clause specifies a full error domain */ var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeMemberAccess.pointer (get_inner_error_cexpression (), "domain"), new CCodeIdentifier - (get_ccode_upper_case_name (clause.error_type.type_symbol))); + (get_ccode_upper_case_name (catch_type.error_domain))); ccode.open_if (ccond); } @@ -283,7 +283,7 @@ // Check the allowed error domains to propagate var domain_check = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeMemberAccess.pointer - (get_inner_error_cexpression (), "domain"), new CCodeIdentifier (get_ccode_upper_case_name (error_type.type_symbol))); + (get_inner_error_cexpression (), "domain"), new CCodeIdentifier (get_ccode_upper_case_name (((ErrorType) error_type).error_domain))); if (ccond == null) { ccond = domain_check; } else { diff -Nru vala-0.52.6/compiler/Makefile.in vala-0.52.7/compiler/Makefile.in --- vala-0.52.6/compiler/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/compiler/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/configure vala-0.52.7/configure --- vala-0.52.6/configure 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/configure 2021-10-30 08:23:55.000000000 +0000 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.71 for vala 0.52.6. +# Generated by GNU Autoconf 2.71 for vala 0.52.7. # # Report bugs to . # @@ -681,8 +681,8 @@ # Identity of this package. PACKAGE_NAME='vala' PACKAGE_TARNAME='vala' -PACKAGE_VERSION='0.52.6' -PACKAGE_STRING='vala 0.52.6' +PACKAGE_VERSION='0.52.7' +PACKAGE_STRING='vala 0.52.7' PACKAGE_BUGREPORT='https://gitlab.gnome.org/GNOME/vala/issues' PACKAGE_URL='https://wiki.gnome.org/Projects/Vala' @@ -1481,7 +1481,7 @@ # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures vala 0.52.6 to adapt to many kinds of systems. +\`configure' configures vala 0.52.7 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1552,7 +1552,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of vala 0.52.6:";; + short | recursive ) echo "Configuration of vala 0.52.7:";; esac cat <<\_ACEOF @@ -1687,7 +1687,7 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -vala configure 0.52.6 +vala configure 0.52.7 generated by GNU Autoconf 2.71 Copyright (C) 2021 Free Software Foundation, Inc. @@ -1948,7 +1948,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by vala $as_me 0.52.6, which was +It was created by vala $as_me 0.52.7, which was generated by GNU Autoconf 2.71. Invocation command line was $ $0$ac_configure_args_raw @@ -3222,7 +3222,7 @@ # Define the identity of the package. PACKAGE='vala' - VERSION='0.52.6' + VERSION='0.52.7' printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h @@ -14614,7 +14614,7 @@ # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by vala $as_me 0.52.6, which was +This file was extended by vala $as_me 0.52.7, which was generated by GNU Autoconf 2.71. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -14683,7 +14683,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ -vala config.status 0.52.6 +vala config.status 0.52.7 configured by $0, generated by GNU Autoconf 2.71, with options \\"\$ac_cs_config\\" diff -Nru vala-0.52.6/debian/changelog vala-0.52.7/debian/changelog --- vala-0.52.6/debian/changelog 2021-10-04 10:13:10.000000000 +0000 +++ vala-0.52.7/debian/changelog 2021-11-14 09:43:31.000000000 +0000 @@ -1,9 +1,9 @@ -vala (0.52.6-0ubuntu1~18.04~valateam0) bionic; urgency=high +vala (0.52.7-0ubuntu1~18.04~valateam0) bionic; urgency=high * New upstream release * New upstream release - -- Rico Tzschichholz Mon, 04 Oct 2021 12:13:10 +0200 + -- Rico Tzschichholz Sun, 14 Nov 2021 10:43:31 +0100 vala (0.48.18-1) unstable; urgency=medium diff -Nru vala-0.52.6/doc/Makefile.in vala-0.52.7/doc/Makefile.in --- vala-0.52.6/doc/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/doc/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/doc/manual/Makefile.in vala-0.52.7/doc/manual/Makefile.in --- vala-0.52.6/doc/manual/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/doc/manual/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/doc/valac.1 vala-0.52.7/doc/valac.1 --- vala-0.52.6/doc/valac.1 2021-10-04 09:42:35.000000000 +0000 +++ vala-0.52.7/doc/valac.1 2021-10-30 08:21:26.000000000 +0000 @@ -1,5 +1,5 @@ -.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.4. -.TH VALAC "1" "October 2021" "Vala 0.52.6" "User Commands" +.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5. +.TH VALAC "1" "October 2021" "Vala 0.52.7" "User Commands" .SH NAME valac \- compiler that translates Vala source code into C source and header files .SH SYNOPSIS diff -Nru vala-0.52.6/doc/valadoc.1 vala-0.52.7/doc/valadoc.1 --- vala-0.52.6/doc/valadoc.1 2021-10-04 09:42:39.000000000 +0000 +++ vala-0.52.7/doc/valadoc.1 2021-10-30 08:21:27.000000000 +0000 @@ -1,5 +1,5 @@ -.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.4. -.TH VALADOC "1" "October 2021" "Valadoc 0.52.6" "User Commands" +.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5. +.TH VALADOC "1" "October 2021" "Valadoc 0.52.7" "User Commands" .SH NAME valadoc \- Vala Documentation Tool .SH SYNOPSIS diff -Nru vala-0.52.6/doc/vala-gen-introspect.1 vala-0.52.7/doc/vala-gen-introspect.1 --- vala-0.52.6/doc/vala-gen-introspect.1 2021-10-04 09:42:43.000000000 +0000 +++ vala-0.52.7/doc/vala-gen-introspect.1 2021-10-30 08:21:28.000000000 +0000 @@ -1,5 +1,5 @@ -.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.4. -.TH VALA-GEN-INTROSPECT "1" "October 2021" "gen-introspect 0.52.6" "User Commands" +.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5. +.TH VALA-GEN-INTROSPECT "1" "October 2021" "gen-introspect 0.52.7" "User Commands" .SH NAME vala-gen-introspect \- generate a GI file for GObject and glib based packages .SH SYNOPSIS diff -Nru vala-0.52.6/doc/vapigen.1 vala-0.52.7/doc/vapigen.1 --- vala-0.52.6/doc/vapigen.1 2021-10-04 09:42:48.000000000 +0000 +++ vala-0.52.7/doc/vapigen.1 2021-10-30 08:21:28.000000000 +0000 @@ -1,5 +1,5 @@ -.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.4. -.TH VAPIGEN "1" "October 2021" "Vala API Generator 0.52.6" "User Commands" +.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5. +.TH VAPIGEN "1" "October 2021" "Vala API Generator 0.52.7" "User Commands" .SH NAME vapigen \- generate a Vala API .SH SYNOPSIS diff -Nru vala-0.52.6/gee/arraylist.vala vala-0.52.7/gee/arraylist.vala --- vala-0.52.6/gee/arraylist.vala 2021-04-19 18:42:41.000000000 +0000 +++ vala-0.52.7/gee/arraylist.vala 2021-10-26 12:38:24.000000000 +0000 @@ -169,7 +169,7 @@ // concurrent modification protection public int _stamp = 0; - public Iterator (ArrayList list) { + public Iterator (ArrayList list) { this.list = list; } diff -Nru vala-0.52.6/gee/hashmap.vala vala-0.52.7/gee/hashmap.vala --- vala-0.52.6/gee/hashmap.vala 2021-04-19 18:42:41.000000000 +0000 +++ vala-0.52.7/gee/hashmap.vala 2021-10-26 12:38:24.000000000 +0000 @@ -195,7 +195,7 @@ private HashMap _map; - public KeySet (HashMap map) { + public KeySet (HashMap map) { this.map = map; } @@ -243,7 +243,7 @@ // concurrent modification protection private int _stamp; - public MapIterator (HashMap map) { + public MapIterator (HashMap map) { this.map = map; } @@ -287,7 +287,7 @@ // concurrent modification protection private int _stamp; - public KeyIterator (HashMap map) { + public KeyIterator (HashMap map) { this.map = map; } @@ -340,7 +340,7 @@ private HashMap _map; - public ValueCollection (HashMap map) { + public ValueCollection (HashMap map) { this.map = map; } @@ -395,7 +395,7 @@ // concurrent modification protection private int _stamp; - public ValueIterator (HashMap map) { + public ValueIterator (HashMap map) { this.map = map; } diff -Nru vala-0.52.6/gee/hashset.vala vala-0.52.7/gee/hashset.vala --- vala-0.52.6/gee/hashset.vala 2021-04-19 18:42:41.000000000 +0000 +++ vala-0.52.7/gee/hashset.vala 2021-10-26 12:38:24.000000000 +0000 @@ -200,7 +200,7 @@ // concurrent modification protection private int _stamp = 0; - public Iterator (HashSet set) { + public Iterator (HashSet set) { this.set = set; } diff -Nru vala-0.52.6/gee/Makefile.in vala-0.52.7/gee/Makefile.in --- vala-0.52.6/gee/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/gee/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/gobject-introspection/Makefile.in vala-0.52.7/gobject-introspection/Makefile.in --- vala-0.52.6/gobject-introspection/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/gobject-introspection/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/gobject-introspection/scannerparser.c vala-0.52.7/gobject-introspection/scannerparser.c --- vala-0.52.6/gobject-introspection/scannerparser.c 2021-10-04 09:47:35.000000000 +0000 +++ vala-0.52.7/gobject-introspection/scannerparser.c 2021-10-30 08:24:48.000000000 +0000 @@ -1,4 +1,4 @@ -/* A Bison parser, made by GNU Bison 3.7.6. */ +/* A Bison parser, made by GNU Bison 3.8.2. */ /* Bison implementation for Yacc-like parsers in C @@ -46,10 +46,10 @@ USER NAME SPACE" below. */ /* Identify Bison output, and Bison version. */ -#define YYBISON 30706 +#define YYBISON 30802 /* Bison version string. */ -#define YYBISON_VERSION "3.7.6" +#define YYBISON_VERSION "3.8.2" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -436,8 +436,10 @@ extern YYSTYPE yylval; + int yyparse (GIGenerator* igenerator); + #endif /* !YY_YY_SCANNERPARSER_H_INCLUDED */ /* Symbol kind. */ enum yysymbol_kind_t @@ -767,12 +769,18 @@ # define YY_USE(E) /* empty */ #endif -#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ +#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") +# else +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ _Pragma ("GCC diagnostic push") \ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# endif # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ _Pragma ("GCC diagnostic pop") #else @@ -993,7 +1001,7 @@ }; #if YYDEBUG - /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ +/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_int16 yyrline[] = { 0, 279, 279, 286, 298, 302, 306, 307, 315, 321, @@ -1083,24 +1091,6 @@ } #endif -#ifdef YYPRINT -/* YYTOKNUM[NUM] -- (External) token number corresponding to the - (internal) symbol number NUM (which must be that of a token). */ -static const yytype_int16 yytoknum[] = -{ - 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 40, 41, - 91, 93, 46, 44, 38, 42, 43, 45, 126, 33, - 47, 37, 60, 62, 94, 124, 63, 58, 61, 59, - 123, 125 -}; -#endif - #define YYPACT_NINF (-199) #define yypact_value_is_default(Yyn) \ @@ -1111,8 +1101,8 @@ #define yytable_value_is_error(Yyn) \ 0 - /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ static const yytype_int16 yypact[] = { 1546, -199, -199, -199, -199, -199, -199, -199, 18, -199, @@ -1157,9 +1147,9 @@ -199, -199, -199, -199, 618, -199 }; - /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. - Performed when YYTABLE does not specify something else to do. Zero - means the default is an error. */ +/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE does not specify something else to do. Zero + means the default is an error. */ static const yytype_uint8 yydefact[] = { 0, 240, 184, 100, 111, 103, 142, 108, 0, 98, @@ -1204,7 +1194,7 @@ 208, 218, 217, 215, 0, 219 }; - /* YYPGOTO[NTERM-NUM]. */ +/* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { -199, -199, -199, -8, 1, -199, -199, 76, -199, -81, @@ -1217,7 +1207,7 @@ -199, -199, -199, -199, -199 }; - /* YYDEFGOTO[NTERM-NUM]. */ +/* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { 0, 82, 83, 84, 192, 85, 249, 133, 87, 88, @@ -1230,9 +1220,9 @@ 40, 41, 42, 43, 44 }; - /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule whose - number is the opposite. If YYTABLE_NINF, syntax error. */ +/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule whose + number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { 47, 99, 119, 56, 209, 136, 146, 107, 49, 48, @@ -1605,8 +1595,8 @@ -1, -1, 61, 62, 63, 64 }; - /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ +/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of + state STATE-NUM. */ static const yytype_uint8 yystos[] = { 0, 1, 4, 31, 32, 35, 36, 40, 42, 43, @@ -1651,7 +1641,7 @@ 149, 149, 149, 149, 69, 149 }; - /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ static const yytype_uint8 yyr1[] = { 0, 92, 93, 93, 93, 93, 93, 93, 94, 94, @@ -1681,7 +1671,7 @@ 166 }; - /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ +/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ static const yytype_int8 yyr2[] = { 0, 2, 1, 1, 1, 1, 1, 3, 1, 2, @@ -1720,6 +1710,7 @@ #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrorlab +#define YYNOMEM goto yyexhaustedlab #define YYRECOVERING() (!!yyerrstatus) @@ -1760,10 +1751,7 @@ YYFPRINTF Args; \ } while (0) -/* This macro is provided for backward compatibility. */ -# ifndef YY_LOCATION_PRINT -# define YY_LOCATION_PRINT(File, Loc) ((void) 0) -# endif + # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ @@ -1791,10 +1779,6 @@ YY_USE (igenerator); if (!yyvaluep) return; -# ifdef YYPRINT - if (yykind < YYNTOKENS) - YYPRINT (yyo, yytoknum[yykind], *yyvaluep); -# endif YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN YY_USE (yykind); YY_IGNORE_MAYBE_UNINITIALIZED_END @@ -2250,6 +2234,7 @@ YYDPRINTF ((stderr, "Starting parse\n")); yychar = YYEMPTY; /* Cause a token to be read. */ + goto yysetstate; @@ -2275,7 +2260,7 @@ if (yyss + yystacksize - 1 <= yyssp) #if !defined yyoverflow && !defined YYSTACK_RELOCATE - goto yyexhaustedlab; + YYNOMEM; #else { /* Get the current used size of the three stacks, in elements. */ @@ -2303,7 +2288,7 @@ # else /* defined YYSTACK_RELOCATE */ /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) - goto yyexhaustedlab; + YYNOMEM; yystacksize *= 2; if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH; @@ -2314,7 +2299,7 @@ YY_CAST (union yyalloc *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); if (! yyptr) - goto yyexhaustedlab; + YYNOMEM; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); # undef YYSTACK_RELOCATE @@ -2336,6 +2321,7 @@ } #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ + if (yystate == YYFINAL) YYACCEPT; @@ -2455,7 +2441,7 @@ (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } } -#line 2459 "scannerparser.c" +#line 2445 "scannerparser.c" break; case 3: /* primary_expression: INTEGER */ @@ -2471,7 +2457,7 @@ (yyval.symbol)->const_int = atoi (yytext); } } -#line 2475 "scannerparser.c" +#line 2461 "scannerparser.c" break; case 4: /* primary_expression: CHARACTER */ @@ -2479,7 +2465,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2483 "scannerparser.c" +#line 2469 "scannerparser.c" break; case 5: /* primary_expression: FLOATING */ @@ -2487,7 +2473,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2491 "scannerparser.c" +#line 2477 "scannerparser.c" break; case 7: /* primary_expression: '(' expression ')' */ @@ -2495,7 +2481,7 @@ { (yyval.symbol) = (yyvsp[-1].symbol); } -#line 2499 "scannerparser.c" +#line 2485 "scannerparser.c" break; case 8: /* strings: STRING */ @@ -2505,7 +2491,7 @@ yytext[strlen (yytext) - 1] = '\0'; (yyval.symbol)->const_string = g_strcompress (yytext + 1); } -#line 2509 "scannerparser.c" +#line 2495 "scannerparser.c" break; case 9: /* strings: strings STRING */ @@ -2520,7 +2506,7 @@ g_free (string2); (yyval.symbol)->const_string = strings; } -#line 2524 "scannerparser.c" +#line 2510 "scannerparser.c" break; case 10: /* identifier: "identifier" */ @@ -2528,7 +2514,7 @@ { (yyval.str) = g_strdup (yytext); } -#line 2532 "scannerparser.c" +#line 2518 "scannerparser.c" break; case 14: /* postfix_expression: postfix_expression '[' expression ']' */ @@ -2536,7 +2522,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2540 "scannerparser.c" +#line 2526 "scannerparser.c" break; case 15: /* postfix_expression: postfix_expression '(' argument_expression_list ')' */ @@ -2544,7 +2530,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2548 "scannerparser.c" +#line 2534 "scannerparser.c" break; case 16: /* postfix_expression: postfix_expression '(' ')' */ @@ -2552,7 +2538,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2556 "scannerparser.c" +#line 2542 "scannerparser.c" break; case 17: /* postfix_expression: postfix_expression '.' identifier_or_typedef_name */ @@ -2560,7 +2546,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2564 "scannerparser.c" +#line 2550 "scannerparser.c" break; case 18: /* postfix_expression: postfix_expression ARROW identifier_or_typedef_name */ @@ -2568,7 +2554,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2572 "scannerparser.c" +#line 2558 "scannerparser.c" break; case 19: /* postfix_expression: postfix_expression PLUSPLUS */ @@ -2576,7 +2562,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2580 "scannerparser.c" +#line 2566 "scannerparser.c" break; case 20: /* postfix_expression: postfix_expression MINUSMINUS */ @@ -2584,7 +2570,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2588 "scannerparser.c" +#line 2574 "scannerparser.c" break; case 24: /* unary_expression: PLUSPLUS unary_expression */ @@ -2592,7 +2578,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2596 "scannerparser.c" +#line 2582 "scannerparser.c" break; case 25: /* unary_expression: MINUSMINUS unary_expression */ @@ -2600,7 +2586,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2604 "scannerparser.c" +#line 2590 "scannerparser.c" break; case 26: /* unary_expression: unary_operator cast_expression */ @@ -2627,7 +2613,7 @@ break; } } -#line 2631 "scannerparser.c" +#line 2617 "scannerparser.c" break; case 27: /* unary_expression: SIZEOF unary_expression */ @@ -2635,7 +2621,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2639 "scannerparser.c" +#line 2625 "scannerparser.c" break; case 28: /* unary_expression: SIZEOF '(' type_name ')' */ @@ -2643,7 +2629,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2647 "scannerparser.c" +#line 2633 "scannerparser.c" break; case 29: /* unary_operator: '&' */ @@ -2651,7 +2637,7 @@ { (yyval.unary_operator) = UNARY_ADDRESS_OF; } -#line 2655 "scannerparser.c" +#line 2641 "scannerparser.c" break; case 30: /* unary_operator: '*' */ @@ -2659,7 +2645,7 @@ { (yyval.unary_operator) = UNARY_POINTER_INDIRECTION; } -#line 2663 "scannerparser.c" +#line 2649 "scannerparser.c" break; case 31: /* unary_operator: '+' */ @@ -2667,7 +2653,7 @@ { (yyval.unary_operator) = UNARY_PLUS; } -#line 2671 "scannerparser.c" +#line 2657 "scannerparser.c" break; case 32: /* unary_operator: '-' */ @@ -2675,7 +2661,7 @@ { (yyval.unary_operator) = UNARY_MINUS; } -#line 2679 "scannerparser.c" +#line 2665 "scannerparser.c" break; case 33: /* unary_operator: '~' */ @@ -2683,7 +2669,7 @@ { (yyval.unary_operator) = UNARY_BITWISE_COMPLEMENT; } -#line 2687 "scannerparser.c" +#line 2673 "scannerparser.c" break; case 34: /* unary_operator: '!' */ @@ -2691,7 +2677,7 @@ { (yyval.unary_operator) = UNARY_LOGICAL_NEGATION; } -#line 2695 "scannerparser.c" +#line 2681 "scannerparser.c" break; case 36: /* cast_expression: '(' type_name ')' cast_expression */ @@ -2699,7 +2685,7 @@ { (yyval.symbol) = (yyvsp[0].symbol); } -#line 2703 "scannerparser.c" +#line 2689 "scannerparser.c" break; case 38: /* multiplicative_expression: multiplicative_expression '*' cast_expression */ @@ -2709,7 +2695,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int * (yyvsp[0].symbol)->const_int; } -#line 2713 "scannerparser.c" +#line 2699 "scannerparser.c" break; case 39: /* multiplicative_expression: multiplicative_expression '/' cast_expression */ @@ -2721,7 +2707,7 @@ (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int / (yyvsp[0].symbol)->const_int; } } -#line 2725 "scannerparser.c" +#line 2711 "scannerparser.c" break; case 40: /* multiplicative_expression: multiplicative_expression '%' cast_expression */ @@ -2731,7 +2717,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int % (yyvsp[0].symbol)->const_int; } -#line 2735 "scannerparser.c" +#line 2721 "scannerparser.c" break; case 42: /* additive_expression: additive_expression '+' multiplicative_expression */ @@ -2741,7 +2727,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int + (yyvsp[0].symbol)->const_int; } -#line 2745 "scannerparser.c" +#line 2731 "scannerparser.c" break; case 43: /* additive_expression: additive_expression '-' multiplicative_expression */ @@ -2751,7 +2737,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int - (yyvsp[0].symbol)->const_int; } -#line 2755 "scannerparser.c" +#line 2741 "scannerparser.c" break; case 45: /* shift_expression: shift_expression SL additive_expression */ @@ -2761,7 +2747,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int << (yyvsp[0].symbol)->const_int; } -#line 2765 "scannerparser.c" +#line 2751 "scannerparser.c" break; case 46: /* shift_expression: shift_expression SR additive_expression */ @@ -2771,7 +2757,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int >> (yyvsp[0].symbol)->const_int; } -#line 2775 "scannerparser.c" +#line 2761 "scannerparser.c" break; case 48: /* relational_expression: relational_expression '<' shift_expression */ @@ -2781,7 +2767,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int < (yyvsp[0].symbol)->const_int; } -#line 2785 "scannerparser.c" +#line 2771 "scannerparser.c" break; case 49: /* relational_expression: relational_expression '>' shift_expression */ @@ -2791,7 +2777,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int > (yyvsp[0].symbol)->const_int; } -#line 2795 "scannerparser.c" +#line 2781 "scannerparser.c" break; case 50: /* relational_expression: relational_expression LTEQ shift_expression */ @@ -2801,7 +2787,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int <= (yyvsp[0].symbol)->const_int; } -#line 2805 "scannerparser.c" +#line 2791 "scannerparser.c" break; case 51: /* relational_expression: relational_expression GTEQ shift_expression */ @@ -2811,7 +2797,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int >= (yyvsp[0].symbol)->const_int; } -#line 2815 "scannerparser.c" +#line 2801 "scannerparser.c" break; case 53: /* equality_expression: equality_expression EQ relational_expression */ @@ -2821,7 +2807,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int == (yyvsp[0].symbol)->const_int; } -#line 2825 "scannerparser.c" +#line 2811 "scannerparser.c" break; case 54: /* equality_expression: equality_expression NOTEQ relational_expression */ @@ -2831,7 +2817,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int != (yyvsp[0].symbol)->const_int; } -#line 2835 "scannerparser.c" +#line 2821 "scannerparser.c" break; case 56: /* and_expression: and_expression '&' equality_expression */ @@ -2841,7 +2827,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int & (yyvsp[0].symbol)->const_int; } -#line 2845 "scannerparser.c" +#line 2831 "scannerparser.c" break; case 58: /* exclusive_or_expression: exclusive_or_expression '^' and_expression */ @@ -2851,7 +2837,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int ^ (yyvsp[0].symbol)->const_int; } -#line 2855 "scannerparser.c" +#line 2841 "scannerparser.c" break; case 60: /* inclusive_or_expression: inclusive_or_expression '|' exclusive_or_expression */ @@ -2861,7 +2847,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = (yyvsp[-2].symbol)->const_int | (yyvsp[0].symbol)->const_int; } -#line 2865 "scannerparser.c" +#line 2851 "scannerparser.c" break; case 62: /* logical_and_expression: logical_and_expression ANDAND inclusive_or_expression */ @@ -2871,7 +2857,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = csymbol_get_const_boolean ((yyvsp[-2].symbol)) && csymbol_get_const_boolean ((yyvsp[0].symbol)); } -#line 2875 "scannerparser.c" +#line 2861 "scannerparser.c" break; case 64: /* logical_or_expression: logical_or_expression OROR logical_and_expression */ @@ -2881,7 +2867,7 @@ (yyval.symbol)->const_int_set = TRUE; (yyval.symbol)->const_int = csymbol_get_const_boolean ((yyvsp[-2].symbol)) || csymbol_get_const_boolean ((yyvsp[0].symbol)); } -#line 2885 "scannerparser.c" +#line 2871 "scannerparser.c" break; case 66: /* conditional_expression: logical_or_expression '?' expression ':' conditional_expression */ @@ -2889,7 +2875,7 @@ { (yyval.symbol) = csymbol_get_const_boolean ((yyvsp[-4].symbol)) ? (yyvsp[-2].symbol) : (yyvsp[0].symbol); } -#line 2893 "scannerparser.c" +#line 2879 "scannerparser.c" break; case 68: /* assignment_expression: unary_expression assignment_operator assignment_expression */ @@ -2897,7 +2883,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2901 "scannerparser.c" +#line 2887 "scannerparser.c" break; case 81: /* expression: expression ',' assignment_expression */ @@ -2905,7 +2891,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 2909 "scannerparser.c" +#line 2895 "scannerparser.c" break; case 83: /* declaration: declaration_specifiers init_declarator_list ';' */ @@ -2925,7 +2911,7 @@ g_igenerator_add_symbol (igenerator, sym); } } -#line 2929 "scannerparser.c" +#line 2915 "scannerparser.c" break; case 85: /* declaration_specifiers: storage_class_specifier declaration_specifiers */ @@ -2934,7 +2920,7 @@ (yyval.ctype) = (yyvsp[0].ctype); (yyval.ctype)->storage_class_specifier |= (yyvsp[-1].storage_class_specifier); } -#line 2938 "scannerparser.c" +#line 2924 "scannerparser.c" break; case 86: /* declaration_specifiers: storage_class_specifier */ @@ -2943,7 +2929,7 @@ (yyval.ctype) = ctype_new (CTYPE_INVALID); (yyval.ctype)->storage_class_specifier |= (yyvsp[0].storage_class_specifier); } -#line 2947 "scannerparser.c" +#line 2933 "scannerparser.c" break; case 87: /* declaration_specifiers: type_specifier declaration_specifiers */ @@ -2952,7 +2938,7 @@ (yyval.ctype) = (yyvsp[-1].ctype); (yyval.ctype)->base_type = (yyvsp[0].ctype); } -#line 2956 "scannerparser.c" +#line 2942 "scannerparser.c" break; case 89: /* declaration_specifiers: type_qualifier declaration_specifiers */ @@ -2961,7 +2947,7 @@ (yyval.ctype) = (yyvsp[0].ctype); (yyval.ctype)->type_qualifier |= (yyvsp[-1].type_qualifier); } -#line 2965 "scannerparser.c" +#line 2951 "scannerparser.c" break; case 90: /* declaration_specifiers: type_qualifier */ @@ -2970,7 +2956,7 @@ (yyval.ctype) = ctype_new (CTYPE_INVALID); (yyval.ctype)->type_qualifier |= (yyvsp[0].type_qualifier); } -#line 2974 "scannerparser.c" +#line 2960 "scannerparser.c" break; case 91: /* declaration_specifiers: function_specifier declaration_specifiers */ @@ -2979,7 +2965,7 @@ (yyval.ctype) = (yyvsp[0].ctype); (yyval.ctype)->function_specifier |= (yyvsp[-1].function_specifier); } -#line 2983 "scannerparser.c" +#line 2969 "scannerparser.c" break; case 92: /* declaration_specifiers: function_specifier */ @@ -2988,7 +2974,7 @@ (yyval.ctype) = ctype_new (CTYPE_INVALID); (yyval.ctype)->function_specifier |= (yyvsp[0].function_specifier); } -#line 2992 "scannerparser.c" +#line 2978 "scannerparser.c" break; case 93: /* init_declarator_list: init_declarator */ @@ -2996,7 +2982,7 @@ { (yyval.list) = g_list_append (NULL, (yyvsp[0].symbol)); } -#line 3000 "scannerparser.c" +#line 2986 "scannerparser.c" break; case 94: /* init_declarator_list: init_declarator_list ',' init_declarator */ @@ -3004,7 +2990,7 @@ { (yyval.list) = g_list_append ((yyvsp[-2].list), (yyvsp[0].symbol)); } -#line 3008 "scannerparser.c" +#line 2994 "scannerparser.c" break; case 97: /* storage_class_specifier: TYPEDEF */ @@ -3012,7 +2998,7 @@ { (yyval.storage_class_specifier) = STORAGE_CLASS_TYPEDEF; } -#line 3016 "scannerparser.c" +#line 3002 "scannerparser.c" break; case 98: /* storage_class_specifier: EXTERN */ @@ -3020,7 +3006,7 @@ { (yyval.storage_class_specifier) = STORAGE_CLASS_EXTERN; } -#line 3024 "scannerparser.c" +#line 3010 "scannerparser.c" break; case 99: /* storage_class_specifier: STATIC */ @@ -3028,7 +3014,7 @@ { (yyval.storage_class_specifier) = STORAGE_CLASS_STATIC; } -#line 3032 "scannerparser.c" +#line 3018 "scannerparser.c" break; case 100: /* storage_class_specifier: AUTO */ @@ -3036,7 +3022,7 @@ { (yyval.storage_class_specifier) = STORAGE_CLASS_AUTO; } -#line 3040 "scannerparser.c" +#line 3026 "scannerparser.c" break; case 101: /* storage_class_specifier: REGISTER */ @@ -3044,7 +3030,7 @@ { (yyval.storage_class_specifier) = STORAGE_CLASS_REGISTER; } -#line 3048 "scannerparser.c" +#line 3034 "scannerparser.c" break; case 102: /* type_specifier: VOID */ @@ -3052,7 +3038,7 @@ { (yyval.ctype) = ctype_new (CTYPE_VOID); } -#line 3056 "scannerparser.c" +#line 3042 "scannerparser.c" break; case 103: /* type_specifier: CHAR */ @@ -3060,7 +3046,7 @@ { (yyval.ctype) = cbasic_type_new ("char"); } -#line 3064 "scannerparser.c" +#line 3050 "scannerparser.c" break; case 104: /* type_specifier: SHORT */ @@ -3068,7 +3054,7 @@ { (yyval.ctype) = cbasic_type_new ("short"); } -#line 3072 "scannerparser.c" +#line 3058 "scannerparser.c" break; case 105: /* type_specifier: INT */ @@ -3076,7 +3062,7 @@ { (yyval.ctype) = cbasic_type_new ("int"); } -#line 3080 "scannerparser.c" +#line 3066 "scannerparser.c" break; case 106: /* type_specifier: LONG */ @@ -3084,7 +3070,7 @@ { (yyval.ctype) = cbasic_type_new ("long"); } -#line 3088 "scannerparser.c" +#line 3074 "scannerparser.c" break; case 107: /* type_specifier: FLOAT */ @@ -3092,7 +3078,7 @@ { (yyval.ctype) = cbasic_type_new ("float"); } -#line 3096 "scannerparser.c" +#line 3082 "scannerparser.c" break; case 108: /* type_specifier: DOUBLE */ @@ -3100,7 +3086,7 @@ { (yyval.ctype) = cbasic_type_new ("double"); } -#line 3104 "scannerparser.c" +#line 3090 "scannerparser.c" break; case 109: /* type_specifier: SIGNED */ @@ -3108,7 +3094,7 @@ { (yyval.ctype) = cbasic_type_new ("signed"); } -#line 3112 "scannerparser.c" +#line 3098 "scannerparser.c" break; case 110: /* type_specifier: UNSIGNED */ @@ -3116,7 +3102,7 @@ { (yyval.ctype) = cbasic_type_new ("unsigned"); } -#line 3120 "scannerparser.c" +#line 3106 "scannerparser.c" break; case 111: /* type_specifier: BOOL */ @@ -3124,7 +3110,7 @@ { (yyval.ctype) = cbasic_type_new ("bool"); } -#line 3128 "scannerparser.c" +#line 3114 "scannerparser.c" break; case 114: /* type_specifier: typedef_name */ @@ -3132,7 +3118,7 @@ { (yyval.ctype) = ctypedef_new ((yyvsp[0].str)); } -#line 3136 "scannerparser.c" +#line 3122 "scannerparser.c" break; case 115: /* struct_or_union_specifier: struct_or_union identifier_or_typedef_name '{' struct_declaration_list '}' */ @@ -3156,7 +3142,7 @@ sym->base_type = ctype_copy ((yyval.ctype)); g_igenerator_add_symbol (igenerator, sym); } -#line 3160 "scannerparser.c" +#line 3146 "scannerparser.c" break; case 116: /* struct_or_union_specifier: struct_or_union '{' struct_declaration_list '}' */ @@ -3165,7 +3151,7 @@ (yyval.ctype) = (yyvsp[-3].ctype); (yyval.ctype)->child_list = (yyvsp[-1].list); } -#line 3169 "scannerparser.c" +#line 3155 "scannerparser.c" break; case 117: /* struct_or_union_specifier: struct_or_union identifier_or_typedef_name */ @@ -3174,7 +3160,7 @@ (yyval.ctype) = (yyvsp[-1].ctype); (yyval.ctype)->name = (yyvsp[0].str); } -#line 3178 "scannerparser.c" +#line 3164 "scannerparser.c" break; case 118: /* struct_or_union: STRUCT */ @@ -3182,7 +3168,7 @@ { (yyval.ctype) = cstruct_new (NULL); } -#line 3186 "scannerparser.c" +#line 3172 "scannerparser.c" break; case 119: /* struct_or_union: UNION */ @@ -3190,7 +3176,7 @@ { (yyval.ctype) = cunion_new (NULL); } -#line 3194 "scannerparser.c" +#line 3180 "scannerparser.c" break; case 121: /* struct_declaration_list: struct_declaration_list struct_declaration */ @@ -3198,7 +3184,7 @@ { (yyval.list) = g_list_concat ((yyvsp[-1].list), (yyvsp[0].list)); } -#line 3202 "scannerparser.c" +#line 3188 "scannerparser.c" break; case 122: /* struct_declaration: specifier_qualifier_list struct_declarator_list ';' */ @@ -3215,7 +3201,7 @@ (yyval.list) = g_list_append ((yyval.list), sym); } } -#line 3219 "scannerparser.c" +#line 3205 "scannerparser.c" break; case 123: /* specifier_qualifier_list: type_specifier specifier_qualifier_list */ @@ -3224,7 +3210,7 @@ (yyval.ctype) = (yyvsp[-1].ctype); (yyval.ctype)->base_type = (yyvsp[0].ctype); } -#line 3228 "scannerparser.c" +#line 3214 "scannerparser.c" break; case 125: /* specifier_qualifier_list: type_qualifier specifier_qualifier_list */ @@ -3233,7 +3219,7 @@ (yyval.ctype) = (yyvsp[0].ctype); (yyval.ctype)->type_qualifier |= (yyvsp[-1].type_qualifier); } -#line 3237 "scannerparser.c" +#line 3223 "scannerparser.c" break; case 126: /* specifier_qualifier_list: type_qualifier */ @@ -3242,7 +3228,7 @@ (yyval.ctype) = ctype_new (CTYPE_INVALID); (yyval.ctype)->type_qualifier |= (yyvsp[0].type_qualifier); } -#line 3246 "scannerparser.c" +#line 3232 "scannerparser.c" break; case 127: /* struct_declarator_list: struct_declarator */ @@ -3250,7 +3236,7 @@ { (yyval.list) = g_list_append (NULL, (yyvsp[0].symbol)); } -#line 3254 "scannerparser.c" +#line 3240 "scannerparser.c" break; case 128: /* struct_declarator_list: struct_declarator_list ',' struct_declarator */ @@ -3258,7 +3244,7 @@ { (yyval.list) = g_list_append ((yyvsp[-2].list), (yyvsp[0].symbol)); } -#line 3262 "scannerparser.c" +#line 3248 "scannerparser.c" break; case 129: /* struct_declarator: %empty */ @@ -3266,7 +3252,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 3270 "scannerparser.c" +#line 3256 "scannerparser.c" break; case 131: /* struct_declarator: ':' constant_expression */ @@ -3274,7 +3260,7 @@ { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); } -#line 3278 "scannerparser.c" +#line 3264 "scannerparser.c" break; case 133: /* enum_specifier: ENUM identifier_or_typedef_name '{' enumerator_list '}' */ @@ -3284,7 +3270,7 @@ (yyval.ctype)->child_list = (yyvsp[-1].list); last_enum_value = -1; } -#line 3288 "scannerparser.c" +#line 3274 "scannerparser.c" break; case 134: /* enum_specifier: ENUM '{' enumerator_list '}' */ @@ -3294,7 +3280,7 @@ (yyval.ctype)->child_list = (yyvsp[-1].list); last_enum_value = -1; } -#line 3298 "scannerparser.c" +#line 3284 "scannerparser.c" break; case 135: /* enum_specifier: ENUM identifier_or_typedef_name '{' enumerator_list ',' '}' */ @@ -3304,7 +3290,7 @@ (yyval.ctype)->child_list = (yyvsp[-2].list); last_enum_value = -1; } -#line 3308 "scannerparser.c" +#line 3294 "scannerparser.c" break; case 136: /* enum_specifier: ENUM '{' enumerator_list ',' '}' */ @@ -3314,7 +3300,7 @@ (yyval.ctype)->child_list = (yyvsp[-2].list); last_enum_value = -1; } -#line 3318 "scannerparser.c" +#line 3304 "scannerparser.c" break; case 137: /* enum_specifier: ENUM identifier_or_typedef_name */ @@ -3322,7 +3308,7 @@ { (yyval.ctype) = cenum_new ((yyvsp[0].str)); } -#line 3326 "scannerparser.c" +#line 3312 "scannerparser.c" break; case 138: /* enumerator_list: enumerator */ @@ -3330,7 +3316,7 @@ { (yyval.list) = g_list_append (NULL, (yyvsp[0].symbol)); } -#line 3334 "scannerparser.c" +#line 3320 "scannerparser.c" break; case 139: /* enumerator_list: enumerator_list ',' enumerator */ @@ -3338,7 +3324,7 @@ { (yyval.list) = g_list_append ((yyvsp[-2].list), (yyvsp[0].symbol)); } -#line 3342 "scannerparser.c" +#line 3328 "scannerparser.c" break; case 140: /* enumerator: identifier */ @@ -3350,7 +3336,7 @@ (yyval.symbol)->const_int = ++last_enum_value; g_hash_table_insert (const_table, g_strdup ((yyval.symbol)->ident), (yyval.symbol)); } -#line 3354 "scannerparser.c" +#line 3340 "scannerparser.c" break; case 141: /* enumerator: identifier '=' constant_expression */ @@ -3363,7 +3349,7 @@ last_enum_value = (yyval.symbol)->const_int; g_hash_table_insert (const_table, g_strdup ((yyval.symbol)->ident), (yyval.symbol)); } -#line 3367 "scannerparser.c" +#line 3353 "scannerparser.c" break; case 142: /* type_qualifier: CONST */ @@ -3371,7 +3357,7 @@ { (yyval.type_qualifier) = TYPE_QUALIFIER_CONST; } -#line 3375 "scannerparser.c" +#line 3361 "scannerparser.c" break; case 143: /* type_qualifier: RESTRICT */ @@ -3379,7 +3365,7 @@ { (yyval.type_qualifier) = TYPE_QUALIFIER_RESTRICT; } -#line 3383 "scannerparser.c" +#line 3369 "scannerparser.c" break; case 144: /* type_qualifier: VOLATILE */ @@ -3387,7 +3373,7 @@ { (yyval.type_qualifier) = TYPE_QUALIFIER_VOLATILE; } -#line 3391 "scannerparser.c" +#line 3377 "scannerparser.c" break; case 145: /* function_specifier: INLINE */ @@ -3395,7 +3381,7 @@ { (yyval.function_specifier) = FUNCTION_INLINE; } -#line 3399 "scannerparser.c" +#line 3385 "scannerparser.c" break; case 146: /* declarator: pointer direct_declarator */ @@ -3404,7 +3390,7 @@ (yyval.symbol) = (yyvsp[0].symbol); csymbol_merge_type ((yyval.symbol), (yyvsp[-1].ctype)); } -#line 3408 "scannerparser.c" +#line 3394 "scannerparser.c" break; case 148: /* direct_declarator: identifier */ @@ -3413,7 +3399,7 @@ (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); (yyval.symbol)->ident = (yyvsp[0].str); } -#line 3417 "scannerparser.c" +#line 3403 "scannerparser.c" break; case 149: /* direct_declarator: '(' declarator ')' */ @@ -3421,7 +3407,7 @@ { (yyval.symbol) = (yyvsp[-1].symbol); } -#line 3425 "scannerparser.c" +#line 3411 "scannerparser.c" break; case 150: /* direct_declarator: direct_declarator '[' assignment_expression ']' */ @@ -3430,7 +3416,7 @@ (yyval.symbol) = (yyvsp[-3].symbol); csymbol_merge_type ((yyval.symbol), carray_new ()); } -#line 3434 "scannerparser.c" +#line 3420 "scannerparser.c" break; case 151: /* direct_declarator: direct_declarator '[' ']' */ @@ -3439,7 +3425,7 @@ (yyval.symbol) = (yyvsp[-2].symbol); csymbol_merge_type ((yyval.symbol), carray_new ()); } -#line 3443 "scannerparser.c" +#line 3429 "scannerparser.c" break; case 152: /* direct_declarator: direct_declarator '(' parameter_type_list ')' */ @@ -3453,7 +3439,7 @@ (yyval.symbol) = (yyvsp[-3].symbol); csymbol_merge_type ((yyval.symbol), func); } -#line 3457 "scannerparser.c" +#line 3443 "scannerparser.c" break; case 153: /* direct_declarator: direct_declarator '(' identifier_list ')' */ @@ -3464,7 +3450,7 @@ (yyval.symbol) = (yyvsp[-3].symbol); csymbol_merge_type ((yyval.symbol), func); } -#line 3468 "scannerparser.c" +#line 3454 "scannerparser.c" break; case 154: /* direct_declarator: direct_declarator '(' ')' */ @@ -3474,7 +3460,7 @@ (yyval.symbol) = (yyvsp[-2].symbol); csymbol_merge_type ((yyval.symbol), func); } -#line 3478 "scannerparser.c" +#line 3464 "scannerparser.c" break; case 155: /* pointer: '*' type_qualifier_list */ @@ -3483,7 +3469,7 @@ (yyval.ctype) = cpointer_new (NULL); (yyval.ctype)->type_qualifier = (yyvsp[0].type_qualifier); } -#line 3487 "scannerparser.c" +#line 3473 "scannerparser.c" break; case 156: /* pointer: '*' */ @@ -3491,7 +3477,7 @@ { (yyval.ctype) = cpointer_new (NULL); } -#line 3495 "scannerparser.c" +#line 3481 "scannerparser.c" break; case 157: /* pointer: '*' type_qualifier_list pointer */ @@ -3500,7 +3486,7 @@ (yyval.ctype) = cpointer_new ((yyvsp[0].ctype)); (yyval.ctype)->type_qualifier = (yyvsp[-1].type_qualifier); } -#line 3504 "scannerparser.c" +#line 3490 "scannerparser.c" break; case 158: /* pointer: '*' pointer */ @@ -3508,7 +3494,7 @@ { (yyval.ctype) = cpointer_new ((yyvsp[0].ctype)); } -#line 3512 "scannerparser.c" +#line 3498 "scannerparser.c" break; case 160: /* type_qualifier_list: type_qualifier_list type_qualifier */ @@ -3516,7 +3502,7 @@ { (yyval.type_qualifier) = (yyvsp[-1].type_qualifier) | (yyvsp[0].type_qualifier); } -#line 3520 "scannerparser.c" +#line 3506 "scannerparser.c" break; case 163: /* parameter_list: parameter_declaration */ @@ -3524,7 +3510,7 @@ { (yyval.list) = g_list_append (NULL, (yyvsp[0].symbol)); } -#line 3528 "scannerparser.c" +#line 3514 "scannerparser.c" break; case 164: /* parameter_list: parameter_list ',' parameter_declaration */ @@ -3532,7 +3518,7 @@ { (yyval.list) = g_list_append ((yyvsp[-2].list), (yyvsp[0].symbol)); } -#line 3536 "scannerparser.c" +#line 3522 "scannerparser.c" break; case 165: /* parameter_declaration: declaration_specifiers declarator */ @@ -3541,7 +3527,7 @@ (yyval.symbol) = (yyvsp[0].symbol); csymbol_merge_type ((yyval.symbol), (yyvsp[-1].ctype)); } -#line 3545 "scannerparser.c" +#line 3531 "scannerparser.c" break; case 166: /* parameter_declaration: declaration_specifiers abstract_declarator */ @@ -3550,7 +3536,7 @@ (yyval.symbol) = (yyvsp[0].symbol); csymbol_merge_type ((yyval.symbol), (yyvsp[-1].ctype)); } -#line 3554 "scannerparser.c" +#line 3540 "scannerparser.c" break; case 167: /* parameter_declaration: declaration_specifiers */ @@ -3559,7 +3545,7 @@ (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); (yyval.symbol)->base_type = (yyvsp[0].ctype); } -#line 3563 "scannerparser.c" +#line 3549 "scannerparser.c" break; case 168: /* identifier_list: identifier */ @@ -3569,7 +3555,7 @@ sym->ident = (yyvsp[0].str); (yyval.list) = g_list_append (NULL, sym); } -#line 3573 "scannerparser.c" +#line 3559 "scannerparser.c" break; case 169: /* identifier_list: identifier_list ',' identifier */ @@ -3579,7 +3565,7 @@ sym->ident = (yyvsp[0].str); (yyval.list) = g_list_append ((yyvsp[-2].list), sym); } -#line 3583 "scannerparser.c" +#line 3569 "scannerparser.c" break; case 172: /* abstract_declarator: pointer */ @@ -3588,7 +3574,7 @@ (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); csymbol_merge_type ((yyval.symbol), (yyvsp[0].ctype)); } -#line 3592 "scannerparser.c" +#line 3578 "scannerparser.c" break; case 174: /* abstract_declarator: pointer direct_abstract_declarator */ @@ -3597,7 +3583,7 @@ (yyval.symbol) = (yyvsp[0].symbol); csymbol_merge_type ((yyval.symbol), (yyvsp[-1].ctype)); } -#line 3601 "scannerparser.c" +#line 3587 "scannerparser.c" break; case 175: /* direct_abstract_declarator: '(' abstract_declarator ')' */ @@ -3605,7 +3591,7 @@ { (yyval.symbol) = (yyvsp[-1].symbol); } -#line 3609 "scannerparser.c" +#line 3595 "scannerparser.c" break; case 176: /* direct_abstract_declarator: '[' ']' */ @@ -3614,7 +3600,7 @@ (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); csymbol_merge_type ((yyval.symbol), carray_new ()); } -#line 3618 "scannerparser.c" +#line 3604 "scannerparser.c" break; case 177: /* direct_abstract_declarator: '[' assignment_expression ']' */ @@ -3623,7 +3609,7 @@ (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); csymbol_merge_type ((yyval.symbol), carray_new ()); } -#line 3627 "scannerparser.c" +#line 3613 "scannerparser.c" break; case 178: /* direct_abstract_declarator: direct_abstract_declarator '[' ']' */ @@ -3632,7 +3618,7 @@ (yyval.symbol) = (yyvsp[-2].symbol); csymbol_merge_type ((yyval.symbol), carray_new ()); } -#line 3636 "scannerparser.c" +#line 3622 "scannerparser.c" break; case 179: /* direct_abstract_declarator: direct_abstract_declarator '[' assignment_expression ']' */ @@ -3641,7 +3627,7 @@ (yyval.symbol) = (yyvsp[-3].symbol); csymbol_merge_type ((yyval.symbol), carray_new ()); } -#line 3645 "scannerparser.c" +#line 3631 "scannerparser.c" break; case 180: /* direct_abstract_declarator: '(' ')' */ @@ -3651,7 +3637,7 @@ (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); csymbol_merge_type ((yyval.symbol), func); } -#line 3655 "scannerparser.c" +#line 3641 "scannerparser.c" break; case 181: /* direct_abstract_declarator: '(' parameter_type_list ')' */ @@ -3665,7 +3651,7 @@ (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); csymbol_merge_type ((yyval.symbol), func); } -#line 3669 "scannerparser.c" +#line 3655 "scannerparser.c" break; case 182: /* direct_abstract_declarator: direct_abstract_declarator '(' ')' */ @@ -3675,7 +3661,7 @@ (yyval.symbol) = (yyvsp[-2].symbol); csymbol_merge_type ((yyval.symbol), func); } -#line 3679 "scannerparser.c" +#line 3665 "scannerparser.c" break; case 183: /* direct_abstract_declarator: direct_abstract_declarator '(' parameter_type_list ')' */ @@ -3689,7 +3675,7 @@ (yyval.symbol) = (yyvsp[-3].symbol); csymbol_merge_type ((yyval.symbol), func); } -#line 3693 "scannerparser.c" +#line 3679 "scannerparser.c" break; case 184: /* typedef_name: "typedef-name" */ @@ -3697,7 +3683,7 @@ { (yyval.str) = g_strdup (yytext); } -#line 3701 "scannerparser.c" +#line 3687 "scannerparser.c" break; case 234: /* function_macro: FUNCTION_MACRO */ @@ -3705,7 +3691,7 @@ { (yyval.str) = g_strdup (yytext + strlen ("#define ")); } -#line 3709 "scannerparser.c" +#line 3695 "scannerparser.c" break; case 235: /* object_macro: OBJECT_MACRO */ @@ -3713,7 +3699,7 @@ { (yyval.str) = g_strdup (yytext + strlen ("#define ")); } -#line 3717 "scannerparser.c" +#line 3703 "scannerparser.c" break; case 237: /* object_macro_define: object_macro constant_expression */ @@ -3724,11 +3710,11 @@ g_igenerator_add_symbol (igenerator, (yyvsp[0].symbol)); } } -#line 3728 "scannerparser.c" +#line 3714 "scannerparser.c" break; -#line 3732 "scannerparser.c" +#line 3718 "scannerparser.c" default: break; } @@ -3804,7 +3790,7 @@ } yyerror (igenerator, yymsgp); if (yysyntax_error_status == YYENOMEM) - goto yyexhaustedlab; + YYNOMEM; } } @@ -3840,6 +3826,7 @@ label yyerrorlab therefore never appears in user code. */ if (0) YYERROR; + ++yynerrs; /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ @@ -3900,7 +3887,7 @@ `-------------------------------------*/ yyacceptlab: yyresult = 0; - goto yyreturn; + goto yyreturnlab; /*-----------------------------------. @@ -3908,24 +3895,22 @@ `-----------------------------------*/ yyabortlab: yyresult = 1; - goto yyreturn; + goto yyreturnlab; -#if 1 -/*-------------------------------------------------. -| yyexhaustedlab -- memory exhaustion comes here. | -`-------------------------------------------------*/ +/*-----------------------------------------------------------. +| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | +`-----------------------------------------------------------*/ yyexhaustedlab: yyerror (igenerator, YY_("memory exhausted")); yyresult = 2; - goto yyreturn; -#endif + goto yyreturnlab; -/*-------------------------------------------------------. -| yyreturn -- parsing is finished, clean up and return. | -`-------------------------------------------------------*/ -yyreturn: +/*----------------------------------------------------------. +| yyreturnlab -- parsing is finished, clean up and return. | +`----------------------------------------------------------*/ +yyreturnlab: if (yychar != YYEMPTY) { /* Make sure we have latest lookahead translation. See comments at diff -Nru vala-0.52.6/gobject-introspection/scannerparser.h vala-0.52.7/gobject-introspection/scannerparser.h --- vala-0.52.6/gobject-introspection/scannerparser.h 2021-10-04 09:47:35.000000000 +0000 +++ vala-0.52.7/gobject-introspection/scannerparser.h 2021-10-30 08:24:48.000000000 +0000 @@ -1,4 +1,4 @@ -/* A Bison parser, made by GNU Bison 3.7.6. */ +/* A Bison parser, made by GNU Bison 3.8.2. */ /* Bison interface for Yacc-like parsers in C @@ -219,6 +219,8 @@ extern YYSTYPE yylval; + int yyparse (GIGenerator* igenerator); + #endif /* !YY_YY_SCANNERPARSER_H_INCLUDED */ diff -Nru vala-0.52.6/libvaladoc/Makefile.in vala-0.52.7/libvaladoc/Makefile.in --- vala-0.52.6/libvaladoc/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/libvaladoc/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/Makefile.in vala-0.52.7/Makefile.in --- vala-0.52.6/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/NEWS vala-0.52.7/NEWS --- vala-0.52.6/NEWS 2021-10-04 09:41:39.000000000 +0000 +++ vala-0.52.7/NEWS 2021-10-30 08:20:09.000000000 +0000 @@ -1,3 +1,19 @@ +Vala 0.52.7 +=========== + * Various improvements and bug fixes: + - codegen: Actually free data when using "remove(_all)" + on GLib.Queue/(S)List [#1238] + - vala: + + Parameter following ellipsis parameter is not allowed [#1237] + + More thorough check of ValueType and set CodeNode.error on failure + + Really check compatiblity of error types for delegate symbol + + Correctly output signature of callable throwing error + + Report error for non ErrorType in throws + + Implement CodeWriter.visit_foreach_statement()/visit_catch_clause() + - parser: Make sure ErrorCodes are accessible as needed + - girparser: Add support for "ref_/ref_sink_/unref_function" + metadata for classes [#1233] + Vala 0.52.6 =========== * Various improvements and bug fixes: diff -Nru vala-0.52.6/.tarball-version vala-0.52.7/.tarball-version --- vala-0.52.6/.tarball-version 2021-10-04 09:48:40.000000000 +0000 +++ vala-0.52.7/.tarball-version 2021-10-30 08:25:30.000000000 +0000 @@ -1 +1 @@ -0.52.6 +0.52.7 diff -Nru vala-0.52.6/tests/basic-types/glists_remove.vala vala-0.52.7/tests/basic-types/glists_remove.vala --- vala-0.52.6/tests/basic-types/glists_remove.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/basic-types/glists_remove.vala 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,113 @@ +class Foo : Object { +} + +void test_glist () { + { + var list = new GLib.List (); + var foo = new Foo (); + list.append (foo); + assert (list.length () == 1); + assert (foo.ref_count == 2); + list.remove (foo); + assert (list.length () == 0); + assert (foo.ref_count == 1); + } + { + var list = new GLib.List (); + var foo = new Foo (); + list.append (foo); + list.append (foo); + assert (list.length () == 2); + assert (foo.ref_count == 3); + list.remove_all (foo); + assert (list.length () == 0); + assert (foo.ref_count == 1); + } + { + var list = new GLib.List (); + unowned var s = "foo"; + list.append (s); + assert (list.length () == 1); + list.remove (s); + assert (list.length () == 0); + list.append (s); + list.remove_all (s); + assert (list.length () == 0); + } +} + +void test_gslist () { + { + var list = new GLib.SList (); + var foo = new Foo (); + list.append (foo); + assert (list.length () == 1); + assert (foo.ref_count == 2); + list.remove (foo); + assert (list.length () == 0); + assert (foo.ref_count == 1); + } + { + var list = new GLib.SList (); + var foo = new Foo (); + list.append (foo); + list.append (foo); + assert (list.length () == 2); + assert (foo.ref_count == 3); + list.remove_all (foo); + assert (list.length () == 0); + assert (foo.ref_count == 1); + } + { + var list = new GLib.SList (); + unowned var s = "foo"; + list.append (s); + assert (list.length () == 1); + list.remove (s); + assert (list.length () == 0); + list.append (s); + list.remove_all (s); + assert (list.length () == 0); + } +} + +void test_gqueue () { + { + var queue = new GLib.Queue (); + var foo = new Foo (); + queue.push_head (foo); + assert (queue.length == 1); + assert (foo.ref_count == 2); + queue.remove (foo); + assert (queue.length == 0); + assert (foo.ref_count == 1); + } + { + var queue = new GLib.Queue (); + var foo = new Foo (); + queue.push_head (foo); + queue.push_head (foo); + assert (queue.length == 2); + assert (foo.ref_count == 3); + queue.remove_all (foo); + assert (queue.length == 0); + assert (foo.ref_count == 1); + } + { + var queue = new GLib.Queue (); + unowned var s = "foo"; + queue.push_head (s); + assert (queue.length == 1); + queue.remove (s); + assert (queue.length == 0); + queue.push_head (s); + queue.remove_all (s); + assert (queue.length == 0); + } +} + +void main () { + test_glist (); + test_gslist (); + test_gqueue (); +} diff -Nru vala-0.52.6/tests/basic-types/gvariants-hashtable-deserialize-missing-type-arguments.test vala-0.52.7/tests/basic-types/gvariants-hashtable-deserialize-missing-type-arguments.test --- vala-0.52.6/tests/basic-types/gvariants-hashtable-deserialize-missing-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/basic-types/gvariants-hashtable-deserialize-missing-type-arguments.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,6 @@ +Invalid Code + +void main () { + Variant v = null; + var foo = (HashTable) v; +} diff -Nru vala-0.52.6/tests/basic-types/gvariants-hashtable-missing-type-arguments.test vala-0.52.7/tests/basic-types/gvariants-hashtable-missing-type-arguments.test --- vala-0.52.6/tests/basic-types/gvariants-hashtable-missing-type-arguments.test 2021-09-30 15:37:07.000000000 +0000 +++ vala-0.52.7/tests/basic-types/gvariants-hashtable-missing-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 @@ -1,12 +0,0 @@ -Invalid Code - -void main () { - { - HashTable foo = null; - Variant v = foo; - } - { - Variant v = null; - var foo = (HashTable) v; - } -} diff -Nru vala-0.52.6/tests/basic-types/gvariants-hashtable-serialize-missing-type-arguments.test vala-0.52.7/tests/basic-types/gvariants-hashtable-serialize-missing-type-arguments.test --- vala-0.52.6/tests/basic-types/gvariants-hashtable-serialize-missing-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/basic-types/gvariants-hashtable-serialize-missing-type-arguments.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,6 @@ +Invalid Code + +void main () { + HashTable foo = null; + Variant v = foo; +} diff -Nru vala-0.52.6/tests/chainup/base-struct-invalid.test vala-0.52.7/tests/chainup/base-struct-invalid.test --- vala-0.52.6/tests/chainup/base-struct-invalid.test 2021-04-19 18:42:41.000000000 +0000 +++ vala-0.52.7/tests/chainup/base-struct-invalid.test 2021-10-26 12:38:24.000000000 +0000 @@ -1,6 +1,8 @@ Invalid Code struct Foo { + public int i; + public Foo () { base (); } diff -Nru vala-0.52.6/tests/delegates/incompatible-error-argument-2.test vala-0.52.7/tests/delegates/incompatible-error-argument-2.test --- vala-0.52.6/tests/delegates/incompatible-error-argument-2.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/delegates/incompatible-error-argument-2.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,22 @@ +Invalid Code + +errordomain FooError { + FAIL; +} + +errordomain BarError { + FAIL; +} + +delegate void FooFunc () throws FooError; + +void bar () throws BarError { + throw new BarError.FAIL (""); +} + +void foo (FooFunc f) { +} + +void main () { + foo (bar); +} diff -Nru vala-0.52.6/tests/delegates/incompatible-error-argument.test vala-0.52.7/tests/delegates/incompatible-error-argument.test --- vala-0.52.6/tests/delegates/incompatible-error-argument.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/delegates/incompatible-error-argument.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,21 @@ +Invalid Code + +errordomain FooError { + FAIL; +} + +errordomain BarError { + FAIL; +} + +delegate void FooFunc () throws FooError; + +delegate void BarFunc () throws BarError; + +void foo (FooFunc f) { +} + +void main () { + BarFunc bar = () => { throw new BarError.FAIL (""); }; + foo (bar); +} diff -Nru vala-0.52.6/tests/delegates/incompatible-error-assignment.test vala-0.52.7/tests/delegates/incompatible-error-assignment.test --- vala-0.52.6/tests/delegates/incompatible-error-assignment.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/delegates/incompatible-error-assignment.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,18 @@ +Invalid Code + +errordomain FooError { + FAIL; +} + +errordomain BarError { + FAIL; +} + +delegate void FooFunc () throws FooError; + +delegate void BarFunc () throws BarError; + +void main () { + FooFunc f = () => { throw new FooError.FAIL (""); }; + BarFunc b = f; +} diff -Nru vala-0.52.6/tests/delegates/lambda-outer-constant.test vala-0.52.7/tests/delegates/lambda-outer-constant.test --- vala-0.52.6/tests/delegates/lambda-outer-constant.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/delegates/lambda-outer-constant.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,11 @@ +Invalid Code + +delegate void FooFunc (); + +void main () { + const int FOO = 23; + + FooFunc foo = () => { + var i = FOO; + }; +} diff -Nru vala-0.52.6/tests/enums/bug614424.vala vala-0.52.7/tests/enums/bug614424.vala --- vala-0.52.6/tests/enums/bug614424.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/enums/bug614424.vala 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,11 @@ +enum Foo { + BAR; + + public string bar () { + return to_string (); + } +} + +void main () { + assert (Foo.BAR.bar () == "FOO_BAR"); +} diff -Nru vala-0.52.6/tests/errors/catch-no-error-type.test vala-0.52.7/tests/errors/catch-no-error-type.test --- vala-0.52.6/tests/errors/catch-no-error-type.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/errors/catch-no-error-type.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,7 @@ +Invalid Code + +void main () { + try { + } catch (int e) { + } +} diff -Nru vala-0.52.6/tests/errors/delegate-throws-error-code.vala vala-0.52.7/tests/errors/delegate-throws-error-code.vala --- vala-0.52.6/tests/errors/delegate-throws-error-code.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/errors/delegate-throws-error-code.vala 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,11 @@ +errordomain FooError { + FOO, + BAR; +} + +delegate void FooFunc () throws FooError.BAR; + +void main () { + FooFunc foo = () => {}; + foo (); +} diff -Nru vala-0.52.6/tests/errors/delegate-throws-no-error-type.test vala-0.52.7/tests/errors/delegate-throws-no-error-type.test --- vala-0.52.6/tests/errors/delegate-throws-no-error-type.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/errors/delegate-throws-no-error-type.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,6 @@ +Invalid Code + +delegate void FooFunc () throws int; + +void main () { +} diff -Nru vala-0.52.6/tests/errors/method-throws-error-code.vala vala-0.52.7/tests/errors/method-throws-error-code.vala --- vala-0.52.6/tests/errors/method-throws-error-code.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/errors/method-throws-error-code.vala 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,11 @@ +errordomain FooError { + FOO, + BAR; +} + +void foo () throws FooError.BAR { +} + +void main () { + foo (); +} diff -Nru vala-0.52.6/tests/errors/method-throws-no-error-type.test vala-0.52.7/tests/errors/method-throws-no-error-type.test --- vala-0.52.6/tests/errors/method-throws-no-error-type.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/errors/method-throws-no-error-type.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,7 @@ +Invalid Code + +void foo () throws int { +} + +void main () { +} diff -Nru vala-0.52.6/tests/fastvapi/Makefile.in vala-0.52.7/tests/fastvapi/Makefile.in --- vala-0.52.6/tests/fastvapi/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/tests/fastvapi/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/tests/girwriter/girtest.vala vala-0.52.7/tests/girwriter/girtest.vala --- vala-0.52.6/tests/girwriter/girtest.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/tests/girwriter/girtest.vala 2021-10-30 08:19:54.000000000 +0000 @@ -286,7 +286,7 @@ return new int[8]; } - public EqualFunc simple_delegate_return () { + public EqualFunc simple_delegate_return () { return str_equal; } diff -Nru vala-0.52.6/tests/girwriter/girtest.vapi-expected vala-0.52.7/tests/girwriter/girtest.vapi-expected --- vala-0.52.6/tests/girwriter/girtest.vapi-expected 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/tests/girwriter/girtest.vapi-expected 2021-10-30 08:19:54.000000000 +0000 @@ -103,7 +103,7 @@ public static void none_inout (ref unowned GirTest.ObjectTest obj); public static void none_out (out unowned GirTest.ObjectTest obj); public static unowned GirTest.ObjectTest none_return (); - public GLib.EqualFunc simple_delegate_return (); + public GLib.EqualFunc simple_delegate_return (); public void simple_throw () throws GirTest.ErrorTest; [GIR (visible = false)] public void skipped_method (); diff -Nru vala-0.52.6/tests/girwriter/Makefile.in vala-0.52.7/tests/girwriter/Makefile.in --- vala-0.52.6/tests/girwriter/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/tests/girwriter/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/tests/gtktemplate/Makefile.in vala-0.52.7/tests/gtktemplate/Makefile.in --- vala-0.52.6/tests/gtktemplate/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/tests/gtktemplate/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/tests/Makefile.am vala-0.52.7/tests/Makefile.am --- vala-0.52.6/tests/Makefile.am 2021-10-04 08:39:13.000000000 +0000 +++ vala-0.52.7/tests/Makefile.am 2021-10-30 08:19:54.000000000 +0000 @@ -59,9 +59,11 @@ basic-types/sizeof.vala \ basic-types/garray.vala \ basic-types/glists.vala \ + basic-types/glists_remove.vala \ basic-types/gptrarray.vala \ basic-types/gvariants.vala \ - basic-types/gvariants-hashtable-missing-type-arguments.test \ + basic-types/gvariants-hashtable-deserialize-missing-type-arguments.test \ + basic-types/gvariants-hashtable-serialize-missing-type-arguments.test \ basic-types/gvariants-unboxing-safe.vala \ basic-types/null.vala \ basic-types/bug570846.test \ @@ -168,6 +170,7 @@ methods/lambda.vala \ methods/closures.vala \ methods/contains.vala \ + methods/ellipsis-preceding.test \ methods/extern.vala \ methods/iterator.vala \ methods/parameter-fixed-array-initializer.vala \ @@ -327,6 +330,7 @@ enums/in-invalid.test \ enums/no_gtype_to_string.vala \ enums/switch.vala \ + enums/bug614424.vala \ enums/bug666035.vala \ enums/bug666035-1.test \ enums/bug666035-2.test \ @@ -403,12 +407,16 @@ delegates/implicit-local-variable.vala \ delegates/incompatible.test \ delegates/incompatible-assignment.test \ + delegates/incompatible-error-assignment.test \ + delegates/incompatible-error-argument.test \ + delegates/incompatible-error-argument-2.test \ delegates/incompatible-initializer.test \ delegates/incompatible-target.test \ delegates/instance-method-to-no-target.test \ delegates/instance-method-to-no-target-2.test \ delegates/lambda-incompatible.test \ delegates/lambda-mixed-instance-static.vala \ + delegates/lambda-outer-constant.test \ delegates/lambda-shared-closure.vala \ delegates/member-target-destroy.vala \ delegates/reference_transfer.vala \ @@ -614,7 +622,10 @@ objects/with-nested-unambigous-signal.vala \ errors/catch-error-code.vala \ errors/catch-in-finally.vala \ + errors/catch-no-error-type.test \ errors/default-gtype.vala \ + errors/delegate-throws-error-code.vala \ + errors/delegate-throws-no-error-type.test \ errors/errors.vala \ errors/errorcode.vala \ errors/errordomain.vala \ @@ -623,6 +634,8 @@ errors/invalid-type-check.test \ errors/loops.vala \ errors/method-throws.vala \ + errors/method-throws-error-code.vala \ + errors/method-throws-no-error-type.test \ errors/unhandled.vala \ errors/bug567181.vala \ errors/bug579101.vala \ @@ -908,7 +921,7 @@ parser/with-no-block.test \ parser/with-no-expression.test \ parser/yield-method.test \ - parser/yield-return.test \ + parser/yield-return-invalid.test \ parser/yield-return.vala \ parser/bug728574.vala \ parser/bug749576.vala \ @@ -985,6 +998,8 @@ semantic/creation-method-errordomain.test \ semantic/creation-method-interface.test \ semantic/creation-method-namespace.test \ + semantic/delegate-access-destroy-invalid.test \ + semantic/delegate-access-target-invalid.test \ semantic/delegate-error-accessibility.test \ semantic/delegate-return-valist.test \ semantic/delegate-too-few-type-arguments.test \ @@ -1002,6 +1017,8 @@ semantic/field-non-constant.test \ semantic/field-owned-to-unowned.test \ semantic/field-static-instance-access.test \ + semantic/field-too-few-type-arguments.test \ + semantic/field-too-many-type-arguments.test \ semantic/field-valist.test \ semantic/field-void.test \ semantic/floating-reference.vala \ @@ -1034,11 +1051,15 @@ semantic/localvariable-var-static-access-instance-property.test \ semantic/localvariable-var-without-initializer.test \ semantic/localvariable-void.test \ + semantic/lock-not-current-class.test \ + semantic/lock-not-lockable.test \ semantic/member-access-async-callback-invalid.test \ semantic/member-access-capture-out.test \ semantic/member-access-capture-valist-parameter.test \ semantic/member-access-capture-valist-variable.test \ + semantic/member-access-not-found.test \ semantic/member-access-protected-invalid.test \ + semantic/member-access-this-invalid.test \ semantic/member-access-undefined.test \ semantic/member-access-static-with-instance.vala \ semantic/member-access-static-transformed-qualified.vala \ @@ -1066,6 +1087,8 @@ semantic/method-private-virtual.test \ semantic/method-protected.test \ semantic/method-return-accessibility.test \ + semantic/method-return-too-few-type-arguments.test \ + semantic/method-return-too-many-type-arguments.test \ semantic/method-return-valist.test \ semantic/method-too-few-type-arguments.test \ semantic/method-too-many-type-arguments.test \ @@ -1086,6 +1109,8 @@ semantic/parameter-out-default.test \ semantic/parameter-params.test \ semantic/parameter-ref-default.test \ + semantic/parameter-too-few-type-arguments.test \ + semantic/parameter-too-many-type-arguments.test \ semantic/parameter-void.test \ semantic/params-array-multiple.test \ semantic/params-array-objectcreation-multiple.test \ @@ -1107,6 +1132,8 @@ semantic/property-struct-override.test \ semantic/property-struct-protected.test \ semantic/property-struct-virtual.test \ + semantic/property-too-few-type-arguments.test \ + semantic/property-too-many-type-arguments.test \ semantic/property-void.test \ semantic/reference-transfer-not-supported.test \ semantic/reference-transfer-unavailable.test \ @@ -1135,10 +1162,13 @@ semantic/type-argument-ownership-mismatch.test \ semantic/unary-invalid-instance-member-access.test \ semantic/unary-unsupported-complement.test \ + semantic/unary-unsupported-decrement.test \ semantic/unary-unsupported-increment.test \ semantic/unary-unsupported-minus.test \ semantic/unary-unsupported-negation.test \ semantic/unary-unsupported-out-ref.test \ + semantic/unlock-not-current-class.test \ + semantic/unlock-not-lockable.test \ semantic/with-array.test \ semantic/with-buildin.vala \ semantic/with-class.test \ diff -Nru vala-0.52.6/tests/Makefile.in vala-0.52.7/tests/Makefile.in --- vala-0.52.6/tests/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/tests/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. @@ -98,9 +98,10 @@ basic-types/array-uint8-uchar-compat.vala \ basic-types/pointers.vala basic-types/pointers-arithmetic.vala \ basic-types/sizeof.vala basic-types/garray.vala \ - basic-types/glists.vala basic-types/gptrarray.vala \ - basic-types/gvariants.vala \ - basic-types/gvariants-hashtable-missing-type-arguments.test \ + basic-types/glists.vala basic-types/glists_remove.vala \ + basic-types/gptrarray.vala basic-types/gvariants.vala \ + basic-types/gvariants-hashtable-deserialize-missing-type-arguments.test \ + basic-types/gvariants-hashtable-serialize-missing-type-arguments.test \ basic-types/gvariants-unboxing-safe.vala basic-types/null.vala \ basic-types/bug570846.test basic-types/bug571486.vala \ basic-types/bug591552.vala basic-types/bug595751.vala \ @@ -167,8 +168,8 @@ chainup/bug791785.vala pointers/delete.vala \ pointers/bug590641.vala methods/array-length-type.vala \ methods/lambda.vala methods/closures.vala \ - methods/contains.vala methods/extern.vala \ - methods/iterator.vala \ + methods/contains.vala methods/ellipsis-preceding.test \ + methods/extern.vala methods/iterator.vala \ methods/parameter-fixed-array-initializer.vala \ methods/parameter-out-free-on-error.vala \ methods/parameter-ref-array-resize.vala \ @@ -282,9 +283,9 @@ enums/enum-no-gtype.vala enums/enums.vala enums/flags.vala \ enums/from-0-literal.vala enums/in-inference.vala \ enums/in-invalid.test enums/no_gtype_to_string.vala \ - enums/switch.vala enums/bug666035.vala enums/bug666035-1.test \ - enums/bug666035-2.test enums/bug673879.vala \ - enums/bug763831.vala enums/bug780050.vala \ + enums/switch.vala enums/bug614424.vala enums/bug666035.vala \ + enums/bug666035-1.test enums/bug666035-2.test \ + enums/bug673879.vala enums/bug763831.vala enums/bug780050.vala \ structs/cast-struct-boxed.vala structs/struct_only.vala \ structs/struct-base-types.vala structs/struct-boxed-cast.vala \ structs/struct-empty-still.test \ @@ -327,12 +328,16 @@ delegates/implicit-local-variable.vala \ delegates/incompatible.test \ delegates/incompatible-assignment.test \ + delegates/incompatible-error-assignment.test \ + delegates/incompatible-error-argument.test \ + delegates/incompatible-error-argument-2.test \ delegates/incompatible-initializer.test \ delegates/incompatible-target.test \ delegates/instance-method-to-no-target.test \ delegates/instance-method-to-no-target-2.test \ delegates/lambda-incompatible.test \ delegates/lambda-mixed-instance-static.vala \ + delegates/lambda-outer-constant.test \ delegates/lambda-shared-closure.vala \ delegates/member-target-destroy.vala \ delegates/reference_transfer.vala \ @@ -472,12 +477,15 @@ objects/with-nested-signal.vala \ objects/with-nested-unambigous-signal.vala \ errors/catch-error-code.vala errors/catch-in-finally.vala \ - errors/default-gtype.vala errors/errors.vala \ + errors/catch-no-error-type.test errors/default-gtype.vala \ + errors/delegate-throws-error-code.vala \ + errors/delegate-throws-no-error-type.test errors/errors.vala \ errors/errorcode.vala errors/errordomain.vala \ errors/errordomain-instance-method.test \ errors/errordomain-static-method.vala \ errors/invalid-type-check.test errors/loops.vala \ - errors/method-throws.vala errors/unhandled.vala \ + errors/method-throws.vala errors/method-throws-error-code.vala \ + errors/method-throws-no-error-type.test errors/unhandled.vala \ errors/bug567181.vala errors/bug579101.vala \ errors/bug596228.vala errors/bug623049.vala \ errors/bug627090.vala errors/bug639589.vala \ @@ -674,7 +682,7 @@ parser/with-empty.vala parser/with-invalid-declaration.test \ parser/with-invalid-expression.test parser/with-no-block.test \ parser/with-no-expression.test parser/yield-method.test \ - parser/yield-return.test parser/yield-return.vala \ + parser/yield-return-invalid.test parser/yield-return.vala \ parser/bug728574.vala parser/bug749576.vala \ parser-keep-going/member-initializer.vala \ resolver/class-base-cycle.test \ @@ -743,6 +751,8 @@ semantic/creation-method-errordomain.test \ semantic/creation-method-interface.test \ semantic/creation-method-namespace.test \ + semantic/delegate-access-destroy-invalid.test \ + semantic/delegate-access-target-invalid.test \ semantic/delegate-error-accessibility.test \ semantic/delegate-return-valist.test \ semantic/delegate-too-few-type-arguments.test \ @@ -758,6 +768,8 @@ semantic/field-non-constant.test \ semantic/field-owned-to-unowned.test \ semantic/field-static-instance-access.test \ + semantic/field-too-few-type-arguments.test \ + semantic/field-too-many-type-arguments.test \ semantic/field-valist.test semantic/field-void.test \ semantic/floating-reference.vala \ semantic/floating-reference-base-method.vala \ @@ -789,11 +801,15 @@ semantic/localvariable-var-static-access-instance-property.test \ semantic/localvariable-var-without-initializer.test \ semantic/localvariable-void.test \ + semantic/lock-not-current-class.test \ + semantic/lock-not-lockable.test \ semantic/member-access-async-callback-invalid.test \ semantic/member-access-capture-out.test \ semantic/member-access-capture-valist-parameter.test \ semantic/member-access-capture-valist-variable.test \ + semantic/member-access-not-found.test \ semantic/member-access-protected-invalid.test \ + semantic/member-access-this-invalid.test \ semantic/member-access-undefined.test \ semantic/member-access-static-with-instance.vala \ semantic/member-access-static-transformed-qualified.vala \ @@ -819,6 +835,8 @@ semantic/method-private-virtual.test \ semantic/method-protected.test \ semantic/method-return-accessibility.test \ + semantic/method-return-too-few-type-arguments.test \ + semantic/method-return-too-many-type-arguments.test \ semantic/method-return-valist.test \ semantic/method-too-few-type-arguments.test \ semantic/method-too-many-type-arguments.test \ @@ -838,6 +856,8 @@ semantic/parameter-out-default.test \ semantic/parameter-params.test \ semantic/parameter-ref-default.test \ + semantic/parameter-too-few-type-arguments.test \ + semantic/parameter-too-many-type-arguments.test \ semantic/parameter-void.test \ semantic/params-array-multiple.test \ semantic/params-array-objectcreation-multiple.test \ @@ -859,6 +879,8 @@ semantic/property-struct-override.test \ semantic/property-struct-protected.test \ semantic/property-struct-virtual.test \ + semantic/property-too-few-type-arguments.test \ + semantic/property-too-many-type-arguments.test \ semantic/property-void.test \ semantic/reference-transfer-not-supported.test \ semantic/reference-transfer-unavailable.test \ @@ -886,12 +908,15 @@ semantic/type-argument-ownership-mismatch.test \ semantic/unary-invalid-instance-member-access.test \ semantic/unary-unsupported-complement.test \ + semantic/unary-unsupported-decrement.test \ semantic/unary-unsupported-increment.test \ semantic/unary-unsupported-minus.test \ semantic/unary-unsupported-negation.test \ semantic/unary-unsupported-out-ref.test \ - semantic/with-array.test semantic/with-buildin.vala \ - semantic/with-class.test semantic/with-compact.vala \ + semantic/unlock-not-current-class.test \ + semantic/unlock-not-lockable.test semantic/with-array.test \ + semantic/with-buildin.vala semantic/with-class.test \ + semantic/with-compact.vala \ semantic/with-declaration-cast-type.vala \ semantic/with-declaration-wrong-type.test \ semantic/with-declaration.vala \ diff -Nru vala-0.52.6/tests/methods/ellipsis-preceding.test vala-0.52.7/tests/methods/ellipsis-preceding.test --- vala-0.52.6/tests/methods/ellipsis-preceding.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/methods/ellipsis-preceding.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,7 @@ +Invalid Code + +void foo (int i, ..., int j) { +} + +void main () { +} diff -Nru vala-0.52.6/tests/objects/bug642809.vala vala-0.52.7/tests/objects/bug642809.vala --- vala-0.52.6/tests/objects/bug642809.vala 2019-10-17 07:43:42.000000000 +0000 +++ vala-0.52.7/tests/objects/bug642809.vala 2021-10-26 12:38:24.000000000 +0000 @@ -5,7 +5,13 @@ class Bar : Object, Foo { } +class Manam : Object, Foo { + public override void virtual_signal () { } +} + void main () { var bar = new Bar (); bar.virtual_signal (); + var manam = new Manam (); + manam.virtual_signal (); } diff -Nru vala-0.52.6/tests/parser/yield-return-invalid.test vala-0.52.7/tests/parser/yield-return-invalid.test --- vala-0.52.6/tests/parser/yield-return-invalid.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/parser/yield-return-invalid.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,13 @@ +Invalid Code + +class Foo { + public async Foo () { + } +} + +async Foo bar () { + yield return new Foo (); +} + +void main () { +} diff -Nru vala-0.52.6/tests/parser/yield-return.test vala-0.52.7/tests/parser/yield-return.test --- vala-0.52.6/tests/parser/yield-return.test 2021-04-19 18:42:41.000000000 +0000 +++ vala-0.52.7/tests/parser/yield-return.test 1970-01-01 00:00:00.000000000 +0000 @@ -1,13 +0,0 @@ -Invalid Code - -class Foo { - public async Foo () { - } -} - -async Foo bar () { - yield return new Foo (); -} - -void main () { -} diff -Nru vala-0.52.6/tests/semantic/delegate-access-destroy-invalid.test vala-0.52.7/tests/semantic/delegate-access-destroy-invalid.test --- vala-0.52.6/tests/semantic/delegate-access-destroy-invalid.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/delegate-access-destroy-invalid.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,9 @@ +Invalid Code + +[CCode (has_target = false)] +delegate void Foo (); + +void main () { + Foo foo = null; + var d = foo.destroy; +} diff -Nru vala-0.52.6/tests/semantic/delegate-access-target-invalid.test vala-0.52.7/tests/semantic/delegate-access-target-invalid.test --- vala-0.52.6/tests/semantic/delegate-access-target-invalid.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/delegate-access-target-invalid.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,9 @@ +Invalid Code + +[CCode (has_target = false)] +delegate void Foo (); + +void main () { + Foo foo = null; + var t = foo.target; +} diff -Nru vala-0.52.6/tests/semantic/field-too-few-type-arguments.test vala-0.52.7/tests/semantic/field-too-few-type-arguments.test --- vala-0.52.6/tests/semantic/field-too-few-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/field-too-few-type-arguments.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,9 @@ +Invalid Code + +class Foo { +} + +Foo bar; + +void main () { +} diff -Nru vala-0.52.6/tests/semantic/field-too-many-type-arguments.test vala-0.52.7/tests/semantic/field-too-many-type-arguments.test --- vala-0.52.6/tests/semantic/field-too-many-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/field-too-many-type-arguments.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,9 @@ +Invalid Code + +class Foo { +} + +Foo bar; + +void main () { +} diff -Nru vala-0.52.6/tests/semantic/lock-not-current-class.test vala-0.52.7/tests/semantic/lock-not-current-class.test --- vala-0.52.6/tests/semantic/lock-not-current-class.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/lock-not-current-class.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,14 @@ +Invalid Code + +class Bar { + public int bar; +} + +class Foo { + void foo (Bar bar) { + lock (bar.bar); + } +} + +void main () { +} diff -Nru vala-0.52.6/tests/semantic/lock-not-lockable.test vala-0.52.7/tests/semantic/lock-not-lockable.test --- vala-0.52.6/tests/semantic/lock-not-lockable.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/lock-not-lockable.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,8 @@ +Invalid Code + +void foo () { +} + +void main () { + lock (foo); +} diff -Nru vala-0.52.6/tests/semantic/member-access-not-found.test vala-0.52.7/tests/semantic/member-access-not-found.test --- vala-0.52.6/tests/semantic/member-access-not-found.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/member-access-not-found.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,9 @@ +Invalid Code + +class Foo { +} + +void main () { + var foo = new Foo (); + foo.get_bar (); +} diff -Nru vala-0.52.6/tests/semantic/member-access-this-invalid.test vala-0.52.7/tests/semantic/member-access-this-invalid.test --- vala-0.52.6/tests/semantic/member-access-this-invalid.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/member-access-this-invalid.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,5 @@ +Invalid Code + +void main () { + var foo = this; +} diff -Nru vala-0.52.6/tests/semantic/method-return-too-few-type-arguments.test vala-0.52.7/tests/semantic/method-return-too-few-type-arguments.test --- vala-0.52.6/tests/semantic/method-return-too-few-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/method-return-too-few-type-arguments.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,10 @@ +Invalid Code + +class Foo { +} + +Foo bar () { +} + +void main () { +} diff -Nru vala-0.52.6/tests/semantic/method-return-too-many-type-arguments.test vala-0.52.7/tests/semantic/method-return-too-many-type-arguments.test --- vala-0.52.6/tests/semantic/method-return-too-many-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/method-return-too-many-type-arguments.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,10 @@ +Invalid Code + +class Foo { +} + +Foo bar () { +} + +void main () { +} diff -Nru vala-0.52.6/tests/semantic/parameter-too-few-type-arguments.test vala-0.52.7/tests/semantic/parameter-too-few-type-arguments.test --- vala-0.52.6/tests/semantic/parameter-too-few-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/parameter-too-few-type-arguments.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,10 @@ +Invalid Code + +class Foo { +} + +void bar (Foo foo) { +} + +void main () { +} diff -Nru vala-0.52.6/tests/semantic/parameter-too-many-type-arguments.test vala-0.52.7/tests/semantic/parameter-too-many-type-arguments.test --- vala-0.52.6/tests/semantic/parameter-too-many-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/parameter-too-many-type-arguments.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,10 @@ +Invalid Code + +class Foo { +} + +void bar (Foo foo) { +} + +void main () { +} diff -Nru vala-0.52.6/tests/semantic/property-too-few-type-arguments.test vala-0.52.7/tests/semantic/property-too-few-type-arguments.test --- vala-0.52.6/tests/semantic/property-too-few-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/property-too-few-type-arguments.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,11 @@ +Invalid Code + +class Foo { +} + +class Bar { + public Foo foo { get; set; } +} + +void main () { +} diff -Nru vala-0.52.6/tests/semantic/property-too-many-type-arguments.test vala-0.52.7/tests/semantic/property-too-many-type-arguments.test --- vala-0.52.6/tests/semantic/property-too-many-type-arguments.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/property-too-many-type-arguments.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,11 @@ +Invalid Code + +class Foo { +} + +class Bar { + public Foo foo { get; set; } +} + +void main () { +} diff -Nru vala-0.52.6/tests/semantic/unary-unsupported-decrement.test vala-0.52.7/tests/semantic/unary-unsupported-decrement.test --- vala-0.52.6/tests/semantic/unary-unsupported-decrement.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/unary-unsupported-decrement.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,9 @@ +Invalid Code + +int foo () { + return 23; +} + +void main () { + ++foo (); +} diff -Nru vala-0.52.6/tests/semantic/unlock-not-current-class.test vala-0.52.7/tests/semantic/unlock-not-current-class.test --- vala-0.52.6/tests/semantic/unlock-not-current-class.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/unlock-not-current-class.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,14 @@ +Invalid Code + +class Bar { + public int bar; +} + +class Foo { + void foo (Bar bar) { + unlock (bar.bar); + } +} + +void main () { +} diff -Nru vala-0.52.6/tests/semantic/unlock-not-lockable.test vala-0.52.7/tests/semantic/unlock-not-lockable.test --- vala-0.52.6/tests/semantic/unlock-not-lockable.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.52.7/tests/semantic/unlock-not-lockable.test 2021-10-26 12:38:24.000000000 +0000 @@ -0,0 +1,8 @@ +Invalid Code + +void foo () { +} + +void main () { + unlock (foo); +} diff -Nru vala-0.52.6/vala/Makefile.in vala-0.52.7/vala/Makefile.in --- vala-0.52.6/vala/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/vala/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/vala/valaaddressofexpression.c vala-0.52.7/vala/valaaddressofexpression.c --- vala-0.52.6/vala/valaaddressofexpression.c 2021-10-04 09:46:51.000000000 +0000 +++ vala-0.52.7/vala/valaaddressofexpression.c 2021-10-30 08:24:05.000000000 +0000 @@ -238,8 +238,8 @@ ValaExpression* _tmp33_; ValaDataType* _tmp34_; ValaDataType* _tmp35_; - gboolean _tmp50_; - gboolean _tmp51_; + gboolean _tmp54_; + gboolean _tmp55_; gboolean result = FALSE; self = (ValaAddressofExpression*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -341,38 +341,46 @@ ValaDataType* _tmp39_; ValaPointerType* _tmp40_; ValaPointerType* _tmp41_; - ValaPointerType* _tmp42_; - ValaPointerType* _tmp43_; + ValaSourceReference* _tmp42_; + ValaSourceReference* _tmp43_; + ValaPointerType* _tmp44_; + ValaPointerType* _tmp45_; _tmp36_ = vala_addressof_expression_get_inner (self); _tmp37_ = _tmp36_; _tmp38_ = vala_expression_get_value_type (_tmp37_); _tmp39_ = _tmp38_; _tmp40_ = vala_pointer_type_new (_tmp39_, NULL); _tmp41_ = _tmp40_; - _tmp42_ = vala_pointer_type_new ((ValaDataType*) _tmp41_, NULL); + _tmp42_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp43_ = _tmp42_; - vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp43_); - _vala_code_node_unref0 (_tmp43_); + _tmp44_ = vala_pointer_type_new ((ValaDataType*) _tmp41_, _tmp43_); + _tmp45_ = _tmp44_; + vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp45_); + _vala_code_node_unref0 (_tmp45_); _vala_code_node_unref0 (_tmp41_); } else { - ValaExpression* _tmp44_; - ValaExpression* _tmp45_; - ValaDataType* _tmp46_; - ValaDataType* _tmp47_; - ValaPointerType* _tmp48_; - ValaPointerType* _tmp49_; - _tmp44_ = vala_addressof_expression_get_inner (self); - _tmp45_ = _tmp44_; - _tmp46_ = vala_expression_get_value_type (_tmp45_); + ValaExpression* _tmp46_; + ValaExpression* _tmp47_; + ValaDataType* _tmp48_; + ValaDataType* _tmp49_; + ValaSourceReference* _tmp50_; + ValaSourceReference* _tmp51_; + ValaPointerType* _tmp52_; + ValaPointerType* _tmp53_; + _tmp46_ = vala_addressof_expression_get_inner (self); _tmp47_ = _tmp46_; - _tmp48_ = vala_pointer_type_new (_tmp47_, NULL); + _tmp48_ = vala_expression_get_value_type (_tmp47_); _tmp49_ = _tmp48_; - vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp49_); - _vala_code_node_unref0 (_tmp49_); + _tmp50_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp51_ = _tmp50_; + _tmp52_ = vala_pointer_type_new (_tmp49_, _tmp51_); + _tmp53_ = _tmp52_; + vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp53_); + _vala_code_node_unref0 (_tmp53_); } - _tmp50_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp51_ = _tmp50_; - result = !_tmp51_; + _tmp54_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp55_ = _tmp54_; + result = !_tmp55_; return result; } diff -Nru vala-0.52.6/vala/valaaddressofexpression.vala vala-0.52.7/vala/valaaddressofexpression.vala --- vala-0.52.6/vala/valaaddressofexpression.vala 2021-09-30 15:37:07.000000000 +0000 +++ vala-0.52.7/vala/valaaddressofexpression.vala 2021-10-26 12:38:24.000000000 +0000 @@ -109,9 +109,9 @@ } if (inner.value_type.is_reference_type_or_type_parameter ()) { - value_type = new PointerType (new PointerType (inner.value_type)); + value_type = new PointerType (new PointerType (inner.value_type), source_reference); } else { - value_type = new PointerType (inner.value_type); + value_type = new PointerType (inner.value_type, source_reference); } return !error; diff -Nru vala-0.52.6/vala/valaassignment.c vala-0.52.7/vala/valaassignment.c --- vala-0.52.6/vala/valaassignment.c 2021-10-04 09:46:51.000000000 +0000 +++ vala-0.52.7/vala/valaassignment.c 2021-10-30 08:24:05.000000000 +0000 @@ -373,15 +373,15 @@ gboolean _tmp253_ = FALSE; gboolean _tmp254_ = FALSE; ValaAssignmentOperator _tmp255_; - ValaMemberAccess* _tmp302_; - ValaExpression* _tmp595_; - ValaExpression* _tmp596_; - ValaDataType* _tmp597_; - ValaDataType* _tmp598_; - ValaDataType* _tmp607_; - ValaDataType* _tmp608_; - gboolean _tmp611_; - gboolean _tmp612_; + ValaMemberAccess* _tmp304_; + ValaExpression* _tmp597_; + ValaExpression* _tmp598_; + ValaDataType* _tmp599_; + ValaDataType* _tmp600_; + ValaDataType* _tmp609_; + ValaDataType* _tmp610_; + gboolean _tmp613_; + gboolean _tmp614_; gboolean result = FALSE; self = (ValaAssignment*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -1118,47 +1118,51 @@ ValaMemberAccess* _tmp268_; const gchar* _tmp269_; const gchar* _tmp270_; - ValaMemberAccess* _tmp271_; + ValaSourceReference* _tmp271_; + ValaSourceReference* _tmp272_; + ValaMemberAccess* _tmp273_; ValaBinaryOperator bop = 0; - ValaAssignmentOperator _tmp272_; + ValaAssignmentOperator _tmp274_; ValaBinaryExpression* bin = NULL; - ValaBinaryOperator _tmp275_; - ValaMemberAccess* _tmp276_; - ValaExpression* _tmp277_; - ValaExpression* _tmp278_; - ValaSourceReference* _tmp279_; - ValaSourceReference* _tmp280_; - ValaBinaryExpression* _tmp281_; - ValaBinaryExpression* _tmp282_; - ValaExpression* _tmp283_; - ValaExpression* _tmp284_; - ValaDataType* _tmp285_; - ValaDataType* _tmp286_; - ValaExpression* _tmp287_; - ValaExpression* _tmp288_; + ValaBinaryOperator _tmp277_; + ValaMemberAccess* _tmp278_; + ValaExpression* _tmp279_; + ValaExpression* _tmp280_; + ValaSourceReference* _tmp281_; + ValaSourceReference* _tmp282_; + ValaBinaryExpression* _tmp283_; + ValaBinaryExpression* _tmp284_; + ValaExpression* _tmp285_; + ValaExpression* _tmp286_; + ValaDataType* _tmp287_; + ValaDataType* _tmp288_; ValaExpression* _tmp289_; ValaExpression* _tmp290_; - ValaDataType* _tmp291_; - ValaDataType* _tmp292_; + ValaExpression* _tmp291_; + ValaExpression* _tmp292_; ValaDataType* _tmp293_; ValaDataType* _tmp294_; - ValaExpression* _tmp295_; - ValaExpression* _tmp296_; - ValaDataType* _tmp297_; - ValaDataType* _tmp298_; - ValaBinaryExpression* _tmp299_; - ValaExpression* _tmp300_; - ValaExpression* _tmp301_; + ValaDataType* _tmp295_; + ValaDataType* _tmp296_; + ValaExpression* _tmp297_; + ValaExpression* _tmp298_; + ValaDataType* _tmp299_; + ValaDataType* _tmp300_; + ValaBinaryExpression* _tmp301_; + ValaExpression* _tmp302_; + ValaExpression* _tmp303_; _tmp265_ = ma; _tmp266_ = vala_member_access_get_inner (_tmp265_); _tmp267_ = _tmp266_; _tmp268_ = ma; _tmp269_ = vala_member_access_get_member_name (_tmp268_); _tmp270_ = _tmp269_; - _tmp271_ = vala_member_access_new (_tmp267_, _tmp270_, NULL); - old_value = _tmp271_; - _tmp272_ = self->priv->_operator; - switch (_tmp272_) { + _tmp271_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp272_ = _tmp271_; + _tmp273_ = vala_member_access_new (_tmp267_, _tmp270_, _tmp272_); + old_value = _tmp273_; + _tmp274_ = self->priv->_operator; + switch (_tmp274_) { case VALA_ASSIGNMENT_OPERATOR_BITWISE_OR: { bop = VALA_BINARY_OPERATOR_BITWISE_OR; @@ -1211,355 +1215,355 @@ } default: { - ValaSourceReference* _tmp273_; - ValaSourceReference* _tmp274_; + ValaSourceReference* _tmp275_; + ValaSourceReference* _tmp276_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp273_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp274_ = _tmp273_; - vala_report_error (_tmp274_, "internal error: unsupported assignment operator"); + _tmp275_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp276_ = _tmp275_; + vala_report_error (_tmp276_, "internal error: unsupported assignment operator"); result = FALSE; _vala_code_node_unref0 (old_value); return result; } } - _tmp275_ = bop; - _tmp276_ = old_value; - _tmp277_ = vala_assignment_get_right (self); - _tmp278_ = _tmp277_; - _tmp279_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp277_ = bop; + _tmp278_ = old_value; + _tmp279_ = vala_assignment_get_right (self); _tmp280_ = _tmp279_; - _tmp281_ = vala_binary_expression_new (_tmp275_, (ValaExpression*) _tmp276_, _tmp278_, _tmp280_); - bin = _tmp281_; - _tmp282_ = bin; - _tmp283_ = vala_assignment_get_right (self); - _tmp284_ = _tmp283_; - _tmp285_ = vala_expression_get_target_type (_tmp284_); + _tmp281_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp282_ = _tmp281_; + _tmp283_ = vala_binary_expression_new (_tmp277_, (ValaExpression*) _tmp278_, _tmp280_, _tmp282_); + bin = _tmp283_; + _tmp284_ = bin; + _tmp285_ = vala_assignment_get_right (self); _tmp286_ = _tmp285_; - vala_expression_set_target_type ((ValaExpression*) _tmp282_, _tmp286_); - _tmp287_ = vala_assignment_get_right (self); + _tmp287_ = vala_expression_get_target_type (_tmp286_); _tmp288_ = _tmp287_; + vala_expression_set_target_type ((ValaExpression*) _tmp284_, _tmp288_); _tmp289_ = vala_assignment_get_right (self); _tmp290_ = _tmp289_; - _tmp291_ = vala_expression_get_target_type (_tmp290_); + _tmp291_ = vala_assignment_get_right (self); _tmp292_ = _tmp291_; - _tmp293_ = vala_data_type_copy (_tmp292_); + _tmp293_ = vala_expression_get_target_type (_tmp292_); _tmp294_ = _tmp293_; - vala_expression_set_target_type (_tmp288_, _tmp294_); - _vala_code_node_unref0 (_tmp294_); - _tmp295_ = vala_assignment_get_right (self); + _tmp295_ = vala_data_type_copy (_tmp294_); _tmp296_ = _tmp295_; - _tmp297_ = vala_expression_get_target_type (_tmp296_); + vala_expression_set_target_type (_tmp290_, _tmp296_); + _vala_code_node_unref0 (_tmp296_); + _tmp297_ = vala_assignment_get_right (self); _tmp298_ = _tmp297_; - vala_data_type_set_value_owned (_tmp298_, FALSE); - _tmp299_ = bin; - vala_assignment_set_right (self, (ValaExpression*) _tmp299_); - _tmp300_ = vala_assignment_get_right (self); - _tmp301_ = _tmp300_; - vala_code_node_check ((ValaCodeNode*) _tmp301_, context); + _tmp299_ = vala_expression_get_target_type (_tmp298_); + _tmp300_ = _tmp299_; + vala_data_type_set_value_owned (_tmp300_, FALSE); + _tmp301_ = bin; + vala_assignment_set_right (self, (ValaExpression*) _tmp301_); + _tmp302_ = vala_assignment_get_right (self); + _tmp303_ = _tmp302_; + vala_code_node_check ((ValaCodeNode*) _tmp303_, context); vala_assignment_set_operator (self, VALA_ASSIGNMENT_OPERATOR_SIMPLE); _vala_code_node_unref0 (bin); _vala_code_node_unref0 (old_value); } - _tmp302_ = ma; - if (_tmp302_ != NULL) { - ValaMemberAccess* _tmp303_; - ValaSymbol* _tmp304_; - ValaSymbol* _tmp305_; - gboolean _tmp412_ = FALSE; - ValaExpression* _tmp413_; - ValaExpression* _tmp414_; - ValaDataType* _tmp415_; - ValaDataType* _tmp416_; + _tmp304_ = ma; + if (_tmp304_ != NULL) { + ValaMemberAccess* _tmp305_; + ValaSymbol* _tmp306_; + ValaSymbol* _tmp307_; + gboolean _tmp414_ = FALSE; + ValaExpression* _tmp415_; + ValaExpression* _tmp416_; + ValaDataType* _tmp417_; + ValaDataType* _tmp418_; ValaMemberAccess* right_ma = NULL; - ValaExpression* _tmp469_; - ValaExpression* _tmp470_; - gboolean _tmp471_ = FALSE; - ValaMemberAccess* _tmp472_; - _tmp303_ = ma; - _tmp304_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp303_); - _tmp305_ = _tmp304_; - if (VALA_IS_PROPERTY (_tmp305_)) { + ValaExpression* _tmp471_; + ValaExpression* _tmp472_; + gboolean _tmp473_ = FALSE; + ValaMemberAccess* _tmp474_; + _tmp305_ = ma; + _tmp306_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp305_); + _tmp307_ = _tmp306_; + if (VALA_IS_PROPERTY (_tmp307_)) { ValaProperty* prop = NULL; - ValaMemberAccess* _tmp306_; - ValaSymbol* _tmp307_; - ValaSymbol* _tmp308_; + ValaMemberAccess* _tmp308_; + ValaSymbol* _tmp309_; + ValaSymbol* _tmp310_; ValaDynamicProperty* dynamic_prop = NULL; - ValaProperty* _tmp309_; - ValaDynamicProperty* _tmp310_; - _tmp306_ = ma; - _tmp307_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp306_); - _tmp308_ = _tmp307_; - prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp308_, VALA_TYPE_PROPERTY, ValaProperty); - _tmp309_ = prop; - dynamic_prop = VALA_IS_DYNAMIC_PROPERTY (_tmp309_) ? ((ValaDynamicProperty*) _tmp309_) : NULL; - _tmp310_ = dynamic_prop; - if (_tmp310_ != NULL) { - ValaDynamicProperty* _tmp311_; - ValaExpression* _tmp312_; - ValaExpression* _tmp313_; - ValaDataType* _tmp314_; - ValaDataType* _tmp315_; + ValaProperty* _tmp311_; + ValaDynamicProperty* _tmp312_; + _tmp308_ = ma; + _tmp309_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp308_); + _tmp310_ = _tmp309_; + prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp310_, VALA_TYPE_PROPERTY, ValaProperty); + _tmp311_ = prop; + dynamic_prop = VALA_IS_DYNAMIC_PROPERTY (_tmp311_) ? ((ValaDynamicProperty*) _tmp311_) : NULL; + _tmp312_ = dynamic_prop; + if (_tmp312_ != NULL) { + ValaDynamicProperty* _tmp313_; + ValaExpression* _tmp314_; + ValaExpression* _tmp315_; ValaDataType* _tmp316_; ValaDataType* _tmp317_; - ValaExpression* _tmp318_; - ValaExpression* _tmp319_; - ValaDynamicProperty* _tmp320_; - ValaDataType* _tmp321_; - ValaDataType* _tmp322_; + ValaDataType* _tmp318_; + ValaDataType* _tmp319_; + ValaExpression* _tmp320_; + ValaExpression* _tmp321_; + ValaDynamicProperty* _tmp322_; ValaDataType* _tmp323_; ValaDataType* _tmp324_; - _tmp311_ = dynamic_prop; - _tmp312_ = vala_assignment_get_right (self); - _tmp313_ = _tmp312_; - _tmp314_ = vala_expression_get_value_type (_tmp313_); + ValaDataType* _tmp325_; + ValaDataType* _tmp326_; + _tmp313_ = dynamic_prop; + _tmp314_ = vala_assignment_get_right (self); _tmp315_ = _tmp314_; - _tmp316_ = vala_data_type_copy (_tmp315_); + _tmp316_ = vala_expression_get_value_type (_tmp315_); _tmp317_ = _tmp316_; - vala_property_set_property_type ((ValaProperty*) _tmp311_, _tmp317_); - _vala_code_node_unref0 (_tmp317_); - _tmp318_ = vala_assignment_get_left (self); + _tmp318_ = vala_data_type_copy (_tmp317_); _tmp319_ = _tmp318_; - _tmp320_ = dynamic_prop; - _tmp321_ = vala_property_get_property_type ((ValaProperty*) _tmp320_); - _tmp322_ = _tmp321_; - _tmp323_ = vala_data_type_copy (_tmp322_); + vala_property_set_property_type ((ValaProperty*) _tmp313_, _tmp319_); + _vala_code_node_unref0 (_tmp319_); + _tmp320_ = vala_assignment_get_left (self); + _tmp321_ = _tmp320_; + _tmp322_ = dynamic_prop; + _tmp323_ = vala_property_get_property_type ((ValaProperty*) _tmp322_); _tmp324_ = _tmp323_; - vala_expression_set_value_type (_tmp319_, _tmp324_); - _vala_code_node_unref0 (_tmp324_); + _tmp325_ = vala_data_type_copy (_tmp324_); + _tmp326_ = _tmp325_; + vala_expression_set_value_type (_tmp321_, _tmp326_); + _vala_code_node_unref0 (_tmp326_); } } else { - gboolean _tmp325_ = FALSE; - ValaMemberAccess* _tmp326_; - ValaSymbol* _tmp327_; - ValaSymbol* _tmp328_; - _tmp326_ = ma; - _tmp327_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp326_); - _tmp328_ = _tmp327_; - if (VALA_IS_ARRAY_LENGTH_FIELD (_tmp328_)) { - ValaMemberAccess* _tmp329_; - ValaExpression* _tmp330_; - ValaExpression* _tmp331_; - ValaDataType* _tmp332_; - ValaDataType* _tmp333_; - gboolean _tmp334_; - gboolean _tmp335_; - _tmp329_ = ma; - _tmp330_ = vala_member_access_get_inner (_tmp329_); - _tmp331_ = _tmp330_; - _tmp332_ = vala_expression_get_value_type (_tmp331_); + gboolean _tmp327_ = FALSE; + ValaMemberAccess* _tmp328_; + ValaSymbol* _tmp329_; + ValaSymbol* _tmp330_; + _tmp328_ = ma; + _tmp329_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp328_); + _tmp330_ = _tmp329_; + if (VALA_IS_ARRAY_LENGTH_FIELD (_tmp330_)) { + ValaMemberAccess* _tmp331_; + ValaExpression* _tmp332_; + ValaExpression* _tmp333_; + ValaDataType* _tmp334_; + ValaDataType* _tmp335_; + gboolean _tmp336_; + gboolean _tmp337_; + _tmp331_ = ma; + _tmp332_ = vala_member_access_get_inner (_tmp331_); _tmp333_ = _tmp332_; - _tmp334_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp333_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp334_ = vala_expression_get_value_type (_tmp333_); _tmp335_ = _tmp334_; - _tmp325_ = _tmp335_; + _tmp336_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp335_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp337_ = _tmp336_; + _tmp327_ = _tmp337_; } else { - _tmp325_ = FALSE; + _tmp327_ = FALSE; } - if (_tmp325_) { - ValaSourceReference* _tmp336_; - ValaSourceReference* _tmp337_; + if (_tmp327_) { + ValaSourceReference* _tmp338_; + ValaSourceReference* _tmp339_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp336_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp337_ = _tmp336_; - vala_report_error (_tmp337_, "`length' field of fixed length arrays is read-only"); + _tmp338_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp339_ = _tmp338_; + vala_report_error (_tmp339_, "`length' field of fixed length arrays is read-only"); result = FALSE; return result; } else { - gboolean _tmp338_ = FALSE; - ValaMemberAccess* _tmp339_; - ValaSymbol* _tmp340_; - ValaSymbol* _tmp341_; - _tmp339_ = ma; - _tmp340_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp339_); - _tmp341_ = _tmp340_; - if (VALA_IS_VARIABLE (_tmp341_)) { - ValaExpression* _tmp342_; - ValaExpression* _tmp343_; - ValaDataType* _tmp344_; - ValaDataType* _tmp345_; - _tmp342_ = vala_assignment_get_right (self); - _tmp343_ = _tmp342_; - _tmp344_ = vala_expression_get_value_type (_tmp343_); + gboolean _tmp340_ = FALSE; + ValaMemberAccess* _tmp341_; + ValaSymbol* _tmp342_; + ValaSymbol* _tmp343_; + _tmp341_ = ma; + _tmp342_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp341_); + _tmp343_ = _tmp342_; + if (VALA_IS_VARIABLE (_tmp343_)) { + ValaExpression* _tmp344_; + ValaExpression* _tmp345_; + ValaDataType* _tmp346_; + ValaDataType* _tmp347_; + _tmp344_ = vala_assignment_get_right (self); _tmp345_ = _tmp344_; - _tmp338_ = VALA_IS_METHOD_TYPE (_tmp345_); + _tmp346_ = vala_expression_get_value_type (_tmp345_); + _tmp347_ = _tmp346_; + _tmp340_ = VALA_IS_METHOD_TYPE (_tmp347_); } else { - _tmp338_ = FALSE; + _tmp340_ = FALSE; } - if (_tmp338_) { + if (_tmp340_) { ValaVariable* variable = NULL; - ValaMemberAccess* _tmp346_; - ValaSymbol* _tmp347_; - ValaSymbol* _tmp348_; - ValaVariable* _tmp349_; - ValaDataType* _tmp350_; - ValaDataType* _tmp351_; - _tmp346_ = ma; - _tmp347_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp346_); - _tmp348_ = _tmp347_; - variable = G_TYPE_CHECK_INSTANCE_CAST (_tmp348_, VALA_TYPE_VARIABLE, ValaVariable); - _tmp349_ = variable; - _tmp350_ = vala_variable_get_variable_type (_tmp349_); - _tmp351_ = _tmp350_; - if (VALA_IS_DELEGATE_TYPE (_tmp351_)) { - ValaExpression* _tmp352_; - ValaExpression* _tmp353_; - ValaDataType* _tmp354_; - ValaDataType* _tmp355_; - ValaVariable* _tmp356_; + ValaMemberAccess* _tmp348_; + ValaSymbol* _tmp349_; + ValaSymbol* _tmp350_; + ValaVariable* _tmp351_; + ValaDataType* _tmp352_; + ValaDataType* _tmp353_; + _tmp348_ = ma; + _tmp349_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp348_); + _tmp350_ = _tmp349_; + variable = G_TYPE_CHECK_INSTANCE_CAST (_tmp350_, VALA_TYPE_VARIABLE, ValaVariable); + _tmp351_ = variable; + _tmp352_ = vala_variable_get_variable_type (_tmp351_); + _tmp353_ = _tmp352_; + if (VALA_IS_DELEGATE_TYPE (_tmp353_)) { + ValaExpression* _tmp354_; + ValaExpression* _tmp355_; + ValaDataType* _tmp356_; ValaDataType* _tmp357_; - ValaDataType* _tmp358_; - _tmp352_ = vala_assignment_get_right (self); - _tmp353_ = _tmp352_; - _tmp354_ = vala_expression_get_value_type (_tmp353_); + ValaVariable* _tmp358_; + ValaDataType* _tmp359_; + ValaDataType* _tmp360_; + _tmp354_ = vala_assignment_get_right (self); _tmp355_ = _tmp354_; - _tmp356_ = variable; - _tmp357_ = vala_variable_get_variable_type (_tmp356_); - _tmp358_ = _tmp357_; - if (!vala_data_type_compatible (_tmp355_, _tmp358_)) { + _tmp356_ = vala_expression_get_value_type (_tmp355_); + _tmp357_ = _tmp356_; + _tmp358_ = variable; + _tmp359_ = vala_variable_get_variable_type (_tmp358_); + _tmp360_ = _tmp359_; + if (!vala_data_type_compatible (_tmp357_, _tmp360_)) { ValaMethod* m = NULL; - ValaExpression* _tmp359_; - ValaExpression* _tmp360_; - ValaSymbol* _tmp361_; - ValaSymbol* _tmp362_; + ValaExpression* _tmp361_; + ValaExpression* _tmp362_; + ValaSymbol* _tmp363_; + ValaSymbol* _tmp364_; ValaDelegate* cb = NULL; - ValaVariable* _tmp363_; - ValaDataType* _tmp364_; - ValaDataType* _tmp365_; - ValaDelegate* _tmp366_; - ValaDelegate* _tmp367_; - ValaSourceReference* _tmp368_; - ValaSourceReference* _tmp369_; - ValaMethod* _tmp370_; - gchar* _tmp371_; - gchar* _tmp372_; - ValaDelegate* _tmp373_; + ValaVariable* _tmp365_; + ValaDataType* _tmp366_; + ValaDataType* _tmp367_; + ValaDelegate* _tmp368_; + ValaDelegate* _tmp369_; + ValaSourceReference* _tmp370_; + ValaSourceReference* _tmp371_; + ValaMethod* _tmp372_; + gchar* _tmp373_; gchar* _tmp374_; - gchar* _tmp375_; - _tmp359_ = vala_assignment_get_right (self); - _tmp360_ = _tmp359_; - _tmp361_ = vala_expression_get_symbol_reference (_tmp360_); + ValaDelegate* _tmp375_; + gchar* _tmp376_; + gchar* _tmp377_; + _tmp361_ = vala_assignment_get_right (self); _tmp362_ = _tmp361_; - m = G_TYPE_CHECK_INSTANCE_CAST (_tmp362_, VALA_TYPE_METHOD, ValaMethod); - _tmp363_ = variable; - _tmp364_ = vala_variable_get_variable_type (_tmp363_); - _tmp365_ = _tmp364_; - _tmp366_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp365_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + _tmp363_ = vala_expression_get_symbol_reference (_tmp362_); + _tmp364_ = _tmp363_; + m = G_TYPE_CHECK_INSTANCE_CAST (_tmp364_, VALA_TYPE_METHOD, ValaMethod); + _tmp365_ = variable; + _tmp366_ = vala_variable_get_variable_type (_tmp365_); _tmp367_ = _tmp366_; - cb = _tmp367_; - vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp368_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp368_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp367_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); _tmp369_ = _tmp368_; - _tmp370_ = m; - _tmp371_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp370_); - _tmp372_ = _tmp371_; - _tmp373_ = cb; - _tmp374_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp373_); - _tmp375_ = _tmp374_; - vala_report_error (_tmp369_, "Declaration of method `%s' is not compatible with delegate `%s'", _tmp372_, _tmp375_); - _g_free0 (_tmp375_); - _g_free0 (_tmp372_); + cb = _tmp369_; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp370_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp371_ = _tmp370_; + _tmp372_ = m; + _tmp373_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp372_); + _tmp374_ = _tmp373_; + _tmp375_ = cb; + _tmp376_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp375_); + _tmp377_ = _tmp376_; + vala_report_error (_tmp371_, "Declaration of method `%s' is not compatible with delegate `%s'", _tmp374_, _tmp377_); + _g_free0 (_tmp377_); + _g_free0 (_tmp374_); result = FALSE; return result; } } else { - ValaSourceReference* _tmp376_; - ValaSourceReference* _tmp377_; + ValaSourceReference* _tmp378_; + ValaSourceReference* _tmp379_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp376_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp377_ = _tmp376_; - vala_report_error (_tmp377_, "Assignment: Invalid assignment attempt"); + _tmp378_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp379_ = _tmp378_; + vala_report_error (_tmp379_, "Assignment: Invalid assignment attempt"); result = FALSE; return result; } } else { - ValaMemberAccess* _tmp378_; - ValaSymbol* _tmp379_; - ValaSymbol* _tmp380_; - _tmp378_ = ma; - _tmp379_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp378_); - _tmp380_ = _tmp379_; - if (VALA_IS_VARIABLE (_tmp380_)) { + ValaMemberAccess* _tmp380_; + ValaSymbol* _tmp381_; + ValaSymbol* _tmp382_; + _tmp380_ = ma; + _tmp381_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp380_); + _tmp382_ = _tmp381_; + if (VALA_IS_VARIABLE (_tmp382_)) { ValaVariable* variable = NULL; - ValaMemberAccess* _tmp381_; - ValaSymbol* _tmp382_; - ValaSymbol* _tmp383_; + ValaMemberAccess* _tmp383_; + ValaSymbol* _tmp384_; + ValaSymbol* _tmp385_; ValaArrayType* variable_array_type = NULL; - ValaVariable* _tmp384_; - ValaDataType* _tmp385_; - ValaDataType* _tmp386_; - gboolean _tmp387_ = FALSE; - gboolean _tmp388_ = FALSE; + ValaVariable* _tmp386_; + ValaDataType* _tmp387_; + ValaDataType* _tmp388_; gboolean _tmp389_ = FALSE; - ValaArrayType* _tmp390_; - _tmp381_ = ma; - _tmp382_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp381_); - _tmp383_ = _tmp382_; - variable = G_TYPE_CHECK_INSTANCE_CAST (_tmp383_, VALA_TYPE_VARIABLE, ValaVariable); - _tmp384_ = variable; - _tmp385_ = vala_variable_get_variable_type (_tmp384_); - _tmp386_ = _tmp385_; - variable_array_type = VALA_IS_ARRAY_TYPE (_tmp386_) ? ((ValaArrayType*) _tmp386_) : NULL; - _tmp390_ = variable_array_type; - if (_tmp390_ != NULL) { - ValaArrayType* _tmp391_; - gboolean _tmp392_; - gboolean _tmp393_; - _tmp391_ = variable_array_type; - _tmp392_ = vala_array_type_get_inline_allocated (_tmp391_); - _tmp393_ = _tmp392_; - _tmp389_ = _tmp393_; - } else { - _tmp389_ = FALSE; - } - if (_tmp389_) { - ValaExpression* _tmp394_; - ValaExpression* _tmp395_; - _tmp394_ = vala_assignment_get_right (self); + gboolean _tmp390_ = FALSE; + gboolean _tmp391_ = FALSE; + ValaArrayType* _tmp392_; + _tmp383_ = ma; + _tmp384_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp383_); + _tmp385_ = _tmp384_; + variable = G_TYPE_CHECK_INSTANCE_CAST (_tmp385_, VALA_TYPE_VARIABLE, ValaVariable); + _tmp386_ = variable; + _tmp387_ = vala_variable_get_variable_type (_tmp386_); + _tmp388_ = _tmp387_; + variable_array_type = VALA_IS_ARRAY_TYPE (_tmp388_) ? ((ValaArrayType*) _tmp388_) : NULL; + _tmp392_ = variable_array_type; + if (_tmp392_ != NULL) { + ValaArrayType* _tmp393_; + gboolean _tmp394_; + gboolean _tmp395_; + _tmp393_ = variable_array_type; + _tmp394_ = vala_array_type_get_inline_allocated (_tmp393_); _tmp395_ = _tmp394_; - _tmp388_ = VALA_IS_ARRAY_CREATION_EXPRESSION (_tmp395_); + _tmp391_ = _tmp395_; } else { - _tmp388_ = FALSE; + _tmp391_ = FALSE; } - if (_tmp388_) { + if (_tmp391_) { ValaExpression* _tmp396_; ValaExpression* _tmp397_; - ValaInitializerList* _tmp398_; - ValaInitializerList* _tmp399_; _tmp396_ = vala_assignment_get_right (self); _tmp397_ = _tmp396_; - _tmp398_ = vala_array_creation_expression_get_initializer_list (G_TYPE_CHECK_INSTANCE_CAST (_tmp397_, VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpression)); + _tmp390_ = VALA_IS_ARRAY_CREATION_EXPRESSION (_tmp397_); + } else { + _tmp390_ = FALSE; + } + if (_tmp390_) { + ValaExpression* _tmp398_; + ValaExpression* _tmp399_; + ValaInitializerList* _tmp400_; + ValaInitializerList* _tmp401_; + _tmp398_ = vala_assignment_get_right (self); _tmp399_ = _tmp398_; - _tmp387_ = _tmp399_ == NULL; + _tmp400_ = vala_array_creation_expression_get_initializer_list (G_TYPE_CHECK_INSTANCE_CAST (_tmp399_, VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpression)); + _tmp401_ = _tmp400_; + _tmp389_ = _tmp401_ == NULL; } else { - _tmp387_ = FALSE; + _tmp389_ = FALSE; } - if (_tmp387_) { - ValaSourceReference* _tmp400_; - ValaSourceReference* _tmp401_; - ValaCodeNode* _tmp402_; - ValaCodeNode* _tmp403_; + if (_tmp389_) { + ValaSourceReference* _tmp402_; + ValaSourceReference* _tmp403_; ValaCodeNode* _tmp404_; ValaCodeNode* _tmp405_; ValaCodeNode* _tmp406_; ValaCodeNode* _tmp407_; - ValaSourceReference* _tmp408_; - ValaSourceReference* _tmp409_; - ValaEmptyStatement* _tmp410_; - ValaEmptyStatement* _tmp411_; - _tmp400_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp401_ = _tmp400_; - vala_report_warning (_tmp401_, "Inline allocated arrays don't require an explicit instantiation"); - _tmp402_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + ValaCodeNode* _tmp408_; + ValaCodeNode* _tmp409_; + ValaSourceReference* _tmp410_; + ValaSourceReference* _tmp411_; + ValaEmptyStatement* _tmp412_; + ValaEmptyStatement* _tmp413_; + _tmp402_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp403_ = _tmp402_; - _tmp404_ = vala_code_node_get_parent_node (_tmp403_); + vala_report_warning (_tmp403_, "Inline allocated arrays don't require an explicit instantiation"); + _tmp404_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); _tmp405_ = _tmp404_; - _tmp406_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp406_ = vala_code_node_get_parent_node (_tmp405_); _tmp407_ = _tmp406_; - _tmp408_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp408_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); _tmp409_ = _tmp408_; - _tmp410_ = vala_empty_statement_new (_tmp409_); + _tmp410_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp411_ = _tmp410_; - vala_block_replace_statement (G_TYPE_CHECK_INSTANCE_CAST (_tmp405_, VALA_TYPE_BLOCK, ValaBlock), G_TYPE_CHECK_INSTANCE_CAST (_tmp407_, VALA_TYPE_STATEMENT, ValaStatement), (ValaStatement*) _tmp411_); - _vala_code_node_unref0 (_tmp411_); + _tmp412_ = vala_empty_statement_new (_tmp411_); + _tmp413_ = _tmp412_; + vala_block_replace_statement (G_TYPE_CHECK_INSTANCE_CAST (_tmp407_, VALA_TYPE_BLOCK, ValaBlock), G_TYPE_CHECK_INSTANCE_CAST (_tmp409_, VALA_TYPE_STATEMENT, ValaStatement), (ValaStatement*) _tmp413_); + _vala_code_node_unref0 (_tmp413_); result = TRUE; return result; } @@ -1567,483 +1571,483 @@ } } } - _tmp413_ = vala_assignment_get_left (self); - _tmp414_ = _tmp413_; - _tmp415_ = vala_expression_get_value_type (_tmp414_); + _tmp415_ = vala_assignment_get_left (self); _tmp416_ = _tmp415_; - if (_tmp416_ != NULL) { - ValaExpression* _tmp417_; - ValaExpression* _tmp418_; - ValaDataType* _tmp419_; - ValaDataType* _tmp420_; - _tmp417_ = vala_assignment_get_right (self); - _tmp418_ = _tmp417_; - _tmp419_ = vala_expression_get_value_type (_tmp418_); + _tmp417_ = vala_expression_get_value_type (_tmp416_); + _tmp418_ = _tmp417_; + if (_tmp418_ != NULL) { + ValaExpression* _tmp419_; + ValaExpression* _tmp420_; + ValaDataType* _tmp421_; + ValaDataType* _tmp422_; + _tmp419_ = vala_assignment_get_right (self); _tmp420_ = _tmp419_; - _tmp412_ = _tmp420_ != NULL; + _tmp421_ = vala_expression_get_value_type (_tmp420_); + _tmp422_ = _tmp421_; + _tmp414_ = _tmp422_ != NULL; } else { - _tmp412_ = FALSE; + _tmp414_ = FALSE; } - if (_tmp412_) { - ValaExpression* _tmp421_; - ValaExpression* _tmp422_; - ValaDataType* _tmp423_; - ValaDataType* _tmp424_; - ValaExpression* _tmp425_; - ValaExpression* _tmp426_; - ValaDataType* _tmp427_; - ValaDataType* _tmp428_; - ValaMemberAccess* _tmp443_; - ValaSymbol* _tmp444_; - ValaSymbol* _tmp445_; - _tmp421_ = vala_assignment_get_right (self); - _tmp422_ = _tmp421_; - _tmp423_ = vala_expression_get_value_type (_tmp422_); + if (_tmp414_) { + ValaExpression* _tmp423_; + ValaExpression* _tmp424_; + ValaDataType* _tmp425_; + ValaDataType* _tmp426_; + ValaExpression* _tmp427_; + ValaExpression* _tmp428_; + ValaDataType* _tmp429_; + ValaDataType* _tmp430_; + ValaMemberAccess* _tmp445_; + ValaSymbol* _tmp446_; + ValaSymbol* _tmp447_; + _tmp423_ = vala_assignment_get_right (self); _tmp424_ = _tmp423_; - _tmp425_ = vala_assignment_get_left (self); + _tmp425_ = vala_expression_get_value_type (_tmp424_); _tmp426_ = _tmp425_; - _tmp427_ = vala_expression_get_value_type (_tmp426_); + _tmp427_ = vala_assignment_get_left (self); _tmp428_ = _tmp427_; - if (!vala_data_type_compatible (_tmp424_, _tmp428_)) { - ValaSourceReference* _tmp429_; - ValaSourceReference* _tmp430_; - ValaExpression* _tmp431_; - ValaExpression* _tmp432_; - ValaDataType* _tmp433_; - ValaDataType* _tmp434_; - gchar* _tmp435_; - gchar* _tmp436_; - ValaExpression* _tmp437_; - ValaExpression* _tmp438_; - ValaDataType* _tmp439_; - ValaDataType* _tmp440_; - gchar* _tmp441_; - gchar* _tmp442_; + _tmp429_ = vala_expression_get_value_type (_tmp428_); + _tmp430_ = _tmp429_; + if (!vala_data_type_compatible (_tmp426_, _tmp430_)) { + ValaSourceReference* _tmp431_; + ValaSourceReference* _tmp432_; + ValaExpression* _tmp433_; + ValaExpression* _tmp434_; + ValaDataType* _tmp435_; + ValaDataType* _tmp436_; + gchar* _tmp437_; + gchar* _tmp438_; + ValaExpression* _tmp439_; + ValaExpression* _tmp440_; + ValaDataType* _tmp441_; + ValaDataType* _tmp442_; + gchar* _tmp443_; + gchar* _tmp444_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp429_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp430_ = _tmp429_; - _tmp431_ = vala_assignment_get_right (self); + _tmp431_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp432_ = _tmp431_; - _tmp433_ = vala_expression_get_value_type (_tmp432_); + _tmp433_ = vala_assignment_get_right (self); _tmp434_ = _tmp433_; - _tmp435_ = vala_code_node_to_string ((ValaCodeNode*) _tmp434_); + _tmp435_ = vala_expression_get_value_type (_tmp434_); _tmp436_ = _tmp435_; - _tmp437_ = vala_assignment_get_left (self); + _tmp437_ = vala_code_node_to_string ((ValaCodeNode*) _tmp436_); _tmp438_ = _tmp437_; - _tmp439_ = vala_expression_get_value_type (_tmp438_); + _tmp439_ = vala_assignment_get_left (self); _tmp440_ = _tmp439_; - _tmp441_ = vala_code_node_to_string ((ValaCodeNode*) _tmp440_); + _tmp441_ = vala_expression_get_value_type (_tmp440_); _tmp442_ = _tmp441_; - vala_report_error (_tmp430_, "Assignment: Cannot convert from `%s' to `%s'", _tmp436_, _tmp442_); - _g_free0 (_tmp442_); - _g_free0 (_tmp436_); + _tmp443_ = vala_code_node_to_string ((ValaCodeNode*) _tmp442_); + _tmp444_ = _tmp443_; + vala_report_error (_tmp432_, "Assignment: Cannot convert from `%s' to `%s'", _tmp438_, _tmp444_); + _g_free0 (_tmp444_); + _g_free0 (_tmp438_); result = FALSE; return result; } - _tmp443_ = ma; - _tmp444_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp443_); - _tmp445_ = _tmp444_; - if (!VALA_IS_PROPERTY (_tmp445_)) { - ValaExpression* _tmp446_; - ValaExpression* _tmp447_; - ValaDataType* _tmp448_; - ValaDataType* _tmp449_; - _tmp446_ = vala_assignment_get_right (self); - _tmp447_ = _tmp446_; - _tmp448_ = vala_expression_get_value_type (_tmp447_); + _tmp445_ = ma; + _tmp446_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp445_); + _tmp447_ = _tmp446_; + if (!VALA_IS_PROPERTY (_tmp447_)) { + ValaExpression* _tmp448_; + ValaExpression* _tmp449_; + ValaDataType* _tmp450_; + ValaDataType* _tmp451_; + _tmp448_ = vala_assignment_get_right (self); _tmp449_ = _tmp448_; - if (vala_data_type_is_disposable (_tmp449_)) { - gboolean _tmp450_ = FALSE; - ValaExpression* _tmp451_; - ValaExpression* _tmp452_; - ValaDataType* _tmp453_; - ValaDataType* _tmp454_; - _tmp451_ = vala_assignment_get_left (self); - _tmp452_ = _tmp451_; - _tmp453_ = vala_expression_get_value_type (_tmp452_); + _tmp450_ = vala_expression_get_value_type (_tmp449_); + _tmp451_ = _tmp450_; + if (vala_data_type_is_disposable (_tmp451_)) { + gboolean _tmp452_ = FALSE; + ValaExpression* _tmp453_; + ValaExpression* _tmp454_; + ValaDataType* _tmp455_; + ValaDataType* _tmp456_; + _tmp453_ = vala_assignment_get_left (self); _tmp454_ = _tmp453_; - if (!VALA_IS_POINTER_TYPE (_tmp454_)) { - ValaExpression* _tmp455_; - ValaExpression* _tmp456_; - ValaDataType* _tmp457_; - ValaDataType* _tmp458_; - gboolean _tmp459_; - gboolean _tmp460_; - _tmp455_ = vala_assignment_get_left (self); - _tmp456_ = _tmp455_; - _tmp457_ = vala_expression_get_value_type (_tmp456_); + _tmp455_ = vala_expression_get_value_type (_tmp454_); + _tmp456_ = _tmp455_; + if (!VALA_IS_POINTER_TYPE (_tmp456_)) { + ValaExpression* _tmp457_; + ValaExpression* _tmp458_; + ValaDataType* _tmp459_; + ValaDataType* _tmp460_; + gboolean _tmp461_; + gboolean _tmp462_; + _tmp457_ = vala_assignment_get_left (self); _tmp458_ = _tmp457_; - _tmp459_ = vala_data_type_get_value_owned (_tmp458_); + _tmp459_ = vala_expression_get_value_type (_tmp458_); _tmp460_ = _tmp459_; - _tmp450_ = !_tmp460_; + _tmp461_ = vala_data_type_get_value_owned (_tmp460_); + _tmp462_ = _tmp461_; + _tmp452_ = !_tmp462_; } else { - _tmp450_ = FALSE; + _tmp452_ = FALSE; } - if (_tmp450_) { - ValaSourceReference* _tmp461_; - ValaSourceReference* _tmp462_; + if (_tmp452_) { + ValaSourceReference* _tmp463_; + ValaSourceReference* _tmp464_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp461_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp462_ = _tmp461_; - vala_report_error (_tmp462_, "Invalid assignment from owned expression to unowned variable"); + _tmp463_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp464_ = _tmp463_; + vala_report_error (_tmp464_, "Invalid assignment from owned expression to unowned variable"); } } else { - ValaExpression* _tmp463_; - ValaExpression* _tmp464_; - ValaDataType* _tmp465_; - ValaDataType* _tmp466_; - gboolean _tmp467_; - gboolean _tmp468_; - _tmp463_ = vala_assignment_get_left (self); - _tmp464_ = _tmp463_; - _tmp465_ = vala_expression_get_value_type (_tmp464_); + ValaExpression* _tmp465_; + ValaExpression* _tmp466_; + ValaDataType* _tmp467_; + ValaDataType* _tmp468_; + gboolean _tmp469_; + gboolean _tmp470_; + _tmp465_ = vala_assignment_get_left (self); _tmp466_ = _tmp465_; - _tmp467_ = vala_data_type_get_value_owned (_tmp466_); + _tmp467_ = vala_expression_get_value_type (_tmp466_); _tmp468_ = _tmp467_; - if (_tmp468_) { + _tmp469_ = vala_data_type_get_value_owned (_tmp468_); + _tmp470_ = _tmp469_; + if (_tmp470_) { } } } } - _tmp469_ = vala_assignment_get_right (self); - _tmp470_ = _tmp469_; - right_ma = VALA_IS_MEMBER_ACCESS (_tmp470_) ? ((ValaMemberAccess*) _tmp470_) : NULL; - _tmp472_ = right_ma; - if (_tmp472_ != NULL) { - ValaMemberAccess* _tmp473_; - ValaSymbol* _tmp474_; - ValaSymbol* _tmp475_; - ValaMemberAccess* _tmp476_; + _tmp471_ = vala_assignment_get_right (self); + _tmp472_ = _tmp471_; + right_ma = VALA_IS_MEMBER_ACCESS (_tmp472_) ? ((ValaMemberAccess*) _tmp472_) : NULL; + _tmp474_ = right_ma; + if (_tmp474_ != NULL) { + ValaMemberAccess* _tmp475_; + ValaSymbol* _tmp476_; ValaSymbol* _tmp477_; - ValaSymbol* _tmp478_; - _tmp473_ = ma; - _tmp474_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp473_); - _tmp475_ = _tmp474_; - _tmp476_ = right_ma; - _tmp477_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp476_); - _tmp478_ = _tmp477_; - _tmp471_ = _tmp475_ == _tmp478_; + ValaMemberAccess* _tmp478_; + ValaSymbol* _tmp479_; + ValaSymbol* _tmp480_; + _tmp475_ = ma; + _tmp476_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp475_); + _tmp477_ = _tmp476_; + _tmp478_ = right_ma; + _tmp479_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp478_); + _tmp480_ = _tmp479_; + _tmp473_ = _tmp477_ == _tmp480_; } else { - _tmp471_ = FALSE; + _tmp473_ = FALSE; } - if (_tmp471_) { - gboolean _tmp479_ = FALSE; - ValaMemberAccess* _tmp480_; - ValaSymbol* _tmp481_; - ValaSymbol* _tmp482_; - _tmp480_ = ma; - _tmp481_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp480_); - _tmp482_ = _tmp481_; - if (VALA_IS_LOCAL_VARIABLE (_tmp482_)) { - _tmp479_ = TRUE; + if (_tmp473_) { + gboolean _tmp481_ = FALSE; + ValaMemberAccess* _tmp482_; + ValaSymbol* _tmp483_; + ValaSymbol* _tmp484_; + _tmp482_ = ma; + _tmp483_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp482_); + _tmp484_ = _tmp483_; + if (VALA_IS_LOCAL_VARIABLE (_tmp484_)) { + _tmp481_ = TRUE; } else { - ValaMemberAccess* _tmp483_; - ValaSymbol* _tmp484_; - ValaSymbol* _tmp485_; - _tmp483_ = ma; - _tmp484_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp483_); - _tmp485_ = _tmp484_; - _tmp479_ = VALA_IS_PARAMETER (_tmp485_); - } - if (_tmp479_) { - ValaSourceReference* _tmp486_; - ValaSourceReference* _tmp487_; - _tmp486_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + ValaMemberAccess* _tmp485_; + ValaSymbol* _tmp486_; + ValaSymbol* _tmp487_; + _tmp485_ = ma; + _tmp486_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp485_); _tmp487_ = _tmp486_; - vala_report_warning (_tmp487_, "Assignment to same variable"); + _tmp481_ = VALA_IS_PARAMETER (_tmp487_); + } + if (_tmp481_) { + ValaSourceReference* _tmp488_; + ValaSourceReference* _tmp489_; + _tmp488_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp489_ = _tmp488_; + vala_report_warning (_tmp489_, "Assignment to same variable"); } else { - ValaMemberAccess* _tmp488_; - ValaSymbol* _tmp489_; - ValaSymbol* _tmp490_; - _tmp488_ = ma; - _tmp489_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp488_); - _tmp490_ = _tmp489_; - if (VALA_IS_FIELD (_tmp490_)) { + ValaMemberAccess* _tmp490_; + ValaSymbol* _tmp491_; + ValaSymbol* _tmp492_; + _tmp490_ = ma; + _tmp491_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp490_); + _tmp492_ = _tmp491_; + if (VALA_IS_FIELD (_tmp492_)) { ValaField* f = NULL; - ValaMemberAccess* _tmp491_; - ValaSymbol* _tmp492_; - ValaSymbol* _tmp493_; - ValaField* _tmp494_; - ValaMemberBinding _tmp495_; - ValaMemberBinding _tmp496_; - _tmp491_ = ma; - _tmp492_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp491_); - _tmp493_ = _tmp492_; - f = G_TYPE_CHECK_INSTANCE_CAST (_tmp493_, VALA_TYPE_FIELD, ValaField); - _tmp494_ = f; - _tmp495_ = vala_field_get_binding (_tmp494_); - _tmp496_ = _tmp495_; - if (_tmp496_ == VALA_MEMBER_BINDING_STATIC) { - ValaSourceReference* _tmp497_; - ValaSourceReference* _tmp498_; - _tmp497_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp498_ = _tmp497_; - vala_report_warning (_tmp498_, "Assignment to same variable"); + ValaMemberAccess* _tmp493_; + ValaSymbol* _tmp494_; + ValaSymbol* _tmp495_; + ValaField* _tmp496_; + ValaMemberBinding _tmp497_; + ValaMemberBinding _tmp498_; + _tmp493_ = ma; + _tmp494_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp493_); + _tmp495_ = _tmp494_; + f = G_TYPE_CHECK_INSTANCE_CAST (_tmp495_, VALA_TYPE_FIELD, ValaField); + _tmp496_ = f; + _tmp497_ = vala_field_get_binding (_tmp496_); + _tmp498_ = _tmp497_; + if (_tmp498_ == VALA_MEMBER_BINDING_STATIC) { + ValaSourceReference* _tmp499_; + ValaSourceReference* _tmp500_; + _tmp499_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp500_ = _tmp499_; + vala_report_warning (_tmp500_, "Assignment to same variable"); } else { ValaMemberAccess* ma_inner = NULL; - ValaMemberAccess* _tmp499_; - ValaExpression* _tmp500_; - ValaExpression* _tmp501_; - ValaMemberAccess* right_ma_inner = NULL; - ValaMemberAccess* _tmp502_; + ValaMemberAccess* _tmp501_; + ValaExpression* _tmp502_; ValaExpression* _tmp503_; - ValaExpression* _tmp504_; - gboolean _tmp505_ = FALSE; - gboolean _tmp506_ = FALSE; + ValaMemberAccess* right_ma_inner = NULL; + ValaMemberAccess* _tmp504_; + ValaExpression* _tmp505_; + ValaExpression* _tmp506_; gboolean _tmp507_ = FALSE; gboolean _tmp508_ = FALSE; gboolean _tmp509_ = FALSE; - ValaMemberAccess* _tmp510_; - _tmp499_ = ma; - _tmp500_ = vala_member_access_get_inner (_tmp499_); - _tmp501_ = _tmp500_; - ma_inner = VALA_IS_MEMBER_ACCESS (_tmp501_) ? ((ValaMemberAccess*) _tmp501_) : NULL; - _tmp502_ = right_ma; - _tmp503_ = vala_member_access_get_inner (_tmp502_); - _tmp504_ = _tmp503_; - right_ma_inner = VALA_IS_MEMBER_ACCESS (_tmp504_) ? ((ValaMemberAccess*) _tmp504_) : NULL; - _tmp510_ = ma_inner; - if (_tmp510_ != NULL) { - ValaMemberAccess* _tmp511_; - const gchar* _tmp512_; - const gchar* _tmp513_; - _tmp511_ = ma_inner; - _tmp512_ = vala_member_access_get_member_name (_tmp511_); - _tmp513_ = _tmp512_; - _tmp509_ = g_strcmp0 (_tmp513_, "this") == 0; + gboolean _tmp510_ = FALSE; + gboolean _tmp511_ = FALSE; + ValaMemberAccess* _tmp512_; + _tmp501_ = ma; + _tmp502_ = vala_member_access_get_inner (_tmp501_); + _tmp503_ = _tmp502_; + ma_inner = VALA_IS_MEMBER_ACCESS (_tmp503_) ? ((ValaMemberAccess*) _tmp503_) : NULL; + _tmp504_ = right_ma; + _tmp505_ = vala_member_access_get_inner (_tmp504_); + _tmp506_ = _tmp505_; + right_ma_inner = VALA_IS_MEMBER_ACCESS (_tmp506_) ? ((ValaMemberAccess*) _tmp506_) : NULL; + _tmp512_ = ma_inner; + if (_tmp512_ != NULL) { + ValaMemberAccess* _tmp513_; + const gchar* _tmp514_; + const gchar* _tmp515_; + _tmp513_ = ma_inner; + _tmp514_ = vala_member_access_get_member_name (_tmp513_); + _tmp515_ = _tmp514_; + _tmp511_ = g_strcmp0 (_tmp515_, "this") == 0; + } else { + _tmp511_ = FALSE; + } + if (_tmp511_) { + ValaMemberAccess* _tmp516_; + ValaExpression* _tmp517_; + ValaExpression* _tmp518_; + _tmp516_ = ma_inner; + _tmp517_ = vala_member_access_get_inner (_tmp516_); + _tmp518_ = _tmp517_; + _tmp510_ = _tmp518_ == NULL; + } else { + _tmp510_ = FALSE; + } + if (_tmp510_) { + ValaMemberAccess* _tmp519_; + _tmp519_ = right_ma_inner; + _tmp509_ = _tmp519_ != NULL; } else { _tmp509_ = FALSE; } if (_tmp509_) { - ValaMemberAccess* _tmp514_; - ValaExpression* _tmp515_; - ValaExpression* _tmp516_; - _tmp514_ = ma_inner; - _tmp515_ = vala_member_access_get_inner (_tmp514_); - _tmp516_ = _tmp515_; - _tmp508_ = _tmp516_ == NULL; + ValaMemberAccess* _tmp520_; + const gchar* _tmp521_; + const gchar* _tmp522_; + _tmp520_ = right_ma_inner; + _tmp521_ = vala_member_access_get_member_name (_tmp520_); + _tmp522_ = _tmp521_; + _tmp508_ = g_strcmp0 (_tmp522_, "this") == 0; } else { _tmp508_ = FALSE; } if (_tmp508_) { - ValaMemberAccess* _tmp517_; - _tmp517_ = right_ma_inner; - _tmp507_ = _tmp517_ != NULL; + ValaMemberAccess* _tmp523_; + ValaExpression* _tmp524_; + ValaExpression* _tmp525_; + _tmp523_ = right_ma_inner; + _tmp524_ = vala_member_access_get_inner (_tmp523_); + _tmp525_ = _tmp524_; + _tmp507_ = _tmp525_ == NULL; } else { _tmp507_ = FALSE; } if (_tmp507_) { - ValaMemberAccess* _tmp518_; - const gchar* _tmp519_; - const gchar* _tmp520_; - _tmp518_ = right_ma_inner; - _tmp519_ = vala_member_access_get_member_name (_tmp518_); - _tmp520_ = _tmp519_; - _tmp506_ = g_strcmp0 (_tmp520_, "this") == 0; - } else { - _tmp506_ = FALSE; - } - if (_tmp506_) { - ValaMemberAccess* _tmp521_; - ValaExpression* _tmp522_; - ValaExpression* _tmp523_; - _tmp521_ = right_ma_inner; - _tmp522_ = vala_member_access_get_inner (_tmp521_); - _tmp523_ = _tmp522_; - _tmp505_ = _tmp523_ == NULL; - } else { - _tmp505_ = FALSE; - } - if (_tmp505_) { - ValaSourceReference* _tmp524_; - ValaSourceReference* _tmp525_; - _tmp524_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp525_ = _tmp524_; - vala_report_warning (_tmp525_, "Assignment to same variable"); + ValaSourceReference* _tmp526_; + ValaSourceReference* _tmp527_; + _tmp526_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp527_ = _tmp526_; + vala_report_warning (_tmp527_, "Assignment to same variable"); } } } } } } else { - ValaExpression* _tmp526_; - ValaExpression* _tmp527_; - _tmp526_ = vala_assignment_get_left (self); - _tmp527_ = _tmp526_; - if (VALA_IS_ELEMENT_ACCESS (_tmp527_)) { + ValaExpression* _tmp528_; + ValaExpression* _tmp529_; + _tmp528_ = vala_assignment_get_left (self); + _tmp529_ = _tmp528_; + if (VALA_IS_ELEMENT_ACCESS (_tmp529_)) { ValaElementAccess* ea = NULL; - ValaExpression* _tmp528_; - ValaExpression* _tmp529_; ValaExpression* _tmp530_; ValaExpression* _tmp531_; - ValaDataType* _tmp532_; - ValaDataType* _tmp533_; - ValaExpression* _tmp534_; - ValaExpression* _tmp535_; - ValaDataType* _tmp536_; - ValaDataType* _tmp537_; - ValaExpression* _tmp552_; - ValaExpression* _tmp553_; - ValaDataType* _tmp554_; - ValaDataType* _tmp555_; - _tmp528_ = vala_assignment_get_left (self); - _tmp529_ = _tmp528_; - ea = G_TYPE_CHECK_INSTANCE_CAST (_tmp529_, VALA_TYPE_ELEMENT_ACCESS, ValaElementAccess); - _tmp530_ = vala_assignment_get_right (self); + ValaExpression* _tmp532_; + ValaExpression* _tmp533_; + ValaDataType* _tmp534_; + ValaDataType* _tmp535_; + ValaExpression* _tmp536_; + ValaExpression* _tmp537_; + ValaDataType* _tmp538_; + ValaDataType* _tmp539_; + ValaExpression* _tmp554_; + ValaExpression* _tmp555_; + ValaDataType* _tmp556_; + ValaDataType* _tmp557_; + _tmp530_ = vala_assignment_get_left (self); _tmp531_ = _tmp530_; - _tmp532_ = vala_expression_get_value_type (_tmp531_); + ea = G_TYPE_CHECK_INSTANCE_CAST (_tmp531_, VALA_TYPE_ELEMENT_ACCESS, ValaElementAccess); + _tmp532_ = vala_assignment_get_right (self); _tmp533_ = _tmp532_; - _tmp534_ = vala_assignment_get_left (self); + _tmp534_ = vala_expression_get_value_type (_tmp533_); _tmp535_ = _tmp534_; - _tmp536_ = vala_expression_get_value_type (_tmp535_); + _tmp536_ = vala_assignment_get_left (self); _tmp537_ = _tmp536_; - if (!vala_data_type_compatible (_tmp533_, _tmp537_)) { - ValaSourceReference* _tmp538_; - ValaSourceReference* _tmp539_; - ValaExpression* _tmp540_; - ValaExpression* _tmp541_; - ValaDataType* _tmp542_; - ValaDataType* _tmp543_; - gchar* _tmp544_; - gchar* _tmp545_; - ValaExpression* _tmp546_; - ValaExpression* _tmp547_; - ValaDataType* _tmp548_; - ValaDataType* _tmp549_; - gchar* _tmp550_; - gchar* _tmp551_; + _tmp538_ = vala_expression_get_value_type (_tmp537_); + _tmp539_ = _tmp538_; + if (!vala_data_type_compatible (_tmp535_, _tmp539_)) { + ValaSourceReference* _tmp540_; + ValaSourceReference* _tmp541_; + ValaExpression* _tmp542_; + ValaExpression* _tmp543_; + ValaDataType* _tmp544_; + ValaDataType* _tmp545_; + gchar* _tmp546_; + gchar* _tmp547_; + ValaExpression* _tmp548_; + ValaExpression* _tmp549_; + ValaDataType* _tmp550_; + ValaDataType* _tmp551_; + gchar* _tmp552_; + gchar* _tmp553_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp538_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp539_ = _tmp538_; - _tmp540_ = vala_assignment_get_right (self); + _tmp540_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp541_ = _tmp540_; - _tmp542_ = vala_expression_get_value_type (_tmp541_); + _tmp542_ = vala_assignment_get_right (self); _tmp543_ = _tmp542_; - _tmp544_ = vala_code_node_to_string ((ValaCodeNode*) _tmp543_); + _tmp544_ = vala_expression_get_value_type (_tmp543_); _tmp545_ = _tmp544_; - _tmp546_ = vala_assignment_get_left (self); + _tmp546_ = vala_code_node_to_string ((ValaCodeNode*) _tmp545_); _tmp547_ = _tmp546_; - _tmp548_ = vala_expression_get_value_type (_tmp547_); + _tmp548_ = vala_assignment_get_left (self); _tmp549_ = _tmp548_; - _tmp550_ = vala_code_node_to_string ((ValaCodeNode*) _tmp549_); + _tmp550_ = vala_expression_get_value_type (_tmp549_); _tmp551_ = _tmp550_; - vala_report_error (_tmp539_, "Assignment: Cannot convert from `%s' to `%s'", _tmp545_, _tmp551_); - _g_free0 (_tmp551_); - _g_free0 (_tmp545_); + _tmp552_ = vala_code_node_to_string ((ValaCodeNode*) _tmp551_); + _tmp553_ = _tmp552_; + vala_report_error (_tmp541_, "Assignment: Cannot convert from `%s' to `%s'", _tmp547_, _tmp553_); + _g_free0 (_tmp553_); + _g_free0 (_tmp547_); result = FALSE; return result; } - _tmp552_ = vala_assignment_get_right (self); - _tmp553_ = _tmp552_; - _tmp554_ = vala_expression_get_value_type (_tmp553_); + _tmp554_ = vala_assignment_get_right (self); _tmp555_ = _tmp554_; - if (vala_data_type_is_disposable (_tmp555_)) { + _tmp556_ = vala_expression_get_value_type (_tmp555_); + _tmp557_ = _tmp556_; + if (vala_data_type_is_disposable (_tmp557_)) { ValaDataType* element_type = NULL; - ValaElementAccess* _tmp556_; - ValaExpression* _tmp557_; - ValaExpression* _tmp558_; - ValaDataType* _tmp559_; - ValaDataType* _tmp560_; - gboolean _tmp582_ = FALSE; - ValaDataType* _tmp583_; - _tmp556_ = ea; - _tmp557_ = vala_element_access_get_container (_tmp556_); - _tmp558_ = _tmp557_; - _tmp559_ = vala_expression_get_value_type (_tmp558_); + ValaElementAccess* _tmp558_; + ValaExpression* _tmp559_; + ValaExpression* _tmp560_; + ValaDataType* _tmp561_; + ValaDataType* _tmp562_; + gboolean _tmp584_ = FALSE; + ValaDataType* _tmp585_; + _tmp558_ = ea; + _tmp559_ = vala_element_access_get_container (_tmp558_); _tmp560_ = _tmp559_; - if (VALA_IS_ARRAY_TYPE (_tmp560_)) { + _tmp561_ = vala_expression_get_value_type (_tmp560_); + _tmp562_ = _tmp561_; + if (VALA_IS_ARRAY_TYPE (_tmp562_)) { ValaArrayType* array_type = NULL; - ValaElementAccess* _tmp561_; - ValaExpression* _tmp562_; - ValaExpression* _tmp563_; - ValaDataType* _tmp564_; - ValaDataType* _tmp565_; - ValaArrayType* _tmp566_; + ValaElementAccess* _tmp563_; + ValaExpression* _tmp564_; + ValaExpression* _tmp565_; + ValaDataType* _tmp566_; ValaDataType* _tmp567_; - ValaDataType* _tmp568_; + ValaArrayType* _tmp568_; ValaDataType* _tmp569_; - _tmp561_ = ea; - _tmp562_ = vala_element_access_get_container (_tmp561_); - _tmp563_ = _tmp562_; - _tmp564_ = vala_expression_get_value_type (_tmp563_); + ValaDataType* _tmp570_; + ValaDataType* _tmp571_; + _tmp563_ = ea; + _tmp564_ = vala_element_access_get_container (_tmp563_); _tmp565_ = _tmp564_; - array_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp565_, VALA_TYPE_ARRAY_TYPE, ValaArrayType); - _tmp566_ = array_type; - _tmp567_ = vala_array_type_get_element_type (_tmp566_); - _tmp568_ = _tmp567_; - _tmp569_ = _vala_code_node_ref0 (_tmp568_); + _tmp566_ = vala_expression_get_value_type (_tmp565_); + _tmp567_ = _tmp566_; + array_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp567_, VALA_TYPE_ARRAY_TYPE, ValaArrayType); + _tmp568_ = array_type; + _tmp569_ = vala_array_type_get_element_type (_tmp568_); + _tmp570_ = _tmp569_; + _tmp571_ = _vala_code_node_ref0 (_tmp570_); _vala_code_node_unref0 (element_type); - element_type = _tmp569_; + element_type = _tmp571_; } else { ValaList* args = NULL; - ValaElementAccess* _tmp570_; - ValaExpression* _tmp571_; - ValaExpression* _tmp572_; - ValaDataType* _tmp573_; - ValaDataType* _tmp574_; - ValaList* _tmp575_; - ValaList* _tmp576_; + ValaElementAccess* _tmp572_; + ValaExpression* _tmp573_; + ValaExpression* _tmp574_; + ValaDataType* _tmp575_; + ValaDataType* _tmp576_; ValaList* _tmp577_; - gint _tmp578_; - gint _tmp579_; - ValaList* _tmp580_; - gpointer _tmp581_; - _tmp570_ = ea; - _tmp571_ = vala_element_access_get_container (_tmp570_); - _tmp572_ = _tmp571_; - _tmp573_ = vala_expression_get_value_type (_tmp572_); + ValaList* _tmp578_; + ValaList* _tmp579_; + gint _tmp580_; + gint _tmp581_; + ValaList* _tmp582_; + gpointer _tmp583_; + _tmp572_ = ea; + _tmp573_ = vala_element_access_get_container (_tmp572_); _tmp574_ = _tmp573_; - _tmp575_ = vala_data_type_get_type_arguments (_tmp574_); - _tmp576_ = _vala_iterable_ref0 (_tmp575_); - args = _tmp576_; - _tmp577_ = args; - _tmp578_ = vala_collection_get_size ((ValaCollection*) _tmp577_); - _tmp579_ = _tmp578_; - _vala_assert (_tmp579_ == 1, "args.size == 1"); - _tmp580_ = args; - _tmp581_ = vala_list_get (_tmp580_, 0); + _tmp575_ = vala_expression_get_value_type (_tmp574_); + _tmp576_ = _tmp575_; + _tmp577_ = vala_data_type_get_type_arguments (_tmp576_); + _tmp578_ = _vala_iterable_ref0 (_tmp577_); + args = _tmp578_; + _tmp579_ = args; + _tmp580_ = vala_collection_get_size ((ValaCollection*) _tmp579_); + _tmp581_ = _tmp580_; + _vala_assert (_tmp581_ == 1, "args.size == 1"); + _tmp582_ = args; + _tmp583_ = vala_list_get (_tmp582_, 0); _vala_code_node_unref0 (element_type); - element_type = (ValaDataType*) _tmp581_; + element_type = (ValaDataType*) _tmp583_; _vala_iterable_unref0 (args); } - _tmp583_ = element_type; - if (!VALA_IS_POINTER_TYPE (_tmp583_)) { - ValaDataType* _tmp584_; - gboolean _tmp585_; - gboolean _tmp586_; - _tmp584_ = element_type; - _tmp585_ = vala_data_type_get_value_owned (_tmp584_); - _tmp586_ = _tmp585_; - _tmp582_ = !_tmp586_; + _tmp585_ = element_type; + if (!VALA_IS_POINTER_TYPE (_tmp585_)) { + ValaDataType* _tmp586_; + gboolean _tmp587_; + gboolean _tmp588_; + _tmp586_ = element_type; + _tmp587_ = vala_data_type_get_value_owned (_tmp586_); + _tmp588_ = _tmp587_; + _tmp584_ = !_tmp588_; } else { - _tmp582_ = FALSE; + _tmp584_ = FALSE; } - if (_tmp582_) { - ValaSourceReference* _tmp587_; - ValaSourceReference* _tmp588_; + if (_tmp584_) { + ValaSourceReference* _tmp589_; + ValaSourceReference* _tmp590_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp587_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp588_ = _tmp587_; - vala_report_error (_tmp588_, "Invalid assignment from owned expression to unowned variable"); + _tmp589_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp590_ = _tmp589_; + vala_report_error (_tmp590_, "Invalid assignment from owned expression to unowned variable"); result = FALSE; _vala_code_node_unref0 (element_type); return result; } _vala_code_node_unref0 (element_type); } else { - ValaExpression* _tmp589_; - ValaExpression* _tmp590_; - ValaDataType* _tmp591_; - ValaDataType* _tmp592_; - gboolean _tmp593_; - gboolean _tmp594_; - _tmp589_ = vala_assignment_get_left (self); - _tmp590_ = _tmp589_; - _tmp591_ = vala_expression_get_value_type (_tmp590_); + ValaExpression* _tmp591_; + ValaExpression* _tmp592_; + ValaDataType* _tmp593_; + ValaDataType* _tmp594_; + gboolean _tmp595_; + gboolean _tmp596_; + _tmp591_ = vala_assignment_get_left (self); _tmp592_ = _tmp591_; - _tmp593_ = vala_data_type_get_value_owned (_tmp592_); + _tmp593_ = vala_expression_get_value_type (_tmp592_); _tmp594_ = _tmp593_; - if (_tmp594_) { + _tmp595_ = vala_data_type_get_value_owned (_tmp594_); + _tmp596_ = _tmp595_; + if (_tmp596_) { } } } else { @@ -2051,45 +2055,45 @@ return result; } } - _tmp595_ = vala_assignment_get_left (self); - _tmp596_ = _tmp595_; - _tmp597_ = vala_expression_get_value_type (_tmp596_); + _tmp597_ = vala_assignment_get_left (self); _tmp598_ = _tmp597_; - if (_tmp598_ != NULL) { - ValaExpression* _tmp599_; - ValaExpression* _tmp600_; - ValaDataType* _tmp601_; - ValaDataType* _tmp602_; + _tmp599_ = vala_expression_get_value_type (_tmp598_); + _tmp600_ = _tmp599_; + if (_tmp600_ != NULL) { + ValaExpression* _tmp601_; + ValaExpression* _tmp602_; ValaDataType* _tmp603_; ValaDataType* _tmp604_; ValaDataType* _tmp605_; ValaDataType* _tmp606_; - _tmp599_ = vala_assignment_get_left (self); - _tmp600_ = _tmp599_; - _tmp601_ = vala_expression_get_value_type (_tmp600_); + ValaDataType* _tmp607_; + ValaDataType* _tmp608_; + _tmp601_ = vala_assignment_get_left (self); _tmp602_ = _tmp601_; - _tmp603_ = vala_data_type_copy (_tmp602_); + _tmp603_ = vala_expression_get_value_type (_tmp602_); _tmp604_ = _tmp603_; - vala_expression_set_value_type ((ValaExpression*) self, _tmp604_); - _vala_code_node_unref0 (_tmp604_); - _tmp605_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp605_ = vala_data_type_copy (_tmp604_); _tmp606_ = _tmp605_; - vala_data_type_set_value_owned (_tmp606_, FALSE); + vala_expression_set_value_type ((ValaExpression*) self, _tmp606_); + _vala_code_node_unref0 (_tmp606_); + _tmp607_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp608_ = _tmp607_; + vala_data_type_set_value_owned (_tmp608_, FALSE); } else { vala_expression_set_value_type ((ValaExpression*) self, NULL); } - _tmp607_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp608_ = _tmp607_; - if (_tmp608_ != NULL) { - ValaDataType* _tmp609_; - ValaDataType* _tmp610_; - _tmp609_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp610_ = _tmp609_; - vala_code_node_check ((ValaCodeNode*) _tmp610_, context); + _tmp609_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp610_ = _tmp609_; + if (_tmp610_ != NULL) { + ValaDataType* _tmp611_; + ValaDataType* _tmp612_; + _tmp611_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp612_ = _tmp611_; + vala_code_node_check ((ValaCodeNode*) _tmp612_, context); } - _tmp611_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp612_ = _tmp611_; - result = !_tmp612_; + _tmp613_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp614_ = _tmp613_; + result = !_tmp614_; return result; } diff -Nru vala-0.52.6/vala/valaassignment.vala vala-0.52.7/vala/valaassignment.vala --- vala-0.52.6/vala/valaassignment.vala 2021-09-30 15:37:07.000000000 +0000 +++ vala-0.52.7/vala/valaassignment.vala 2021-10-26 12:38:24.000000000 +0000 @@ -235,7 +235,7 @@ // FIXME: only do this if the backend doesn't support // the assignment natively - var old_value = new MemberAccess (ma.inner, ma.member_name); + var old_value = new MemberAccess (ma.inner, ma.member_name, source_reference); BinaryOperator bop; diff -Nru vala-0.52.6/vala/valacallabletype.c vala-0.52.7/vala/valacallabletype.c --- vala-0.52.6/vala/valacallabletype.c 2021-10-04 09:46:51.000000000 +0000 +++ vala-0.52.7/vala/valacallabletype.c 2021-10-30 08:24:05.000000000 +0000 @@ -137,13 +137,15 @@ ValaArrayList* error_types = NULL; GEqualFunc _tmp109_; ValaArrayList* _tmp110_; - ValaArrayList* _tmp111_; - ValaArrayList* _tmp112_; - gint _tmp113_; - gint _tmp114_; - GString* _tmp129_; - const gchar* _tmp130_; - gchar* _tmp131_; + ValaCallable* _tmp111_; + ValaCallable* _tmp112_; + ValaArrayList* _tmp113_; + ValaArrayList* _tmp114_; + gint _tmp115_; + gint _tmp116_; + GString* _tmp131_; + const gchar* _tmp132_; + gchar* _tmp133_; gchar* result = NULL; self = (ValaCallableType*) base; _tmp0_ = g_string_new (""); @@ -460,72 +462,74 @@ _tmp109_ = g_direct_equal; _tmp110_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp109_); error_types = _tmp110_; - _tmp111_ = error_types; - vala_code_node_get_error_types ((ValaCodeNode*) self, (ValaCollection*) _tmp111_, NULL); - _tmp112_ = error_types; - _tmp113_ = vala_collection_get_size ((ValaCollection*) _tmp112_); - _tmp114_ = _tmp113_; - if (_tmp114_ > 0) { - GString* _tmp115_; + _tmp111_ = vala_callable_type_get_callable_symbol (self); + _tmp112_ = _tmp111_; + _tmp113_ = error_types; + vala_code_node_get_error_types ((ValaCodeNode*) _tmp112_, (ValaCollection*) _tmp113_, NULL); + _tmp114_ = error_types; + _tmp115_ = vala_collection_get_size ((ValaCollection*) _tmp114_); + _tmp116_ = _tmp115_; + if (_tmp116_ > 0) { + GString* _tmp117_; gboolean first = FALSE; - _tmp115_ = builder; - g_string_append (_tmp115_, " throws "); + _tmp117_ = builder; + g_string_append (_tmp117_, " throws "); first = TRUE; { ValaArrayList* _type_list = NULL; - ValaArrayList* _tmp116_; + ValaArrayList* _tmp118_; gint _type_size = 0; - ValaArrayList* _tmp117_; - gint _tmp118_; - gint _tmp119_; + ValaArrayList* _tmp119_; + gint _tmp120_; + gint _tmp121_; gint _type_index = 0; - _tmp116_ = error_types; - _type_list = _tmp116_; - _tmp117_ = _type_list; - _tmp118_ = vala_collection_get_size ((ValaCollection*) _tmp117_); - _tmp119_ = _tmp118_; - _type_size = _tmp119_; + _tmp118_ = error_types; + _type_list = _tmp118_; + _tmp119_ = _type_list; + _tmp120_ = vala_collection_get_size ((ValaCollection*) _tmp119_); + _tmp121_ = _tmp120_; + _type_size = _tmp121_; _type_index = -1; while (TRUE) { - gint _tmp120_; - gint _tmp121_; + gint _tmp122_; + gint _tmp123_; ValaDataType* type = NULL; - ValaArrayList* _tmp122_; - gpointer _tmp123_; - GString* _tmp125_; - ValaDataType* _tmp126_; - gchar* _tmp127_; - gchar* _tmp128_; + ValaArrayList* _tmp124_; + gpointer _tmp125_; + GString* _tmp127_; + ValaDataType* _tmp128_; + gchar* _tmp129_; + gchar* _tmp130_; _type_index = _type_index + 1; - _tmp120_ = _type_index; - _tmp121_ = _type_size; - if (!(_tmp120_ < _tmp121_)) { + _tmp122_ = _type_index; + _tmp123_ = _type_size; + if (!(_tmp122_ < _tmp123_)) { break; } - _tmp122_ = _type_list; - _tmp123_ = vala_list_get ((ValaList*) _tmp122_, _type_index); - type = (ValaDataType*) _tmp123_; + _tmp124_ = _type_list; + _tmp125_ = vala_list_get ((ValaList*) _tmp124_, _type_index); + type = (ValaDataType*) _tmp125_; if (!first) { - GString* _tmp124_; - _tmp124_ = builder; - g_string_append (_tmp124_, ", "); + GString* _tmp126_; + _tmp126_ = builder; + g_string_append (_tmp126_, ", "); } else { first = FALSE; } - _tmp125_ = builder; - _tmp126_ = type; - _tmp127_ = vala_code_node_to_string ((ValaCodeNode*) _tmp126_); - _tmp128_ = _tmp127_; - g_string_append (_tmp125_, _tmp128_); - _g_free0 (_tmp128_); + _tmp127_ = builder; + _tmp128_ = type; + _tmp129_ = vala_code_node_to_string ((ValaCodeNode*) _tmp128_); + _tmp130_ = _tmp129_; + g_string_append (_tmp127_, _tmp130_); + _g_free0 (_tmp130_); _vala_code_node_unref0 (type); } } } - _tmp129_ = builder; - _tmp130_ = _tmp129_->str; - _tmp131_ = g_strdup (_tmp130_); - result = _tmp131_; + _tmp131_ = builder; + _tmp132_ = _tmp131_->str; + _tmp133_ = g_strdup (_tmp132_); + result = _tmp133_; _vala_iterable_unref0 (error_types); _g_free0 (_tmp23_); _g_string_free0 (builder); diff -Nru vala-0.52.6/vala/valacallabletype.vala vala-0.52.7/vala/valacallabletype.vala --- vala-0.52.6/vala/valacallabletype.vala 2021-10-04 06:42:32.000000000 +0000 +++ vala-0.52.7/vala/valacallabletype.vala 2021-10-30 07:37:56.000000000 +0000 @@ -127,7 +127,7 @@ // Append error-types var error_types = new ArrayList (); - get_error_types (error_types); + callable_symbol.get_error_types (error_types); if (error_types.size > 0) { builder.append (" throws "); diff -Nru vala-0.52.6/vala/valacodenode.c vala-0.52.7/vala/valacodenode.c --- vala-0.52.6/vala/valacodenode.c 2021-10-04 09:46:51.000000000 +0000 +++ vala-0.52.7/vala/valacodenode.c 2021-10-30 08:24:05.000000000 +0000 @@ -510,6 +510,46 @@ * @param name attribute name * @param value true to add the attribute, false to remove it */ +static GList* +vala_g_list_remove_full (GList* self, + gconstpointer data, + GFreeFunc func) +{ + GList* l = NULL; + GList* result = NULL; + l = self; + while (TRUE) { + GList* _tmp0_; + GList* _tmp1_; + gconstpointer _tmp2_; + _tmp0_ = l; + if (!(_tmp0_ != NULL)) { + break; + } + _tmp1_ = l; + _tmp2_ = ((GList*) _tmp1_)->data; + if (_tmp2_ != data) { + GList* _tmp3_; + GList* _tmp4_; + _tmp3_ = l; + _tmp4_ = ((GList*) _tmp3_)->next; + l = _tmp4_; + } else { + GList* _tmp5_; + gconstpointer _tmp6_; + GList* _tmp7_; + _tmp5_ = l; + _tmp6_ = ((GList*) _tmp5_)->data; + func (_tmp6_); + _tmp7_ = l; + self = g_list_delete_link (self, (GList*) _tmp7_); + break; + } + } + result = self; + return result; +} + void vala_code_node_set_attribute (ValaCodeNode* self, const gchar* name, @@ -546,7 +586,7 @@ if (_tmp4_) { ValaAttribute* _tmp6_; _tmp6_ = a; - self->attributes = g_list_remove (self->attributes, _tmp6_); + self->attributes = vala_g_list_remove_full (self->attributes, _tmp6_, _vala_code_node_unref0_); } } } @@ -592,7 +632,7 @@ if (_tmp9_ == 0) { ValaAttribute* _tmp10_; _tmp10_ = a; - self->attributes = g_list_remove (self->attributes, _tmp10_); + self->attributes = vala_g_list_remove_full (self->attributes, _tmp10_, _vala_code_node_unref0_); } } } diff -Nru vala-0.52.6/vala/valacodewriter.c vala-0.52.7/vala/valacodewriter.c --- vala-0.52.6/vala/valacodewriter.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valacodewriter.c 2021-10-30 08:24:05.000000000 +0000 @@ -4027,8 +4027,33 @@ ValaForeachStatement* stmt) { ValaCodeWriter * self; + ValaDataType* _tmp0_; + ValaDataType* _tmp1_; + const gchar* _tmp2_; + const gchar* _tmp3_; + ValaExpression* _tmp4_; + ValaExpression* _tmp5_; + ValaBlock* _tmp6_; + ValaBlock* _tmp7_; self = (ValaCodeWriter*) base; g_return_if_fail (stmt != NULL); + vala_code_writer_write_indent (self); + vala_code_writer_write_string (self, "foreach ("); + _tmp0_ = vala_foreach_statement_get_type_reference (stmt); + _tmp1_ = _tmp0_; + vala_code_writer_write_type (self, _tmp1_); + vala_code_writer_write_string (self, " "); + _tmp2_ = vala_foreach_statement_get_variable_name (stmt); + _tmp3_ = _tmp2_; + vala_code_writer_write_string (self, _tmp3_); + vala_code_writer_write_string (self, " in "); + _tmp4_ = vala_foreach_statement_get_collection (stmt); + _tmp5_ = _tmp4_; + vala_code_node_accept ((ValaCodeNode*) _tmp5_, (ValaCodeVisitor*) self); + vala_code_writer_write_string (self, ")"); + _tmp6_ = vala_foreach_statement_get_body (stmt); + _tmp7_ = _tmp6_; + vala_code_node_accept ((ValaCodeNode*) _tmp7_, (ValaCodeVisitor*) self); } static void @@ -4211,66 +4236,59 @@ ValaCatchClause* clause) { ValaCodeWriter * self; - gchar* _tmp0_ = NULL; - ValaDataType* _tmp1_; - ValaDataType* _tmp2_; - gchar* type_name = NULL; - gchar* _tmp7_; - const gchar* _tmp8_ = NULL; - const gchar* _tmp9_; - const gchar* _tmp10_; - gchar* var_name = NULL; - gchar* _tmp13_; - const gchar* _tmp14_; - gchar* _tmp15_; - gchar* _tmp16_; - ValaBlock* _tmp17_; - ValaBlock* _tmp18_; + const gchar* _tmp0_; + const gchar* _tmp1_; + ValaBlock* _tmp15_; + ValaBlock* _tmp16_; self = (ValaCodeWriter*) base; g_return_if_fail (clause != NULL); - _tmp1_ = vala_catch_clause_get_error_type (clause); - _tmp2_ = _tmp1_; - if (_tmp2_ == NULL) { - gchar* _tmp3_; - _tmp3_ = g_strdup ("GLib.Error"); - _g_free0 (_tmp0_); - _tmp0_ = _tmp3_; - } else { + _tmp0_ = vala_catch_clause_get_variable_name (clause); + _tmp1_ = _tmp0_; + if (_tmp1_ != NULL) { + gchar* _tmp2_ = NULL; + ValaDataType* _tmp3_; ValaDataType* _tmp4_; - ValaDataType* _tmp5_; - gchar* _tmp6_; - _tmp4_ = vala_catch_clause_get_error_type (clause); - _tmp5_ = _tmp4_; - _tmp6_ = vala_code_node_to_string ((ValaCodeNode*) _tmp5_); - _g_free0 (_tmp0_); - _tmp0_ = _tmp6_; - } - _tmp7_ = g_strdup (_tmp0_); - type_name = _tmp7_; - _tmp9_ = vala_catch_clause_get_variable_name (clause); - _tmp10_ = _tmp9_; - if (_tmp10_ == NULL) { - _tmp8_ = "_"; - } else { + gchar* type_name = NULL; + gchar* _tmp9_; + const gchar* _tmp10_; const gchar* _tmp11_; const gchar* _tmp12_; + gchar* _tmp13_; + gchar* _tmp14_; + _tmp3_ = vala_catch_clause_get_error_type (clause); + _tmp4_ = _tmp3_; + if (_tmp4_ == NULL) { + gchar* _tmp5_; + _tmp5_ = g_strdup ("GLib.Error"); + _g_free0 (_tmp2_); + _tmp2_ = _tmp5_; + } else { + ValaDataType* _tmp6_; + ValaDataType* _tmp7_; + gchar* _tmp8_; + _tmp6_ = vala_catch_clause_get_error_type (clause); + _tmp7_ = _tmp6_; + _tmp8_ = vala_code_node_to_string ((ValaCodeNode*) _tmp7_); + _g_free0 (_tmp2_); + _tmp2_ = _tmp8_; + } + _tmp9_ = g_strdup (_tmp2_); + type_name = _tmp9_; + _tmp10_ = type_name; _tmp11_ = vala_catch_clause_get_variable_name (clause); _tmp12_ = _tmp11_; - _tmp8_ = _tmp12_; + _tmp13_ = g_strdup_printf (" catch (%s %s)", _tmp10_, _tmp12_); + _tmp14_ = _tmp13_; + vala_code_writer_write_string (self, _tmp14_); + _g_free0 (_tmp14_); + _g_free0 (type_name); + _g_free0 (_tmp2_); + } else { + vala_code_writer_write_string (self, " catch"); } - _tmp13_ = g_strdup (_tmp8_); - var_name = _tmp13_; - _tmp14_ = type_name; - _tmp15_ = g_strdup_printf (" catch (%s %s)", _tmp14_, var_name); + _tmp15_ = vala_catch_clause_get_body (clause); _tmp16_ = _tmp15_; - vala_code_writer_write_string (self, _tmp16_); - _g_free0 (_tmp16_); - _tmp17_ = vala_catch_clause_get_body (clause); - _tmp18_ = _tmp17_; - vala_code_node_accept ((ValaCodeNode*) _tmp18_, (ValaCodeVisitor*) self); - _g_free0 (var_name); - _g_free0 (type_name); - _g_free0 (_tmp0_); + vala_code_node_accept ((ValaCodeNode*) _tmp16_, (ValaCodeVisitor*) self); } static void diff -Nru vala-0.52.6/vala/valacodewriter.vala vala-0.52.7/vala/valacodewriter.vala --- vala-0.52.6/vala/valacodewriter.vala 2021-10-02 07:25:38.000000000 +0000 +++ vala-0.52.7/vala/valacodewriter.vala 2021-10-26 12:38:24.000000000 +0000 @@ -1141,6 +1141,15 @@ } public override void visit_foreach_statement (ForeachStatement stmt) { + write_indent (); + write_string ("foreach ("); + write_type (stmt.type_reference); + write_string (" "); + write_string (stmt.variable_name); + write_string (" in "); + stmt.collection.accept (this); + write_string (")"); + stmt.body.accept (this); } public override void visit_break_statement (BreakStatement stmt) { @@ -1208,9 +1217,12 @@ } public override void visit_catch_clause (CatchClause clause) { - var type_name = clause.error_type == null ? "GLib.Error" : clause.error_type.to_string (); - var var_name = clause.variable_name == null ? "_" : clause.variable_name; - write_string (" catch (%s %s)".printf (type_name, var_name)); + if (clause.variable_name != null) { + var type_name = clause.error_type == null ? "GLib.Error" : clause.error_type.to_string (); + write_string (" catch (%s %s)".printf (type_name, clause.variable_name)); + } else { + write_string (" catch"); + } clause.body.accept (this); } diff -Nru vala-0.52.6/vala/valadelegate.c vala-0.52.7/vala/valadelegate.c --- vala-0.52.6/vala/valadelegate.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valadelegate.c 2021-10-30 08:24:05.000000000 +0000 @@ -1148,11 +1148,11 @@ ValaTypeSymbol* _tmp35_; ValaTypeSymbol* _tmp36_; ValaList* _tmp54_; - ValaSemanticAnalyzer* _tmp74_; - ValaSemanticAnalyzer* _tmp75_; - ValaSourceFile* _tmp76_; - gboolean _tmp77_; - gboolean _tmp78_; + ValaSemanticAnalyzer* _tmp81_; + ValaSemanticAnalyzer* _tmp82_; + ValaSourceFile* _tmp83_; + gboolean _tmp84_; + gboolean _tmp85_; gboolean result = FALSE; self = (ValaDelegate*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -1324,9 +1324,10 @@ ValaList* _tmp61_; gpointer _tmp62_; ValaDataType* _tmp63_; - ValaSemanticAnalyzer* _tmp64_; - ValaSemanticAnalyzer* _tmp65_; - ValaDataType* _tmp66_; + ValaDataType* _tmp70_; + ValaSemanticAnalyzer* _tmp71_; + ValaSemanticAnalyzer* _tmp72_; + ValaDataType* _tmp73_; _error_type_index = _error_type_index + 1; _tmp59_ = _error_type_index; _tmp60_ = _error_type_size; @@ -1337,29 +1338,47 @@ _tmp62_ = vala_list_get (_tmp61_, _error_type_index); error_type = (ValaDataType*) _tmp62_; _tmp63_ = error_type; - vala_code_node_check ((ValaCodeNode*) _tmp63_, context); - _tmp64_ = vala_code_context_get_analyzer (context); - _tmp65_ = _tmp64_; - _tmp66_ = error_type; - if (!vala_semantic_analyzer_is_type_accessible (_tmp65_, (ValaSymbol*) self, _tmp66_)) { - ValaSourceReference* _tmp67_; - ValaSourceReference* _tmp68_; - ValaDataType* _tmp69_; - gchar* _tmp70_; - gchar* _tmp71_; - gchar* _tmp72_; - gchar* _tmp73_; + if (!VALA_IS_ERROR_TYPE (_tmp63_)) { + ValaDataType* _tmp64_; + ValaSourceReference* _tmp65_; + ValaSourceReference* _tmp66_; + ValaDataType* _tmp67_; + gchar* _tmp68_; + gchar* _tmp69_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp67_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp68_ = _tmp67_; - _tmp69_ = error_type; - _tmp70_ = vala_code_node_to_string ((ValaCodeNode*) _tmp69_); - _tmp71_ = _tmp70_; - _tmp72_ = vala_symbol_get_full_name ((ValaSymbol*) self); - _tmp73_ = _tmp72_; - vala_report_error (_tmp68_, "error type `%s' is less accessible than delegate `%s'", _tmp71_, _tmp73_); - _g_free0 (_tmp73_); - _g_free0 (_tmp71_); + _tmp64_ = error_type; + _tmp65_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp64_); + _tmp66_ = _tmp65_; + _tmp67_ = error_type; + _tmp68_ = vala_code_node_to_string ((ValaCodeNode*) _tmp67_); + _tmp69_ = _tmp68_; + vala_report_error (_tmp66_, "`%s' is not an error type", _tmp69_); + _g_free0 (_tmp69_); + } + _tmp70_ = error_type; + vala_code_node_check ((ValaCodeNode*) _tmp70_, context); + _tmp71_ = vala_code_context_get_analyzer (context); + _tmp72_ = _tmp71_; + _tmp73_ = error_type; + if (!vala_semantic_analyzer_is_type_accessible (_tmp72_, (ValaSymbol*) self, _tmp73_)) { + ValaSourceReference* _tmp74_; + ValaSourceReference* _tmp75_; + ValaDataType* _tmp76_; + gchar* _tmp77_; + gchar* _tmp78_; + gchar* _tmp79_; + gchar* _tmp80_; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp74_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp75_ = _tmp74_; + _tmp76_ = error_type; + _tmp77_ = vala_code_node_to_string ((ValaCodeNode*) _tmp76_); + _tmp78_ = _tmp77_; + _tmp79_ = vala_symbol_get_full_name ((ValaSymbol*) self); + _tmp80_ = _tmp79_; + vala_report_error (_tmp75_, "error type `%s' is less accessible than delegate `%s'", _tmp78_, _tmp80_); + _g_free0 (_tmp80_); + _g_free0 (_tmp78_); result = FALSE; _vala_code_node_unref0 (error_type); _vala_source_file_unref0 (old_source_file); @@ -1369,13 +1388,13 @@ } } } - _tmp74_ = vala_code_context_get_analyzer (context); - _tmp75_ = _tmp74_; - _tmp76_ = old_source_file; - vala_semantic_analyzer_set_current_source_file (_tmp75_, _tmp76_); - _tmp77_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp78_ = _tmp77_; - result = !_tmp78_; + _tmp81_ = vala_code_context_get_analyzer (context); + _tmp82_ = _tmp81_; + _tmp83_ = old_source_file; + vala_semantic_analyzer_set_current_source_file (_tmp82_, _tmp83_); + _tmp84_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp85_ = _tmp84_; + result = !_tmp85_; _vala_source_file_unref0 (old_source_file); return result; } diff -Nru vala-0.52.6/vala/valadelegatetype.c vala-0.52.7/vala/valadelegatetype.c --- vala-0.52.6/vala/valadelegatetype.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valadelegatetype.c 2021-10-30 08:24:05.000000000 +0000 @@ -353,10 +353,12 @@ _tmp6_ = vala_delegate_type_get_delegate_symbol (self); _tmp7_ = _tmp6_; if (!vala_code_node_check ((ValaCodeNode*) _tmp7_, context)) { + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); result = FALSE; return result; } if (!vala_data_type_check_type_arguments ((ValaDataType*) self, context, TRUE)) { + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); result = FALSE; return result; } @@ -415,7 +417,9 @@ ValaArrayList* error_types = NULL; GEqualFunc _tmp78_; ValaArrayList* _tmp79_; - ValaArrayList* _tmp80_; + ValaDelegate* _tmp80_; + ValaDelegate* _tmp81_; + ValaArrayList* _tmp82_; gboolean result = FALSE; self = (ValaDelegateType*) base; g_return_val_if_fail (target_type != NULL, FALSE); @@ -627,86 +631,92 @@ _tmp78_ = g_direct_equal; _tmp79_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp78_); error_types = _tmp79_; - _tmp80_ = error_types; - vala_code_node_get_error_types ((ValaCodeNode*) self, (ValaCollection*) _tmp80_, NULL); + _tmp80_ = vala_delegate_type_get_delegate_symbol (self); + _tmp81_ = _tmp80_; + _tmp82_ = error_types; + vala_code_node_get_error_types ((ValaCodeNode*) _tmp81_, (ValaCollection*) _tmp82_, NULL); { ValaArrayList* _error_type_list = NULL; - ValaArrayList* _tmp81_; + ValaArrayList* _tmp83_; gint _error_type_size = 0; - ValaArrayList* _tmp82_; - gint _tmp83_; - gint _tmp84_; + ValaArrayList* _tmp84_; + gint _tmp85_; + gint _tmp86_; gint _error_type_index = 0; - _tmp81_ = error_types; - _error_type_list = _tmp81_; - _tmp82_ = _error_type_list; - _tmp83_ = vala_collection_get_size ((ValaCollection*) _tmp82_); - _tmp84_ = _tmp83_; - _error_type_size = _tmp84_; + _tmp83_ = error_types; + _error_type_list = _tmp83_; + _tmp84_ = _error_type_list; + _tmp85_ = vala_collection_get_size ((ValaCollection*) _tmp84_); + _tmp86_ = _tmp85_; + _error_type_size = _tmp86_; _error_type_index = -1; while (TRUE) { - gint _tmp85_; - gint _tmp86_; + gint _tmp87_; + gint _tmp88_; ValaDataType* error_type = NULL; - ValaArrayList* _tmp87_; - gpointer _tmp88_; + ValaArrayList* _tmp89_; + gpointer _tmp90_; gboolean match = FALSE; ValaArrayList* delegate_error_types = NULL; - GEqualFunc _tmp89_; - ValaArrayList* _tmp90_; - ValaDelegateType* _tmp91_; + GEqualFunc _tmp91_; ValaArrayList* _tmp92_; + ValaDelegateType* _tmp93_; + ValaDelegate* _tmp94_; + ValaDelegate* _tmp95_; + ValaArrayList* _tmp96_; _error_type_index = _error_type_index + 1; - _tmp85_ = _error_type_index; - _tmp86_ = _error_type_size; - if (!(_tmp85_ < _tmp86_)) { + _tmp87_ = _error_type_index; + _tmp88_ = _error_type_size; + if (!(_tmp87_ < _tmp88_)) { break; } - _tmp87_ = _error_type_list; - _tmp88_ = vala_list_get ((ValaList*) _tmp87_, _error_type_index); - error_type = (ValaDataType*) _tmp88_; + _tmp89_ = _error_type_list; + _tmp90_ = vala_list_get ((ValaList*) _tmp89_, _error_type_index); + error_type = (ValaDataType*) _tmp90_; match = FALSE; - _tmp89_ = g_direct_equal; - _tmp90_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp89_); - delegate_error_types = _tmp90_; - _tmp91_ = dt_target; - _tmp92_ = delegate_error_types; - vala_code_node_get_error_types ((ValaCodeNode*) _tmp91_, (ValaCollection*) _tmp92_, NULL); + _tmp91_ = g_direct_equal; + _tmp92_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp91_); + delegate_error_types = _tmp92_; + _tmp93_ = dt_target; + _tmp94_ = vala_delegate_type_get_delegate_symbol (_tmp93_); + _tmp95_ = _tmp94_; + _tmp96_ = delegate_error_types; + vala_code_node_get_error_types ((ValaCodeNode*) _tmp95_, (ValaCollection*) _tmp96_, NULL); { ValaArrayList* _delegate_error_type_list = NULL; - ValaArrayList* _tmp93_; + ValaArrayList* _tmp97_; gint _delegate_error_type_size = 0; - ValaArrayList* _tmp94_; - gint _tmp95_; - gint _tmp96_; + ValaArrayList* _tmp98_; + gint _tmp99_; + gint _tmp100_; gint _delegate_error_type_index = 0; - _tmp93_ = delegate_error_types; - _delegate_error_type_list = _tmp93_; - _tmp94_ = _delegate_error_type_list; - _tmp95_ = vala_collection_get_size ((ValaCollection*) _tmp94_); - _tmp96_ = _tmp95_; - _delegate_error_type_size = _tmp96_; + _tmp97_ = delegate_error_types; + _delegate_error_type_list = _tmp97_; + _tmp98_ = _delegate_error_type_list; + _tmp99_ = vala_collection_get_size ((ValaCollection*) _tmp98_); + _tmp100_ = _tmp99_; + _delegate_error_type_size = _tmp100_; _delegate_error_type_index = -1; while (TRUE) { - gint _tmp97_; - gint _tmp98_; + gint _tmp101_; + gint _tmp102_; ValaDataType* delegate_error_type = NULL; - ValaArrayList* _tmp99_; - gpointer _tmp100_; - ValaDataType* _tmp101_; - ValaDataType* _tmp102_; + ValaArrayList* _tmp103_; + gpointer _tmp104_; + ValaDataType* _tmp105_; + ValaDataType* _tmp106_; _delegate_error_type_index = _delegate_error_type_index + 1; - _tmp97_ = _delegate_error_type_index; - _tmp98_ = _delegate_error_type_size; - if (!(_tmp97_ < _tmp98_)) { + _tmp101_ = _delegate_error_type_index; + _tmp102_ = _delegate_error_type_size; + if (!(_tmp101_ < _tmp102_)) { break; } - _tmp99_ = _delegate_error_type_list; - _tmp100_ = vala_list_get ((ValaList*) _tmp99_, _delegate_error_type_index); - delegate_error_type = (ValaDataType*) _tmp100_; - _tmp101_ = error_type; - _tmp102_ = delegate_error_type; - if (vala_data_type_compatible (_tmp101_, _tmp102_)) { + _tmp103_ = _delegate_error_type_list; + _tmp104_ = vala_list_get ((ValaList*) _tmp103_, _delegate_error_type_index); + delegate_error_type = (ValaDataType*) _tmp104_; + _tmp105_ = error_type; + _tmp106_ = delegate_error_type; + if (vala_data_type_compatible (_tmp105_, _tmp106_)) { match = TRUE; _vala_code_node_unref0 (delegate_error_type); break; diff -Nru vala-0.52.6/vala/valadelegatetype.vala vala-0.52.7/vala/valadelegatetype.vala --- vala-0.52.6/vala/valadelegatetype.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vala/valadelegatetype.vala 2021-10-30 08:19:54.000000000 +0000 @@ -96,11 +96,13 @@ } if (!delegate_symbol.check (context)) { + error = true; return false; } // check whether there is the expected amount of type-arguments if (!check_type_arguments (context, true)) { + error = true; return false; } @@ -160,11 +162,11 @@ // target-delegate may throw less but not more errors than the delegate var error_types = new ArrayList (); - get_error_types (error_types); + delegate_symbol.get_error_types (error_types); foreach (DataType error_type in error_types) { bool match = false; var delegate_error_types = new ArrayList (); - dt_target.get_error_types (delegate_error_types); + dt_target.delegate_symbol.get_error_types (delegate_error_types); foreach (DataType delegate_error_type in delegate_error_types) { if (error_type.compatible (delegate_error_type)) { match = true; diff -Nru vala-0.52.6/vala/valadelegate.vala vala-0.52.7/vala/valadelegate.vala --- vala-0.52.6/vala/valadelegate.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vala/valadelegate.vala 2021-10-30 08:19:54.000000000 +0000 @@ -325,6 +325,10 @@ if (error_types != null) { foreach (DataType error_type in error_types) { + if (!(error_type is ErrorType)) { + error = true; + Report.error (error_type.source_reference, "`%s' is not an error type", error_type.to_string ()); + } error_type.check (context); // check whether error type is at least as accessible as the delegate diff -Nru vala-0.52.6/vala/valaenumvaluetype.c vala-0.52.7/vala/valaenumvaluetype.c --- vala-0.52.6/vala/valaenumvaluetype.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valaenumvaluetype.c 2021-10-30 08:24:05.000000000 +0000 @@ -103,7 +103,7 @@ vala_enum_value_type_get_to_string_method (ValaEnumValueType* self) { ValaMethod* _tmp0_; - ValaMethod* _tmp41_; + ValaMethod* _tmp45_; ValaMethod* result = NULL; g_return_val_if_fail (self != NULL, NULL); _tmp0_ = self->priv->to_string_method; @@ -118,35 +118,39 @@ ValaDataType* _tmp7_; ValaDataType* _tmp8_; ValaDataType* _tmp9_; - ValaMethod* _tmp10_; - ValaMethod* _tmp11_; + ValaSourceReference* _tmp10_; + ValaSourceReference* _tmp11_; ValaMethod* _tmp12_; - ValaCodeContext* _tmp13_; - ValaCodeContext* _tmp14_; - ValaProfile _tmp15_; - ValaProfile _tmp16_; - gboolean _tmp17_; - ValaMethod* _tmp20_; - ValaTypeSymbol* _tmp21_; - ValaTypeSymbol* _tmp22_; - ValaScope* _tmp23_; - ValaScope* _tmp24_; - ValaMethod* _tmp25_; - ValaDataType* _tmp26_; - ValaDataType* _tmp27_; - ValaParameter* _tmp28_; - ValaParameter* _tmp29_; - ValaMethod* _tmp30_; - ValaScope* _tmp31_; - ValaScope* _tmp32_; - ValaMethod* _tmp33_; - ValaParameter* _tmp34_; - ValaParameter* _tmp35_; - const gchar* _tmp36_; - const gchar* _tmp37_; - ValaMethod* _tmp38_; + ValaMethod* _tmp13_; + ValaMethod* _tmp14_; + ValaCodeContext* _tmp15_; + ValaCodeContext* _tmp16_; + ValaProfile _tmp17_; + ValaProfile _tmp18_; + gboolean _tmp19_; + ValaMethod* _tmp22_; + ValaTypeSymbol* _tmp23_; + ValaTypeSymbol* _tmp24_; + ValaScope* _tmp25_; + ValaScope* _tmp26_; + ValaMethod* _tmp27_; + ValaDataType* _tmp28_; + ValaDataType* _tmp29_; + ValaSourceReference* _tmp30_; + ValaSourceReference* _tmp31_; + ValaParameter* _tmp32_; + ValaParameter* _tmp33_; + ValaMethod* _tmp34_; + ValaScope* _tmp35_; + ValaScope* _tmp36_; + ValaMethod* _tmp37_; + ValaParameter* _tmp38_; ValaParameter* _tmp39_; - ValaParameter* _tmp40_; + const gchar* _tmp40_; + const gchar* _tmp41_; + ValaMethod* _tmp42_; + ValaParameter* _tmp43_; + ValaParameter* _tmp44_; _tmp1_ = vala_code_context_get (); _tmp2_ = _tmp1_; _tmp3_ = vala_code_context_get_analyzer (_tmp2_); @@ -159,58 +163,62 @@ _tmp8_ = string_type; vala_data_type_set_value_owned (_tmp8_, FALSE); _tmp9_ = string_type; - _tmp10_ = vala_method_new ("to_string", _tmp9_, NULL, NULL); + _tmp10_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp11_ = _tmp10_; + _tmp12_ = vala_method_new ("to_string", _tmp9_, _tmp11_, NULL); _vala_code_node_unref0 (self->priv->to_string_method); - self->priv->to_string_method = _tmp10_; - _tmp11_ = self->priv->to_string_method; - vala_symbol_set_access ((ValaSymbol*) _tmp11_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); - _tmp12_ = self->priv->to_string_method; - vala_symbol_set_is_extern ((ValaSymbol*) _tmp12_, TRUE); - _tmp13_ = vala_code_context_get (); - _tmp14_ = _tmp13_; - _tmp15_ = vala_code_context_get_profile (_tmp14_); + self->priv->to_string_method = _tmp12_; + _tmp13_ = self->priv->to_string_method; + vala_symbol_set_access ((ValaSymbol*) _tmp13_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp14_ = self->priv->to_string_method; + vala_symbol_set_is_extern ((ValaSymbol*) _tmp14_, TRUE); + _tmp15_ = vala_code_context_get (); _tmp16_ = _tmp15_; - _tmp17_ = _tmp16_ == VALA_PROFILE_POSIX; - _vala_code_context_unref0 (_tmp14_); - if (_tmp17_) { - ValaMethod* _tmp18_; - _tmp18_ = self->priv->to_string_method; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp18_, "CCode", "cheader_filename", "stdlib.h", NULL); + _tmp17_ = vala_code_context_get_profile (_tmp16_); + _tmp18_ = _tmp17_; + _tmp19_ = _tmp18_ == VALA_PROFILE_POSIX; + _vala_code_context_unref0 (_tmp16_); + if (_tmp19_) { + ValaMethod* _tmp20_; + _tmp20_ = self->priv->to_string_method; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp20_, "CCode", "cheader_filename", "stdlib.h", NULL); } else { - ValaMethod* _tmp19_; - _tmp19_ = self->priv->to_string_method; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp19_, "CCode", "cheader_filename", "glib-object.h", NULL); + ValaMethod* _tmp21_; + _tmp21_ = self->priv->to_string_method; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp21_, "CCode", "cheader_filename", "glib-object.h", NULL); } - _tmp20_ = self->priv->to_string_method; - _tmp21_ = vala_data_type_get_type_symbol ((ValaDataType*) self); - _tmp22_ = _tmp21_; - _tmp23_ = vala_symbol_get_scope ((ValaSymbol*) _tmp22_); + _tmp22_ = self->priv->to_string_method; + _tmp23_ = vala_data_type_get_type_symbol ((ValaDataType*) self); _tmp24_ = _tmp23_; - vala_symbol_set_owner ((ValaSymbol*) _tmp20_, _tmp24_); - _tmp25_ = self->priv->to_string_method; - _tmp26_ = vala_data_type_copy ((ValaDataType*) self); - _tmp27_ = _tmp26_; - _tmp28_ = vala_parameter_new ("this", _tmp27_, NULL); + _tmp25_ = vala_symbol_get_scope ((ValaSymbol*) _tmp24_); + _tmp26_ = _tmp25_; + vala_symbol_set_owner ((ValaSymbol*) _tmp22_, _tmp26_); + _tmp27_ = self->priv->to_string_method; + _tmp28_ = vala_data_type_copy ((ValaDataType*) self); _tmp29_ = _tmp28_; - vala_method_set_this_parameter (_tmp25_, _tmp29_); + _tmp30_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp31_ = _tmp30_; + _tmp32_ = vala_parameter_new ("this", _tmp29_, _tmp31_); + _tmp33_ = _tmp32_; + vala_method_set_this_parameter (_tmp27_, _tmp33_); + _vala_code_node_unref0 (_tmp33_); _vala_code_node_unref0 (_tmp29_); - _vala_code_node_unref0 (_tmp27_); - _tmp30_ = self->priv->to_string_method; - _tmp31_ = vala_symbol_get_scope ((ValaSymbol*) _tmp30_); - _tmp32_ = _tmp31_; - _tmp33_ = self->priv->to_string_method; - _tmp34_ = vala_method_get_this_parameter (_tmp33_); - _tmp35_ = _tmp34_; - _tmp36_ = vala_symbol_get_name ((ValaSymbol*) _tmp35_); - _tmp37_ = _tmp36_; - _tmp38_ = self->priv->to_string_method; - _tmp39_ = vala_method_get_this_parameter (_tmp38_); - _tmp40_ = _tmp39_; - vala_scope_add (_tmp32_, _tmp37_, (ValaSymbol*) _tmp40_); + _tmp34_ = self->priv->to_string_method; + _tmp35_ = vala_symbol_get_scope ((ValaSymbol*) _tmp34_); + _tmp36_ = _tmp35_; + _tmp37_ = self->priv->to_string_method; + _tmp38_ = vala_method_get_this_parameter (_tmp37_); + _tmp39_ = _tmp38_; + _tmp40_ = vala_symbol_get_name ((ValaSymbol*) _tmp39_); + _tmp41_ = _tmp40_; + _tmp42_ = self->priv->to_string_method; + _tmp43_ = vala_method_get_this_parameter (_tmp42_); + _tmp44_ = _tmp43_; + vala_scope_add (_tmp36_, _tmp41_, (ValaSymbol*) _tmp44_); _vala_code_node_unref0 (string_type); } - _tmp41_ = self->priv->to_string_method; - result = _tmp41_; + _tmp45_ = self->priv->to_string_method; + result = _tmp45_; return result; } diff -Nru vala-0.52.6/vala/valaenumvaluetype.vala vala-0.52.7/vala/valaenumvaluetype.vala --- vala-0.52.6/vala/valaenumvaluetype.vala 2021-10-04 06:42:32.000000000 +0000 +++ vala-0.52.7/vala/valaenumvaluetype.vala 2021-10-30 07:37:56.000000000 +0000 @@ -45,7 +45,7 @@ if (to_string_method == null) { var string_type = CodeContext.get ().analyzer.string_type.copy (); string_type.value_owned = false; - to_string_method = new Method ("to_string", string_type); + to_string_method = new Method ("to_string", string_type, source_reference); to_string_method.access = SymbolAccessibility.PUBLIC; to_string_method.is_extern = true; if (CodeContext.get ().profile == Profile.POSIX) { @@ -54,7 +54,7 @@ to_string_method.set_attribute_string ("CCode", "cheader_filename", "glib-object.h"); } to_string_method.owner = type_symbol.scope; - to_string_method.this_parameter = new Parameter ("this", copy ()); + to_string_method.this_parameter = new Parameter ("this", copy (), source_reference); to_string_method.scope.add (to_string_method.this_parameter.name, to_string_method.this_parameter); } return to_string_method; diff -Nru vala-0.52.6/vala/valaforeachstatement.c vala-0.52.7/vala/valaforeachstatement.c --- vala-0.52.6/vala/valaforeachstatement.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valaforeachstatement.c 2021-10-30 08:24:05.000000000 +0000 @@ -1969,12 +1969,14 @@ const gchar* _tmp69_; gchar* _tmp70_; gchar* _tmp71_; - ValaLocalVariable* _tmp72_; - ValaLocalVariable* _tmp73_; + ValaSourceReference* _tmp72_; + ValaSourceReference* _tmp73_; ValaLocalVariable* _tmp74_; ValaLocalVariable* _tmp75_; - gboolean _tmp76_; - gboolean _tmp77_; + ValaLocalVariable* _tmp76_; + ValaLocalVariable* _tmp77_; + gboolean _tmp78_; + gboolean _tmp79_; gboolean result = FALSE; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (context != NULL, FALSE); @@ -2128,19 +2130,21 @@ _tmp69_ = self->priv->_variable_name; _tmp70_ = g_strdup_printf ("%s_collection", _tmp69_); _tmp71_ = _tmp70_; - _tmp72_ = vala_local_variable_new (_tmp68_, _tmp71_, NULL, NULL); + _tmp72_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp73_ = _tmp72_; - vala_foreach_statement_set_collection_variable (self, _tmp73_); - _vala_code_node_unref0 (_tmp73_); + _tmp74_ = vala_local_variable_new (_tmp68_, _tmp71_, NULL, _tmp73_); + _tmp75_ = _tmp74_; + vala_foreach_statement_set_collection_variable (self, _tmp75_); + _vala_code_node_unref0 (_tmp75_); _g_free0 (_tmp71_); _vala_code_node_unref0 (_tmp68_); - _tmp74_ = self->priv->_collection_variable; - vala_block_add_local_variable ((ValaBlock*) self, _tmp74_); - _tmp75_ = self->priv->_collection_variable; - vala_symbol_set_active ((ValaSymbol*) _tmp75_, TRUE); - _tmp76_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp77_ = _tmp76_; - result = !_tmp77_; + _tmp76_ = self->priv->_collection_variable; + vala_block_add_local_variable ((ValaBlock*) self, _tmp76_); + _tmp77_ = self->priv->_collection_variable; + vala_symbol_set_active ((ValaSymbol*) _tmp77_, TRUE); + _tmp78_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp79_ = _tmp78_; + result = !_tmp79_; _vala_code_node_unref0 (old_symbol); return result; } diff -Nru vala-0.52.6/vala/valaforeachstatement.vala vala-0.52.7/vala/valaforeachstatement.vala --- vala-0.52.6/vala/valaforeachstatement.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vala/valaforeachstatement.vala 2021-10-30 08:19:54.000000000 +0000 @@ -396,7 +396,7 @@ context.analyzer.current_symbol = old_symbol; - collection_variable = new LocalVariable (collection_type.copy (), "%s_collection".printf (variable_name)); + collection_variable = new LocalVariable (collection_type.copy (), "%s_collection".printf (variable_name), null, source_reference); add_local_variable (collection_variable); collection_variable.active = true; diff -Nru vala-0.52.6/vala/valagenieparser.c vala-0.52.7/vala/valagenieparser.c --- vala-0.52.6/vala/valagenieparser.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valagenieparser.c 2021-10-30 08:24:05.000000000 +0000 @@ -18652,8 +18652,8 @@ ValaGenieParserModifierFlags _tmp11_; ValaErrorDomain* _tmp19_; ValaSymbol* _result_ = NULL; - ValaErrorDomain* _tmp44_; - ValaSymbol* _tmp45_; + ValaErrorDomain* _tmp45_; + ValaSymbol* _tmp46_; GError* _inner_error0_ = NULL; ValaSymbol* result = NULL; g_return_val_if_fail (self != NULL, NULL); @@ -18769,9 +18769,10 @@ ValaErrorCode* _tmp35_; ValaErrorCode* _tmp36_; ValaErrorCode* _tmp37_; - ValaList* _tmp38_; - ValaErrorDomain* _tmp42_; - ValaErrorCode* _tmp43_; + ValaErrorCode* _tmp38_; + ValaList* _tmp39_; + ValaErrorDomain* _tmp43_; + ValaErrorCode* _tmp44_; if (vala_genie_parser_current (self) == VALA_GENIE_TOKEN_TYPE_DEDENT) { ValaErrorDomain* _tmp21_; ValaList* _tmp22_; @@ -18838,14 +18839,16 @@ _vala_source_reference_unref0 (_tmp33_); ec = _tmp36_; _tmp37_ = ec; - _tmp38_ = code_attrs; - vala_genie_parser_set_attributes (self, (ValaCodeNode*) _tmp37_, _tmp38_); + vala_symbol_set_access ((ValaSymbol*) _tmp37_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp38_ = ec; + _tmp39_ = code_attrs; + vala_genie_parser_set_attributes (self, (ValaCodeNode*) _tmp38_, _tmp39_); if (vala_genie_parser_accept (self, VALA_GENIE_TOKEN_TYPE_ASSIGN)) { - ValaExpression* _tmp39_ = NULL; - ValaExpression* _tmp40_; - ValaErrorCode* _tmp41_; - _tmp40_ = vala_genie_parser_parse_expression (self, &_inner_error0_); - _tmp39_ = _tmp40_; + ValaExpression* _tmp40_ = NULL; + ValaExpression* _tmp41_; + ValaErrorCode* _tmp42_; + _tmp41_ = vala_genie_parser_parse_expression (self, &_inner_error0_); + _tmp40_ = _tmp41_; if (G_UNLIKELY (_inner_error0_ != NULL)) { if (_inner_error0_->domain == VALA_PARSE_ERROR) { g_propagate_error (error, _inner_error0_); @@ -18866,13 +18869,13 @@ return NULL; } } - _tmp41_ = ec; - vala_error_code_set_value (_tmp41_, _tmp39_); - _vala_code_node_unref0 (_tmp39_); - } - _tmp42_ = ed; - _tmp43_ = ec; - vala_error_domain_add_code (_tmp42_, _tmp43_); + _tmp42_ = ec; + vala_error_code_set_value (_tmp42_, _tmp40_); + _vala_code_node_unref0 (_tmp40_); + } + _tmp43_ = ed; + _tmp44_ = ec; + vala_error_domain_add_code (_tmp43_, _tmp44_); vala_genie_parser_accept (self, VALA_GENIE_TOKEN_TYPE_EOL); _vala_code_node_unref0 (ec); _g_free0 (id); @@ -18893,66 +18896,66 @@ return NULL; } } - _tmp44_ = ed; - _tmp45_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp44_); - _result_ = _tmp45_; + _tmp45_ = ed; + _tmp46_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp45_); + _result_ = _tmp46_; while (TRUE) { - ValaUnresolvedSymbol* _tmp46_; ValaUnresolvedSymbol* _tmp47_; ValaUnresolvedSymbol* _tmp48_; ValaUnresolvedSymbol* _tmp49_; ValaUnresolvedSymbol* _tmp50_; ValaUnresolvedSymbol* _tmp51_; ValaUnresolvedSymbol* _tmp52_; - ValaNamespace* ns = NULL; ValaUnresolvedSymbol* _tmp53_; - const gchar* _tmp54_; + ValaNamespace* ns = NULL; + ValaUnresolvedSymbol* _tmp54_; const gchar* _tmp55_; - ValaErrorDomain* _tmp56_; - ValaSourceReference* _tmp57_; + const gchar* _tmp56_; + ValaErrorDomain* _tmp57_; ValaSourceReference* _tmp58_; - ValaNamespace* _tmp59_; - ValaSymbol* _tmp60_; - ValaNamespace* _tmp65_; - ValaSymbol* _tmp66_; - _tmp46_ = sym; - _tmp47_ = vala_unresolved_symbol_get_inner (_tmp46_); - _tmp48_ = _tmp47_; - if (!(_tmp48_ != NULL)) { + ValaSourceReference* _tmp59_; + ValaNamespace* _tmp60_; + ValaSymbol* _tmp61_; + ValaNamespace* _tmp66_; + ValaSymbol* _tmp67_; + _tmp47_ = sym; + _tmp48_ = vala_unresolved_symbol_get_inner (_tmp47_); + _tmp49_ = _tmp48_; + if (!(_tmp49_ != NULL)) { break; } - _tmp49_ = sym; - _tmp50_ = vala_unresolved_symbol_get_inner (_tmp49_); - _tmp51_ = _tmp50_; - _tmp52_ = _vala_code_node_ref0 (_tmp51_); + _tmp50_ = sym; + _tmp51_ = vala_unresolved_symbol_get_inner (_tmp50_); + _tmp52_ = _tmp51_; + _tmp53_ = _vala_code_node_ref0 (_tmp52_); _vala_code_node_unref0 (sym); - sym = _tmp52_; - _tmp53_ = sym; - _tmp54_ = vala_symbol_get_name ((ValaSymbol*) _tmp53_); - _tmp55_ = _tmp54_; - _tmp56_ = ed; - _tmp57_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp56_); - _tmp58_ = _tmp57_; - _tmp59_ = vala_namespace_new (_tmp55_, _tmp58_); - ns = _tmp59_; - _tmp60_ = _result_; - if (VALA_IS_NAMESPACE (_tmp60_)) { - ValaNamespace* _tmp61_; - ValaSymbol* _tmp62_; - _tmp61_ = ns; - _tmp62_ = _result_; - vala_symbol_add_namespace ((ValaSymbol*) _tmp61_, G_TYPE_CHECK_INSTANCE_CAST (_tmp62_, VALA_TYPE_NAMESPACE, ValaNamespace)); + sym = _tmp53_; + _tmp54_ = sym; + _tmp55_ = vala_symbol_get_name ((ValaSymbol*) _tmp54_); + _tmp56_ = _tmp55_; + _tmp57_ = ed; + _tmp58_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp57_); + _tmp59_ = _tmp58_; + _tmp60_ = vala_namespace_new (_tmp56_, _tmp59_); + ns = _tmp60_; + _tmp61_ = _result_; + if (VALA_IS_NAMESPACE (_tmp61_)) { + ValaNamespace* _tmp62_; + ValaSymbol* _tmp63_; + _tmp62_ = ns; + _tmp63_ = _result_; + vala_symbol_add_namespace ((ValaSymbol*) _tmp62_, G_TYPE_CHECK_INSTANCE_CAST (_tmp63_, VALA_TYPE_NAMESPACE, ValaNamespace)); } else { - ValaNamespace* _tmp63_; - ValaSymbol* _tmp64_; - _tmp63_ = ns; - _tmp64_ = _result_; - vala_symbol_add_error_domain ((ValaSymbol*) _tmp63_, G_TYPE_CHECK_INSTANCE_CAST (_tmp64_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain)); + ValaNamespace* _tmp64_; + ValaSymbol* _tmp65_; + _tmp64_ = ns; + _tmp65_ = _result_; + vala_symbol_add_error_domain ((ValaSymbol*) _tmp64_, G_TYPE_CHECK_INSTANCE_CAST (_tmp65_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain)); } - _tmp65_ = ns; - _tmp66_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp65_); + _tmp66_ = ns; + _tmp67_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp66_); _vala_code_node_unref0 (_result_); - _result_ = _tmp66_; + _result_ = _tmp67_; _vala_code_node_unref0 (ns); } result = _result_; diff -Nru vala-0.52.6/vala/valagenieparser.vala vala-0.52.7/vala/valagenieparser.vala --- vala-0.52.6/vala/valagenieparser.vala 2021-09-30 15:37:07.000000000 +0000 +++ vala-0.52.7/vala/valagenieparser.vala 2021-10-26 12:38:24.000000000 +0000 @@ -3515,6 +3515,7 @@ string id = parse_identifier (); comment = scanner.pop_comment (); var ec = new ErrorCode (id, get_src (code_begin), comment); + ec.access = SymbolAccessibility.PUBLIC; set_attributes (ec, code_attrs); if (accept (TokenType.ASSIGN)) { ec.value = parse_expression (); diff -Nru vala-0.52.6/vala/valagirparser.c vala-0.52.7/vala/valagirparser.c --- vala-0.52.6/vala/valagirparser.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valagirparser.c 2021-10-30 08:24:05.000000000 +0000 @@ -106,6 +106,9 @@ VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION, + VALA_GIR_PARSER_ARGUMENT_TYPE_REF_FUNCTION, + VALA_GIR_PARSER_ARGUMENT_TYPE_REF_SINK_FUNCTION, + VALA_GIR_PARSER_ARGUMENT_TYPE_UNREF_FUNCTION, VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID, VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME, @@ -888,7 +891,7 @@ static GType vala_gir_parser_argument_type_get_type_once (void) { - static const GEnumValue values[] = {{VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP, "VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP", "skip"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN, "VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN", "hidden"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NEW, "VALA_GIR_PARSER_ARGUMENT_TYPE_NEW", "new"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE", "type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS", "type-arguments"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME", "cheader-filename"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_NAME", "name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_OWNED, "VALA_GIR_PARSER_ARGUMENT_TYPE_OWNED", "owned"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_UNOWNED, "VALA_GIR_PARSER_ARGUMENT_TYPE_UNOWNED", "unowned"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT, "VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT", "parent"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NULLABLE, "VALA_GIR_PARSER_ARGUMENT_TYPE_NULLABLE", "nullable"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED", "deprecated"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT, "VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT", "replacement"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE", "deprecated-since"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE", "since"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY", "array"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX", "array-length-idx"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_NULL_TERMINATED, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_NULL_TERMINATED", "array-null-terminated"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT", "default"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_OUT, "VALA_GIR_PARSER_ARGUMENT_TYPE_OUT", "out"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_REF, "VALA_GIR_PARSER_ARGUMENT_TYPE_REF", "ref"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME", "vfunc-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL, "VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL", "virtual"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT, "VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT", "abstract"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_COMPACT, "VALA_GIR_PARSER_ARGUMENT_TYPE_COMPACT", "compact"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SEALED, "VALA_GIR_PARSER_ARGUMENT_TYPE_SEALED", "sealed"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SCOPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SCOPE", "scope"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT, "VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT", "struct"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS, "VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS", "throws"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_PRINTF_FORMAT, "VALA_GIR_PARSER_ARGUMENT_TYPE_PRINTF_FORMAT", "printf-format"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD", "array-length-field"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL, "VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL", "sentinel"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE, "VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE", "closure"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY", "destroy"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX", "cprefix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX", "lower-case-cprefix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CSUFFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CSUFFIX", "lower-case-csuffix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN, "VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN", "errordomain"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE", "destroys-instance"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE", "base-type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME", "finish-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_INSTANCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_INSTANCE", "finish-instance"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE", "symbol-type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX, "VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX", "instance-idx"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL, "VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL", "experimental"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FEATURE_TEST_MACRO, "VALA_GIR_PARSER_ARGUMENT_TYPE_FEATURE_TEST_MACRO", "feature-test-macro"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING, "VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING", "floating"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID", "type-id"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION", "type-get-function"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID, "VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID", "return-void"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER, "VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER", "returns-modified-pointer"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME", "delegate-target-cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY_NOTIFY_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY_NOTIFY_CNAME", "destroy-notify-cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME", "finish-vfunc-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NO_ACCESSOR_METHOD, "VALA_GIR_PARSER_ARGUMENT_TYPE_NO_ACCESSOR_METHOD", "no-accessor-method"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NO_WRAPPER, "VALA_GIR_PARSER_ARGUMENT_TYPE_NO_WRAPPER", "no-wrapper"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_CNAME", "cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET, "VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET", "delegate-target"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE", "ctype"}, {0, NULL, NULL}}; + static const GEnumValue values[] = {{VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP, "VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP", "skip"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN, "VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN", "hidden"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NEW, "VALA_GIR_PARSER_ARGUMENT_TYPE_NEW", "new"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE", "type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS", "type-arguments"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME", "cheader-filename"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_NAME", "name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_OWNED, "VALA_GIR_PARSER_ARGUMENT_TYPE_OWNED", "owned"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_UNOWNED, "VALA_GIR_PARSER_ARGUMENT_TYPE_UNOWNED", "unowned"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT, "VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT", "parent"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NULLABLE, "VALA_GIR_PARSER_ARGUMENT_TYPE_NULLABLE", "nullable"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED", "deprecated"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT, "VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT", "replacement"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE", "deprecated-since"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE", "since"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY", "array"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX", "array-length-idx"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_NULL_TERMINATED, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_NULL_TERMINATED", "array-null-terminated"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT", "default"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_OUT, "VALA_GIR_PARSER_ARGUMENT_TYPE_OUT", "out"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_REF, "VALA_GIR_PARSER_ARGUMENT_TYPE_REF", "ref"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME", "vfunc-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL, "VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL", "virtual"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT, "VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT", "abstract"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_COMPACT, "VALA_GIR_PARSER_ARGUMENT_TYPE_COMPACT", "compact"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SEALED, "VALA_GIR_PARSER_ARGUMENT_TYPE_SEALED", "sealed"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SCOPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SCOPE", "scope"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT, "VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT", "struct"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS, "VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS", "throws"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_PRINTF_FORMAT, "VALA_GIR_PARSER_ARGUMENT_TYPE_PRINTF_FORMAT", "printf-format"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD", "array-length-field"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL, "VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL", "sentinel"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE, "VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE", "closure"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY", "destroy"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX", "cprefix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX", "lower-case-cprefix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CSUFFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CSUFFIX", "lower-case-csuffix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN, "VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN", "errordomain"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE", "destroys-instance"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE", "base-type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME", "finish-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_INSTANCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_INSTANCE", "finish-instance"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE", "symbol-type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX, "VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX", "instance-idx"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL, "VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL", "experimental"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FEATURE_TEST_MACRO, "VALA_GIR_PARSER_ARGUMENT_TYPE_FEATURE_TEST_MACRO", "feature-test-macro"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING, "VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING", "floating"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID", "type-id"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION", "type-get-function"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_REF_FUNCTION, "VALA_GIR_PARSER_ARGUMENT_TYPE_REF_FUNCTION", "ref-function"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_REF_SINK_FUNCTION, "VALA_GIR_PARSER_ARGUMENT_TYPE_REF_SINK_FUNCTION", "ref-sink-function"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_UNREF_FUNCTION, "VALA_GIR_PARSER_ARGUMENT_TYPE_UNREF_FUNCTION", "unref-function"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID, "VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID", "return-void"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER, "VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER", "returns-modified-pointer"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME", "delegate-target-cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY_NOTIFY_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY_NOTIFY_CNAME", "destroy-notify-cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME", "finish-vfunc-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NO_ACCESSOR_METHOD, "VALA_GIR_PARSER_ARGUMENT_TYPE_NO_ACCESSOR_METHOD", "no-accessor-method"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NO_WRAPPER, "VALA_GIR_PARSER_ARGUMENT_TYPE_NO_WRAPPER", "no-wrapper"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_CNAME", "cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET, "VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET", "delegate-target"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE", "ctype"}, {0, NULL, NULL}}; GType vala_gir_parser_argument_type_type_id; vala_gir_parser_argument_type_type_id = g_enum_register_static ("ValaGirParserArgumentType", values); return vala_gir_parser_argument_type_type_id; @@ -2762,7 +2765,7 @@ e = _inner_error0_; _inner_error0_ = NULL; _tmp4_ = e->message; - g_error ("valagirparser.vala:1807: Unable to compile regex: %s", _tmp4_); + g_error ("valagirparser.vala:1810: Unable to compile regex: %s", _tmp4_); _g_error_free0 (e); } __finally0: @@ -7225,9 +7228,12 @@ ValaGirParserNode* _tmp4_; ValaClass* _tmp47_; ValaClass* _tmp48_; - ValaClass* _tmp49_; - ValaGirComment* _tmp50_; - ValaGirComment* _tmp51_; + ValaGirParserMetadata* _tmp49_; + ValaGirParserMetadata* _tmp54_; + ValaGirParserMetadata* _tmp59_; + ValaClass* _tmp64_; + ValaGirComment* _tmp65_; + ValaGirComment* _tmp66_; gboolean first_field = FALSE; g_return_if_fail (self != NULL); vala_gir_parser_start_element (self, "class"); @@ -7356,101 +7362,140 @@ vala_gir_parser_set_type_id_ccode (self, (ValaSymbol*) _tmp47_); _tmp48_ = cl; vala_symbol_set_access ((ValaSymbol*) _tmp48_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp49_ = self->priv->metadata; + if (vala_gir_parser_metadata_has_argument (_tmp49_, VALA_GIR_PARSER_ARGUMENT_TYPE_REF_FUNCTION)) { + ValaClass* _tmp50_; + ValaGirParserMetadata* _tmp51_; + gchar* _tmp52_; + gchar* _tmp53_; + _tmp50_ = cl; + _tmp51_ = self->priv->metadata; + _tmp52_ = vala_gir_parser_metadata_get_string (_tmp51_, VALA_GIR_PARSER_ARGUMENT_TYPE_REF_FUNCTION); + _tmp53_ = _tmp52_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp50_, "CCode", "ref_function", _tmp53_, NULL); + _g_free0 (_tmp53_); + } + _tmp54_ = self->priv->metadata; + if (vala_gir_parser_metadata_has_argument (_tmp54_, VALA_GIR_PARSER_ARGUMENT_TYPE_REF_SINK_FUNCTION)) { + ValaClass* _tmp55_; + ValaGirParserMetadata* _tmp56_; + gchar* _tmp57_; + gchar* _tmp58_; + _tmp55_ = cl; + _tmp56_ = self->priv->metadata; + _tmp57_ = vala_gir_parser_metadata_get_string (_tmp56_, VALA_GIR_PARSER_ARGUMENT_TYPE_REF_SINK_FUNCTION); + _tmp58_ = _tmp57_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp55_, "CCode", "ref_sink_function", _tmp58_, NULL); + _g_free0 (_tmp58_); + } + _tmp59_ = self->priv->metadata; + if (vala_gir_parser_metadata_has_argument (_tmp59_, VALA_GIR_PARSER_ARGUMENT_TYPE_UNREF_FUNCTION)) { + ValaClass* _tmp60_; + ValaGirParserMetadata* _tmp61_; + gchar* _tmp62_; + gchar* _tmp63_; + _tmp60_ = cl; + _tmp61_ = self->priv->metadata; + _tmp62_ = vala_gir_parser_metadata_get_string (_tmp61_, VALA_GIR_PARSER_ARGUMENT_TYPE_UNREF_FUNCTION); + _tmp63_ = _tmp62_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp60_, "CCode", "unref_function", _tmp63_, NULL); + _g_free0 (_tmp63_); + } vala_gir_parser_next (self); - _tmp49_ = cl; - _tmp50_ = vala_gir_parser_parse_symbol_doc (self); - _tmp51_ = _tmp50_; - vala_symbol_set_comment ((ValaSymbol*) _tmp49_, (ValaComment*) _tmp51_); - _vala_comment_unref0 (_tmp51_); + _tmp64_ = cl; + _tmp65_ = vala_gir_parser_parse_symbol_doc (self); + _tmp66_ = _tmp65_; + vala_symbol_set_comment ((ValaSymbol*) _tmp64_, (ValaComment*) _tmp66_); + _vala_comment_unref0 (_tmp66_); first_field = TRUE; while (TRUE) { - ValaMarkupTokenType _tmp52_; - ValaMarkupReader* _tmp57_; - const gchar* _tmp58_; - const gchar* _tmp59_; - _tmp52_ = self->priv->current_token; - if (!(_tmp52_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) { + ValaMarkupTokenType _tmp67_; + ValaMarkupReader* _tmp72_; + const gchar* _tmp73_; + const gchar* _tmp74_; + _tmp67_ = self->priv->current_token; + if (!(_tmp67_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) { break; } if (!vala_gir_parser_push_metadata (self)) { - gboolean _tmp53_ = FALSE; + gboolean _tmp68_ = FALSE; if (first_field) { - ValaMarkupReader* _tmp54_; - const gchar* _tmp55_; - const gchar* _tmp56_; - _tmp54_ = self->priv->reader; - _tmp55_ = vala_markup_reader_get_name (_tmp54_); - _tmp56_ = _tmp55_; - _tmp53_ = g_strcmp0 (_tmp56_, "field") == 0; + ValaMarkupReader* _tmp69_; + const gchar* _tmp70_; + const gchar* _tmp71_; + _tmp69_ = self->priv->reader; + _tmp70_ = vala_markup_reader_get_name (_tmp69_); + _tmp71_ = _tmp70_; + _tmp68_ = g_strcmp0 (_tmp71_, "field") == 0; } else { - _tmp53_ = FALSE; + _tmp68_ = FALSE; } - if (_tmp53_) { + if (_tmp68_) { first_field = FALSE; } vala_gir_parser_skip_element (self); continue; } - _tmp57_ = self->priv->reader; - _tmp58_ = vala_markup_reader_get_name (_tmp57_); - _tmp59_ = _tmp58_; - if (g_strcmp0 (_tmp59_, "implements") == 0) { - ValaClass* _tmp60_; - ValaMarkupReader* _tmp61_; - gchar* _tmp62_; - gchar* _tmp63_; - ValaDataType* _tmp64_; - ValaDataType* _tmp65_; + _tmp72_ = self->priv->reader; + _tmp73_ = vala_markup_reader_get_name (_tmp72_); + _tmp74_ = _tmp73_; + if (g_strcmp0 (_tmp74_, "implements") == 0) { + ValaClass* _tmp75_; + ValaMarkupReader* _tmp76_; + gchar* _tmp77_; + gchar* _tmp78_; + ValaDataType* _tmp79_; + ValaDataType* _tmp80_; vala_gir_parser_start_element (self, "implements"); - _tmp60_ = cl; - _tmp61_ = self->priv->reader; - _tmp62_ = vala_markup_reader_get_attribute (_tmp61_, "name"); - _tmp63_ = _tmp62_; - _tmp64_ = vala_gir_parser_parse_type_from_gir_name (self, _tmp63_, NULL, NULL, NULL); - _tmp65_ = _tmp64_; - vala_class_add_base_type (_tmp60_, _tmp65_); - _vala_code_node_unref0 (_tmp65_); - _g_free0 (_tmp63_); + _tmp75_ = cl; + _tmp76_ = self->priv->reader; + _tmp77_ = vala_markup_reader_get_attribute (_tmp76_, "name"); + _tmp78_ = _tmp77_; + _tmp79_ = vala_gir_parser_parse_type_from_gir_name (self, _tmp78_, NULL, NULL, NULL); + _tmp80_ = _tmp79_; + vala_class_add_base_type (_tmp75_, _tmp80_); + _vala_code_node_unref0 (_tmp80_); + _g_free0 (_tmp78_); vala_gir_parser_next (self); vala_gir_parser_end_element (self, "implements"); } else { - ValaMarkupReader* _tmp66_; - const gchar* _tmp67_; - const gchar* _tmp68_; - _tmp66_ = self->priv->reader; - _tmp67_ = vala_markup_reader_get_name (_tmp66_); - _tmp68_ = _tmp67_; - if (g_strcmp0 (_tmp68_, "constant") == 0) { + ValaMarkupReader* _tmp81_; + const gchar* _tmp82_; + const gchar* _tmp83_; + _tmp81_ = self->priv->reader; + _tmp82_ = vala_markup_reader_get_name (_tmp81_); + _tmp83_ = _tmp82_; + if (g_strcmp0 (_tmp83_, "constant") == 0) { vala_gir_parser_parse_constant (self); } else { - ValaMarkupReader* _tmp69_; - const gchar* _tmp70_; - const gchar* _tmp71_; - _tmp69_ = self->priv->reader; - _tmp70_ = vala_markup_reader_get_name (_tmp69_); - _tmp71_ = _tmp70_; - if (g_strcmp0 (_tmp71_, "field") == 0) { - gboolean _tmp72_ = FALSE; + ValaMarkupReader* _tmp84_; + const gchar* _tmp85_; + const gchar* _tmp86_; + _tmp84_ = self->priv->reader; + _tmp85_ = vala_markup_reader_get_name (_tmp84_); + _tmp86_ = _tmp85_; + if (g_strcmp0 (_tmp86_, "field") == 0) { + gboolean _tmp87_ = FALSE; if (first_field) { - const gchar* _tmp73_; - _tmp73_ = parent; - _tmp72_ = _tmp73_ != NULL; + const gchar* _tmp88_; + _tmp88_ = parent; + _tmp87_ = _tmp88_ != NULL; } else { - _tmp72_ = FALSE; + _tmp87_ = FALSE; } - if (_tmp72_) { + if (_tmp87_) { vala_gir_parser_skip_element (self); } else { - ValaMarkupReader* _tmp74_; - gchar* _tmp75_; - gchar* _tmp76_; - gboolean _tmp77_; - _tmp74_ = self->priv->reader; - _tmp75_ = vala_markup_reader_get_attribute (_tmp74_, "name"); - _tmp76_ = _tmp75_; - _tmp77_ = g_strcmp0 (_tmp76_, "priv") != 0; - _g_free0 (_tmp76_); - if (_tmp77_) { + ValaMarkupReader* _tmp89_; + gchar* _tmp90_; + gchar* _tmp91_; + gboolean _tmp92_; + _tmp89_ = self->priv->reader; + _tmp90_ = vala_markup_reader_get_attribute (_tmp89_, "name"); + _tmp91_ = _tmp90_; + _tmp92_ = g_strcmp0 (_tmp91_, "priv") != 0; + _g_free0 (_tmp91_); + if (_tmp92_) { vala_gir_parser_parse_field (self); } else { vala_gir_parser_skip_element (self); @@ -7458,94 +7503,94 @@ } first_field = FALSE; } else { - ValaMarkupReader* _tmp78_; - const gchar* _tmp79_; - const gchar* _tmp80_; - _tmp78_ = self->priv->reader; - _tmp79_ = vala_markup_reader_get_name (_tmp78_); - _tmp80_ = _tmp79_; - if (g_strcmp0 (_tmp80_, "property") == 0) { - ValaProperty* _tmp81_; - ValaProperty* _tmp82_; - _tmp81_ = vala_gir_parser_parse_property (self); - _tmp82_ = _tmp81_; - _vala_code_node_unref0 (_tmp82_); + ValaMarkupReader* _tmp93_; + const gchar* _tmp94_; + const gchar* _tmp95_; + _tmp93_ = self->priv->reader; + _tmp94_ = vala_markup_reader_get_name (_tmp93_); + _tmp95_ = _tmp94_; + if (g_strcmp0 (_tmp95_, "property") == 0) { + ValaProperty* _tmp96_; + ValaProperty* _tmp97_; + _tmp96_ = vala_gir_parser_parse_property (self); + _tmp97_ = _tmp96_; + _vala_code_node_unref0 (_tmp97_); } else { - ValaMarkupReader* _tmp83_; - const gchar* _tmp84_; - const gchar* _tmp85_; - _tmp83_ = self->priv->reader; - _tmp84_ = vala_markup_reader_get_name (_tmp83_); - _tmp85_ = _tmp84_; - if (g_strcmp0 (_tmp85_, "constructor") == 0) { + ValaMarkupReader* _tmp98_; + const gchar* _tmp99_; + const gchar* _tmp100_; + _tmp98_ = self->priv->reader; + _tmp99_ = vala_markup_reader_get_name (_tmp98_); + _tmp100_ = _tmp99_; + if (g_strcmp0 (_tmp100_, "constructor") == 0) { vala_gir_parser_parse_constructor (self); } else { - ValaMarkupReader* _tmp86_; - const gchar* _tmp87_; - const gchar* _tmp88_; - _tmp86_ = self->priv->reader; - _tmp87_ = vala_markup_reader_get_name (_tmp86_); - _tmp88_ = _tmp87_; - if (g_strcmp0 (_tmp88_, "function") == 0) { + ValaMarkupReader* _tmp101_; + const gchar* _tmp102_; + const gchar* _tmp103_; + _tmp101_ = self->priv->reader; + _tmp102_ = vala_markup_reader_get_name (_tmp101_); + _tmp103_ = _tmp102_; + if (g_strcmp0 (_tmp103_, "function") == 0) { vala_gir_parser_parse_method (self, "function"); } else { - ValaMarkupReader* _tmp89_; - const gchar* _tmp90_; - const gchar* _tmp91_; - _tmp89_ = self->priv->reader; - _tmp90_ = vala_markup_reader_get_name (_tmp89_); - _tmp91_ = _tmp90_; - if (g_strcmp0 (_tmp91_, "function-macro") == 0) { + ValaMarkupReader* _tmp104_; + const gchar* _tmp105_; + const gchar* _tmp106_; + _tmp104_ = self->priv->reader; + _tmp105_ = vala_markup_reader_get_name (_tmp104_); + _tmp106_ = _tmp105_; + if (g_strcmp0 (_tmp106_, "function-macro") == 0) { vala_gir_parser_skip_element (self); } else { - ValaMarkupReader* _tmp92_; - const gchar* _tmp93_; - const gchar* _tmp94_; - _tmp92_ = self->priv->reader; - _tmp93_ = vala_markup_reader_get_name (_tmp92_); - _tmp94_ = _tmp93_; - if (g_strcmp0 (_tmp94_, "method") == 0) { + ValaMarkupReader* _tmp107_; + const gchar* _tmp108_; + const gchar* _tmp109_; + _tmp107_ = self->priv->reader; + _tmp108_ = vala_markup_reader_get_name (_tmp107_); + _tmp109_ = _tmp108_; + if (g_strcmp0 (_tmp109_, "method") == 0) { vala_gir_parser_parse_method (self, "method"); } else { - ValaMarkupReader* _tmp95_; - const gchar* _tmp96_; - const gchar* _tmp97_; - _tmp95_ = self->priv->reader; - _tmp96_ = vala_markup_reader_get_name (_tmp95_); - _tmp97_ = _tmp96_; - if (g_strcmp0 (_tmp97_, "virtual-method") == 0) { + ValaMarkupReader* _tmp110_; + const gchar* _tmp111_; + const gchar* _tmp112_; + _tmp110_ = self->priv->reader; + _tmp111_ = vala_markup_reader_get_name (_tmp110_); + _tmp112_ = _tmp111_; + if (g_strcmp0 (_tmp112_, "virtual-method") == 0) { vala_gir_parser_parse_method (self, "virtual-method"); } else { - ValaMarkupReader* _tmp98_; - const gchar* _tmp99_; - const gchar* _tmp100_; - _tmp98_ = self->priv->reader; - _tmp99_ = vala_markup_reader_get_name (_tmp98_); - _tmp100_ = _tmp99_; - if (g_strcmp0 (_tmp100_, "union") == 0) { + ValaMarkupReader* _tmp113_; + const gchar* _tmp114_; + const gchar* _tmp115_; + _tmp113_ = self->priv->reader; + _tmp114_ = vala_markup_reader_get_name (_tmp113_); + _tmp115_ = _tmp114_; + if (g_strcmp0 (_tmp115_, "union") == 0) { vala_gir_parser_parse_union (self); } else { - ValaMarkupReader* _tmp101_; - const gchar* _tmp102_; - const gchar* _tmp103_; - _tmp101_ = self->priv->reader; - _tmp102_ = vala_markup_reader_get_name (_tmp101_); - _tmp103_ = _tmp102_; - if (g_strcmp0 (_tmp103_, "glib:signal") == 0) { + ValaMarkupReader* _tmp116_; + const gchar* _tmp117_; + const gchar* _tmp118_; + _tmp116_ = self->priv->reader; + _tmp117_ = vala_markup_reader_get_name (_tmp116_); + _tmp118_ = _tmp117_; + if (g_strcmp0 (_tmp118_, "glib:signal") == 0) { vala_gir_parser_parse_signal (self); } else { - ValaSourceReference* _tmp104_; - ValaSourceReference* _tmp105_; - ValaMarkupReader* _tmp106_; - const gchar* _tmp107_; - const gchar* _tmp108_; - _tmp104_ = vala_gir_parser_get_current_src (self); - _tmp105_ = _tmp104_; - _tmp106_ = self->priv->reader; - _tmp107_ = vala_markup_reader_get_name (_tmp106_); - _tmp108_ = _tmp107_; - vala_report_error (_tmp105_, "unknown child element `%s' in `class'", _tmp108_); - _vala_source_reference_unref0 (_tmp105_); + ValaSourceReference* _tmp119_; + ValaSourceReference* _tmp120_; + ValaMarkupReader* _tmp121_; + const gchar* _tmp122_; + const gchar* _tmp123_; + _tmp119_ = vala_gir_parser_get_current_src (self); + _tmp120_ = _tmp119_; + _tmp121_ = self->priv->reader; + _tmp122_ = vala_markup_reader_get_name (_tmp121_); + _tmp123_ = _tmp122_; + vala_report_error (_tmp120_, "unknown child element `%s' in `class'", _tmp123_); + _vala_source_reference_unref0 (_tmp120_); vala_gir_parser_skip_element (self); } } @@ -9297,15 +9342,18 @@ ValaClass* _tmp25_; ValaClass* _tmp26_; ValaGirParserMetadata* _tmp27_; - ValaClass* _tmp37_; - ValaGirComment* _tmp38_; - ValaGirComment* _tmp39_; + ValaGirParserMetadata* _tmp37_; + ValaGirParserMetadata* _tmp42_; + ValaGirParserMetadata* _tmp47_; + ValaClass* _tmp52_; + ValaGirComment* _tmp53_; + ValaGirComment* _tmp54_; ValaGirParserNode* ref_method = NULL; ValaGirParserNode* unref_method = NULL; - gboolean _tmp82_ = FALSE; - gboolean _tmp83_ = FALSE; - gboolean _tmp84_ = FALSE; - ValaClass* _tmp85_; + gboolean _tmp97_ = FALSE; + gboolean _tmp98_ = FALSE; + gboolean _tmp99_ = FALSE; + ValaClass* _tmp100_; g_return_if_fail (self != NULL); g_return_if_fail (element_name != NULL); vala_gir_parser_start_element (self, element_name); @@ -9403,154 +9451,193 @@ _vala_source_reference_unref0 (_tmp34_); _g_free0 (_tmp31_); } + _tmp37_ = self->priv->metadata; + if (vala_gir_parser_metadata_has_argument (_tmp37_, VALA_GIR_PARSER_ARGUMENT_TYPE_REF_FUNCTION)) { + ValaClass* _tmp38_; + ValaGirParserMetadata* _tmp39_; + gchar* _tmp40_; + gchar* _tmp41_; + _tmp38_ = cl; + _tmp39_ = self->priv->metadata; + _tmp40_ = vala_gir_parser_metadata_get_string (_tmp39_, VALA_GIR_PARSER_ARGUMENT_TYPE_REF_FUNCTION); + _tmp41_ = _tmp40_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp38_, "CCode", "ref_function", _tmp41_, NULL); + _g_free0 (_tmp41_); + } + _tmp42_ = self->priv->metadata; + if (vala_gir_parser_metadata_has_argument (_tmp42_, VALA_GIR_PARSER_ARGUMENT_TYPE_REF_SINK_FUNCTION)) { + ValaClass* _tmp43_; + ValaGirParserMetadata* _tmp44_; + gchar* _tmp45_; + gchar* _tmp46_; + _tmp43_ = cl; + _tmp44_ = self->priv->metadata; + _tmp45_ = vala_gir_parser_metadata_get_string (_tmp44_, VALA_GIR_PARSER_ARGUMENT_TYPE_REF_SINK_FUNCTION); + _tmp46_ = _tmp45_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp43_, "CCode", "ref_sink_function", _tmp46_, NULL); + _g_free0 (_tmp46_); + } + _tmp47_ = self->priv->metadata; + if (vala_gir_parser_metadata_has_argument (_tmp47_, VALA_GIR_PARSER_ARGUMENT_TYPE_UNREF_FUNCTION)) { + ValaClass* _tmp48_; + ValaGirParserMetadata* _tmp49_; + gchar* _tmp50_; + gchar* _tmp51_; + _tmp48_ = cl; + _tmp49_ = self->priv->metadata; + _tmp50_ = vala_gir_parser_metadata_get_string (_tmp49_, VALA_GIR_PARSER_ARGUMENT_TYPE_UNREF_FUNCTION); + _tmp51_ = _tmp50_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp48_, "CCode", "unref_function", _tmp51_, NULL); + _g_free0 (_tmp51_); + } vala_gir_parser_next (self); - _tmp37_ = cl; - _tmp38_ = vala_gir_parser_parse_symbol_doc (self); - _tmp39_ = _tmp38_; - vala_symbol_set_comment ((ValaSymbol*) _tmp37_, (ValaComment*) _tmp39_); - _vala_comment_unref0 (_tmp39_); + _tmp52_ = cl; + _tmp53_ = vala_gir_parser_parse_symbol_doc (self); + _tmp54_ = _tmp53_; + vala_symbol_set_comment ((ValaSymbol*) _tmp52_, (ValaComment*) _tmp54_); + _vala_comment_unref0 (_tmp54_); ref_method = NULL; unref_method = NULL; while (TRUE) { - ValaMarkupTokenType _tmp40_; - ValaMarkupReader* _tmp41_; - const gchar* _tmp42_; - const gchar* _tmp43_; - _tmp40_ = self->priv->current_token; - if (!(_tmp40_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) { + ValaMarkupTokenType _tmp55_; + ValaMarkupReader* _tmp56_; + const gchar* _tmp57_; + const gchar* _tmp58_; + _tmp55_ = self->priv->current_token; + if (!(_tmp55_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) { break; } if (!vala_gir_parser_push_metadata (self)) { vala_gir_parser_skip_element (self); continue; } - _tmp41_ = self->priv->reader; - _tmp42_ = vala_markup_reader_get_name (_tmp41_); - _tmp43_ = _tmp42_; - if (g_strcmp0 (_tmp43_, "field") == 0) { + _tmp56_ = self->priv->reader; + _tmp57_ = vala_markup_reader_get_name (_tmp56_); + _tmp58_ = _tmp57_; + if (g_strcmp0 (_tmp58_, "field") == 0) { vala_gir_parser_parse_field (self); } else { - ValaMarkupReader* _tmp44_; - const gchar* _tmp45_; - const gchar* _tmp46_; - _tmp44_ = self->priv->reader; - _tmp45_ = vala_markup_reader_get_name (_tmp44_); - _tmp46_ = _tmp45_; - if (g_strcmp0 (_tmp46_, "constructor") == 0) { + ValaMarkupReader* _tmp59_; + const gchar* _tmp60_; + const gchar* _tmp61_; + _tmp59_ = self->priv->reader; + _tmp60_ = vala_markup_reader_get_name (_tmp59_); + _tmp61_ = _tmp60_; + if (g_strcmp0 (_tmp61_, "constructor") == 0) { vala_gir_parser_parse_constructor (self); } else { - ValaMarkupReader* _tmp47_; - const gchar* _tmp48_; - const gchar* _tmp49_; - _tmp47_ = self->priv->reader; - _tmp48_ = vala_markup_reader_get_name (_tmp47_); - _tmp49_ = _tmp48_; - if (g_strcmp0 (_tmp49_, "method") == 0) { + ValaMarkupReader* _tmp62_; + const gchar* _tmp63_; + const gchar* _tmp64_; + _tmp62_ = self->priv->reader; + _tmp63_ = vala_markup_reader_get_name (_tmp62_); + _tmp64_ = _tmp63_; + if (g_strcmp0 (_tmp64_, "method") == 0) { gchar* cname = NULL; - ValaGirParserNode* _tmp50_; - gchar* _tmp51_; - gboolean _tmp52_ = FALSE; - const gchar* _tmp53_; + ValaGirParserNode* _tmp65_; + gchar* _tmp66_; + gboolean _tmp67_ = FALSE; + const gchar* _tmp68_; vala_gir_parser_parse_method (self, "method"); - _tmp50_ = self->priv->old_current; - _tmp51_ = vala_gir_parser_node_get_cname (_tmp50_); - cname = _tmp51_; - _tmp53_ = cname; - if (g_str_has_suffix (_tmp53_, "_ref")) { - gboolean _tmp54_ = FALSE; - ValaGirParserNode* _tmp55_; - _tmp55_ = ref_method; - if (_tmp55_ == NULL) { - _tmp54_ = TRUE; + _tmp65_ = self->priv->old_current; + _tmp66_ = vala_gir_parser_node_get_cname (_tmp65_); + cname = _tmp66_; + _tmp68_ = cname; + if (g_str_has_suffix (_tmp68_, "_ref")) { + gboolean _tmp69_ = FALSE; + ValaGirParserNode* _tmp70_; + _tmp70_ = ref_method; + if (_tmp70_ == NULL) { + _tmp69_ = TRUE; } else { - ValaGirParserNode* _tmp56_; - const gchar* _tmp57_; - _tmp56_ = self->priv->old_current; - _tmp57_ = _tmp56_->name; - _tmp54_ = g_strcmp0 (_tmp57_, "ref") == 0; + ValaGirParserNode* _tmp71_; + const gchar* _tmp72_; + _tmp71_ = self->priv->old_current; + _tmp72_ = _tmp71_->name; + _tmp69_ = g_strcmp0 (_tmp72_, "ref") == 0; } - _tmp52_ = _tmp54_; + _tmp67_ = _tmp69_; } else { - _tmp52_ = FALSE; + _tmp67_ = FALSE; } - if (_tmp52_) { - ValaGirParserNode* _tmp58_; - ValaGirParserNode* _tmp59_; - _tmp58_ = self->priv->old_current; - _tmp59_ = _vala_gir_parser_node_ref0 (_tmp58_); + if (_tmp67_) { + ValaGirParserNode* _tmp73_; + ValaGirParserNode* _tmp74_; + _tmp73_ = self->priv->old_current; + _tmp74_ = _vala_gir_parser_node_ref0 (_tmp73_); _vala_gir_parser_node_unref0 (ref_method); - ref_method = _tmp59_; + ref_method = _tmp74_; } else { - gboolean _tmp60_ = FALSE; - const gchar* _tmp61_; - _tmp61_ = cname; - if (g_str_has_suffix (_tmp61_, "_unref")) { - gboolean _tmp62_ = FALSE; - ValaGirParserNode* _tmp63_; - _tmp63_ = unref_method; - if (_tmp63_ == NULL) { - _tmp62_ = TRUE; + gboolean _tmp75_ = FALSE; + const gchar* _tmp76_; + _tmp76_ = cname; + if (g_str_has_suffix (_tmp76_, "_unref")) { + gboolean _tmp77_ = FALSE; + ValaGirParserNode* _tmp78_; + _tmp78_ = unref_method; + if (_tmp78_ == NULL) { + _tmp77_ = TRUE; } else { - ValaGirParserNode* _tmp64_; - const gchar* _tmp65_; - _tmp64_ = self->priv->old_current; - _tmp65_ = _tmp64_->name; - _tmp62_ = g_strcmp0 (_tmp65_, "unref") == 0; + ValaGirParserNode* _tmp79_; + const gchar* _tmp80_; + _tmp79_ = self->priv->old_current; + _tmp80_ = _tmp79_->name; + _tmp77_ = g_strcmp0 (_tmp80_, "unref") == 0; } - _tmp60_ = _tmp62_; + _tmp75_ = _tmp77_; } else { - _tmp60_ = FALSE; + _tmp75_ = FALSE; } - if (_tmp60_) { - ValaGirParserNode* _tmp66_; - ValaGirParserNode* _tmp67_; - _tmp66_ = self->priv->old_current; - _tmp67_ = _vala_gir_parser_node_ref0 (_tmp66_); + if (_tmp75_) { + ValaGirParserNode* _tmp81_; + ValaGirParserNode* _tmp82_; + _tmp81_ = self->priv->old_current; + _tmp82_ = _vala_gir_parser_node_ref0 (_tmp81_); _vala_gir_parser_node_unref0 (unref_method); - unref_method = _tmp67_; + unref_method = _tmp82_; } } _g_free0 (cname); } else { - ValaMarkupReader* _tmp68_; - const gchar* _tmp69_; - const gchar* _tmp70_; - _tmp68_ = self->priv->reader; - _tmp69_ = vala_markup_reader_get_name (_tmp68_); - _tmp70_ = _tmp69_; - if (g_strcmp0 (_tmp70_, "function") == 0) { + ValaMarkupReader* _tmp83_; + const gchar* _tmp84_; + const gchar* _tmp85_; + _tmp83_ = self->priv->reader; + _tmp84_ = vala_markup_reader_get_name (_tmp83_); + _tmp85_ = _tmp84_; + if (g_strcmp0 (_tmp85_, "function") == 0) { vala_gir_parser_skip_element (self); } else { - ValaMarkupReader* _tmp71_; - const gchar* _tmp72_; - const gchar* _tmp73_; - _tmp71_ = self->priv->reader; - _tmp72_ = vala_markup_reader_get_name (_tmp71_); - _tmp73_ = _tmp72_; - if (g_strcmp0 (_tmp73_, "function-macro") == 0) { + ValaMarkupReader* _tmp86_; + const gchar* _tmp87_; + const gchar* _tmp88_; + _tmp86_ = self->priv->reader; + _tmp87_ = vala_markup_reader_get_name (_tmp86_); + _tmp88_ = _tmp87_; + if (g_strcmp0 (_tmp88_, "function-macro") == 0) { vala_gir_parser_skip_element (self); } else { - ValaMarkupReader* _tmp74_; - const gchar* _tmp75_; - const gchar* _tmp76_; - _tmp74_ = self->priv->reader; - _tmp75_ = vala_markup_reader_get_name (_tmp74_); - _tmp76_ = _tmp75_; - if (g_strcmp0 (_tmp76_, "union") == 0) { + ValaMarkupReader* _tmp89_; + const gchar* _tmp90_; + const gchar* _tmp91_; + _tmp89_ = self->priv->reader; + _tmp90_ = vala_markup_reader_get_name (_tmp89_); + _tmp91_ = _tmp90_; + if (g_strcmp0 (_tmp91_, "union") == 0) { vala_gir_parser_parse_union (self); } else { - ValaSourceReference* _tmp77_; - ValaSourceReference* _tmp78_; - ValaMarkupReader* _tmp79_; - const gchar* _tmp80_; - const gchar* _tmp81_; - _tmp77_ = vala_gir_parser_get_current_src (self); - _tmp78_ = _tmp77_; - _tmp79_ = self->priv->reader; - _tmp80_ = vala_markup_reader_get_name (_tmp79_); - _tmp81_ = _tmp80_; - vala_report_error (_tmp78_, "unknown child element `%s' in `class'", _tmp81_); - _vala_source_reference_unref0 (_tmp78_); + ValaSourceReference* _tmp92_; + ValaSourceReference* _tmp93_; + ValaMarkupReader* _tmp94_; + const gchar* _tmp95_; + const gchar* _tmp96_; + _tmp92_ = vala_gir_parser_get_current_src (self); + _tmp93_ = _tmp92_; + _tmp94_ = self->priv->reader; + _tmp95_ = vala_markup_reader_get_name (_tmp94_); + _tmp96_ = _tmp95_; + vala_report_error (_tmp93_, "unknown child element `%s' in `class'", _tmp96_); + _vala_source_reference_unref0 (_tmp93_); vala_gir_parser_skip_element (self); } } @@ -9560,69 +9647,69 @@ } vala_gir_parser_pop_metadata (self); } - _tmp85_ = cl; - if (vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp85_, "CCode", "ref_function")) { - _tmp84_ = TRUE; - } else { - ValaClass* _tmp86_; - _tmp86_ = cl; - _tmp84_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp86_, "CCode", "unref_function"); - } - if (_tmp84_) { - _tmp83_ = TRUE; - } else { - ValaClass* _tmp87_; - _tmp87_ = cl; - _tmp83_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp87_, "CCode", "copy_function"); - } - if (_tmp83_) { - _tmp82_ = TRUE; - } else { - ValaClass* _tmp88_; - _tmp88_ = cl; - _tmp82_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp88_, "CCode", "free_function"); - } - if (_tmp82_) { - } else { - gboolean _tmp89_ = FALSE; - ValaGirParserNode* _tmp90_; - _tmp90_ = ref_method; - if (_tmp90_ != NULL) { - ValaGirParserNode* _tmp91_; - _tmp91_ = unref_method; - _tmp89_ = _tmp91_ != NULL; - } else { - _tmp89_ = FALSE; - } - if (_tmp89_) { - ValaClass* _tmp92_; - ValaGirParserNode* _tmp93_; - gchar* _tmp94_; - gchar* _tmp95_; - ValaClass* _tmp96_; - ValaGirParserNode* _tmp97_; - gchar* _tmp98_; - gchar* _tmp99_; - _tmp92_ = cl; - _tmp93_ = ref_method; - _tmp94_ = vala_gir_parser_node_get_cname (_tmp93_); - _tmp95_ = _tmp94_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp92_, "CCode", "ref_function", _tmp95_, NULL); - _g_free0 (_tmp95_); - _tmp96_ = cl; - _tmp97_ = unref_method; - _tmp98_ = vala_gir_parser_node_get_cname (_tmp97_); - _tmp99_ = _tmp98_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp96_, "CCode", "unref_function", _tmp99_, NULL); - _g_free0 (_tmp99_); + _tmp100_ = cl; + if (vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp100_, "CCode", "ref_function")) { + _tmp99_ = TRUE; + } else { + ValaClass* _tmp101_; + _tmp101_ = cl; + _tmp99_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp101_, "CCode", "unref_function"); + } + if (_tmp99_) { + _tmp98_ = TRUE; + } else { + ValaClass* _tmp102_; + _tmp102_ = cl; + _tmp98_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp102_, "CCode", "copy_function"); + } + if (_tmp98_) { + _tmp97_ = TRUE; + } else { + ValaClass* _tmp103_; + _tmp103_ = cl; + _tmp97_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp103_, "CCode", "free_function"); + } + if (_tmp97_) { + } else { + gboolean _tmp104_ = FALSE; + ValaGirParserNode* _tmp105_; + _tmp105_ = ref_method; + if (_tmp105_ != NULL) { + ValaGirParserNode* _tmp106_; + _tmp106_ = unref_method; + _tmp104_ = _tmp106_ != NULL; + } else { + _tmp104_ = FALSE; + } + if (_tmp104_) { + ValaClass* _tmp107_; + ValaGirParserNode* _tmp108_; + gchar* _tmp109_; + gchar* _tmp110_; + ValaClass* _tmp111_; + ValaGirParserNode* _tmp112_; + gchar* _tmp113_; + gchar* _tmp114_; + _tmp107_ = cl; + _tmp108_ = ref_method; + _tmp109_ = vala_gir_parser_node_get_cname (_tmp108_); + _tmp110_ = _tmp109_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp107_, "CCode", "ref_function", _tmp110_, NULL); + _g_free0 (_tmp110_); + _tmp111_ = cl; + _tmp112_ = unref_method; + _tmp113_ = vala_gir_parser_node_get_cname (_tmp112_); + _tmp114_ = _tmp113_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp111_, "CCode", "unref_function", _tmp114_, NULL); + _g_free0 (_tmp114_); } else { if (require_copy_free) { - ValaClass* _tmp100_; - ValaClass* _tmp101_; - _tmp100_ = cl; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp100_, "CCode", "copy_function", "g_boxed_copy", NULL); - _tmp101_ = cl; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp101_, "CCode", "free_function", "g_boxed_free", NULL); + ValaClass* _tmp115_; + ValaClass* _tmp116_; + _tmp115_ = cl; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp115_, "CCode", "copy_function", "g_boxed_copy", NULL); + _tmp116_ = cl; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp116_, "CCode", "free_function", "g_boxed_free", NULL); } } } diff -Nru vala-0.52.6/vala/valagirparser.vala vala-0.52.7/vala/valagirparser.vala --- vala-0.52.6/vala/valagirparser.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vala/valagirparser.vala 2021-10-30 08:19:54.000000000 +0000 @@ -88,6 +88,9 @@ FLOATING, TYPE_ID, TYPE_GET_FUNCTION, + REF_FUNCTION, + REF_SINK_FUNCTION, + UNREF_FUNCTION, RETURN_VOID, RETURNS_MODIFIED_POINTER, DELEGATE_TARGET_CNAME, @@ -2995,6 +2998,16 @@ cl.access = SymbolAccessibility.PUBLIC; + if (metadata.has_argument (ArgumentType.REF_FUNCTION)) { + cl.set_attribute_string ("CCode", "ref_function", metadata.get_string (ArgumentType.REF_FUNCTION)); + } + if (metadata.has_argument (ArgumentType.REF_SINK_FUNCTION)) { + cl.set_attribute_string ("CCode", "ref_sink_function", metadata.get_string (ArgumentType.REF_SINK_FUNCTION)); + } + if (metadata.has_argument (ArgumentType.UNREF_FUNCTION)) { + cl.set_attribute_string ("CCode", "unref_function", metadata.get_string (ArgumentType.UNREF_FUNCTION)); + } + next (); cl.comment = parse_symbol_doc (); @@ -3557,6 +3570,15 @@ if (metadata.has_argument (ArgumentType.BASE_TYPE)) { cl.add_base_type (parse_type_from_string (metadata.get_string (ArgumentType.BASE_TYPE), true, metadata.get_source_reference (ArgumentType.BASE_TYPE))); } + if (metadata.has_argument (ArgumentType.REF_FUNCTION)) { + cl.set_attribute_string ("CCode", "ref_function", metadata.get_string (ArgumentType.REF_FUNCTION)); + } + if (metadata.has_argument (ArgumentType.REF_SINK_FUNCTION)) { + cl.set_attribute_string ("CCode", "ref_sink_function", metadata.get_string (ArgumentType.REF_SINK_FUNCTION)); + } + if (metadata.has_argument (ArgumentType.UNREF_FUNCTION)) { + cl.set_attribute_string ("CCode", "unref_function", metadata.get_string (ArgumentType.UNREF_FUNCTION)); + } next (); diff -Nru vala-0.52.6/vala/vala.h vala-0.52.7/vala/vala.h --- vala-0.52.6/vala/vala.h 2021-10-04 09:46:53.000000000 +0000 +++ vala-0.52.7/vala/vala.h 2021-10-30 08:24:06.000000000 +0000 @@ -6800,9 +6800,9 @@ gboolean value_owned); #define VALA_MAJOR_VERSION 0 #define VALA_MINOR_VERSION 52 -#define VALA_MICRO_VERSION 6 +#define VALA_MICRO_VERSION 7 #define VALA_API_VERSION "0.52" -#define VALA_BUILD_VERSION "0.52.6" +#define VALA_BUILD_VERSION "0.52.7" guint vala_get_major_version (void); guint vala_get_minor_version (void); guint vala_get_micro_version (void); diff -Nru vala-0.52.6/vala/valalambdaexpression.c vala-0.52.7/vala/valalambdaexpression.c --- vala-0.52.6/vala/valalambdaexpression.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valalambdaexpression.c 2021-10-30 08:24:06.000000000 +0000 @@ -399,12 +399,16 @@ ValaMethodType* _tmp253_; ValaDataType* _tmp254_; ValaDataType* _tmp255_; - ValaDataType* _tmp256_; - ValaDataType* _tmp257_; - gboolean _tmp258_; - gboolean _tmp259_; - gboolean _tmp260_; - gboolean _tmp261_; + ValaSourceReference* _tmp256_; + ValaSourceReference* _tmp257_; + ValaDataType* _tmp258_; + ValaDataType* _tmp259_; + ValaDataType* _tmp260_; + ValaDataType* _tmp261_; + gboolean _tmp262_; + gboolean _tmp263_; + gboolean _tmp264_; + gboolean _tmp265_; gboolean result = FALSE; self = (ValaLambdaExpression*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -1050,14 +1054,19 @@ _vala_code_node_unref0 (_tmp253_); _tmp254_ = vala_expression_get_value_type ((ValaExpression*) self); _tmp255_ = _tmp254_; - _tmp256_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp256_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp257_ = _tmp256_; - _tmp258_ = vala_data_type_get_value_owned (_tmp257_); + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp255_, _tmp257_); + _tmp258_ = vala_expression_get_value_type ((ValaExpression*) self); _tmp259_ = _tmp258_; - vala_data_type_set_value_owned (_tmp255_, _tmp259_); - _tmp260_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp260_ = vala_expression_get_target_type ((ValaExpression*) self); _tmp261_ = _tmp260_; - result = !_tmp261_; + _tmp262_ = vala_data_type_get_value_owned (_tmp261_); + _tmp263_ = _tmp262_; + vala_data_type_set_value_owned (_tmp259_, _tmp263_); + _tmp264_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp265_ = _tmp264_; + result = !_tmp265_; _vala_iterable_unref0 (error_types); _vala_iterator_unref0 (lambda_param_it); _vala_iterable_unref0 (lambda_params); diff -Nru vala-0.52.6/vala/valalambdaexpression.vala vala-0.52.7/vala/valalambdaexpression.vala --- vala-0.52.6/vala/valalambdaexpression.vala 2021-09-30 15:37:07.000000000 +0000 +++ vala-0.52.7/vala/valalambdaexpression.vala 2021-10-30 07:37:56.000000000 +0000 @@ -264,6 +264,7 @@ method.check (context); value_type = new MethodType (method); + value_type.source_reference = source_reference; value_type.value_owned = target_type.value_owned; return !error; diff -Nru vala-0.52.6/vala/valamemberaccess.c vala-0.52.7/vala/valamemberaccess.c --- vala-0.52.6/vala/valamemberaccess.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valamemberaccess.c 2021-10-30 08:24:06.000000000 +0000 @@ -795,42 +795,42 @@ GEqualFunc _tmp17_; ValaArrayList* _tmp18_; gboolean _tmp19_; - gboolean _tmp659_ = FALSE; - gboolean _tmp660_ = FALSE; - gboolean _tmp661_ = FALSE; - ValaExpression* _tmp662_; - ValaExpression* _tmp663_; - ValaSymbol* _tmp690_; - ValaSymbol* _tmp691_; - ValaSymbol* _tmp760_; - ValaSymbol* _tmp761_; + gboolean _tmp662_ = FALSE; + gboolean _tmp663_ = FALSE; + gboolean _tmp664_ = FALSE; + ValaExpression* _tmp665_; + ValaExpression* _tmp666_; + ValaSymbol* _tmp693_; + ValaSymbol* _tmp694_; + ValaSymbol* _tmp763_; + ValaSymbol* _tmp764_; ValaSymbol* member = NULL; - ValaSymbol* _tmp797_; - ValaSymbol* _tmp798_; + ValaSymbol* _tmp800_; + ValaSymbol* _tmp801_; ValaSymbolAccessibility access = 0; gboolean instance = FALSE; gboolean klass = FALSE; gboolean generics = FALSE; - ValaSymbol* _tmp799_; - ValaSymbol* _tmp800_; + ValaSymbol* _tmp802_; + ValaSymbol* _tmp803_; ValaCodeNode* parent = NULL; - ValaCodeNode* _tmp1248_; - ValaSymbol* _tmp1249_; - ValaSymbol* _tmp1251_; - ValaVersionAttribute* _tmp1252_; - ValaVersionAttribute* _tmp1253_; - ValaSourceReference* _tmp1254_; - ValaSourceReference* _tmp1255_; - gboolean _tmp1256_ = FALSE; - ValaSymbolAccessibility _tmp1257_; - gboolean _tmp1309_ = FALSE; - gboolean _tmp1336_ = FALSE; - gboolean _tmp1337_ = FALSE; - ValaDataType* _tmp1620_; - ValaDataType* _tmp1621_; - gboolean _tmp1624_; - gboolean _tmp1625_; - gboolean _tmp1626_; + ValaCodeNode* _tmp1251_; + ValaSymbol* _tmp1252_; + ValaSymbol* _tmp1254_; + ValaVersionAttribute* _tmp1255_; + ValaVersionAttribute* _tmp1256_; + ValaSourceReference* _tmp1257_; + ValaSourceReference* _tmp1258_; + gboolean _tmp1259_ = FALSE; + ValaSymbolAccessibility _tmp1260_; + gboolean _tmp1312_ = FALSE; + gboolean _tmp1339_ = FALSE; + gboolean _tmp1340_ = FALSE; + ValaDataType* _tmp1641_; + ValaDataType* _tmp1642_; + gboolean _tmp1645_; + gboolean _tmp1646_; + gboolean _tmp1647_; gboolean result = FALSE; self = (ValaMemberAccess*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -1589,8 +1589,8 @@ gboolean _tmp390_ = FALSE; ValaSymbol* _tmp391_; ValaSymbol* _tmp392_; - ValaSymbol* _tmp625_; - ValaSymbol* _tmp626_; + ValaSymbol* _tmp628_; + ValaSymbol* _tmp629_; _tmp248_ = vala_member_access_get_inner (self); _tmp249_ = _tmp248_; _tmp250_ = vala_code_node_get_error ((ValaCodeNode*) _tmp249_); @@ -1988,10 +1988,10 @@ ValaObjectType* _tmp407_; ValaCodeNode* _tmp408_; ValaCodeNode* _tmp409_; - ValaSymbol* _tmp573_; - ValaSymbol* _tmp574_; - ValaSymbol* _tmp623_; - ValaSymbol* _tmp624_; + ValaSymbol* _tmp576_; + ValaSymbol* _tmp577_; + ValaSymbol* _tmp626_; + ValaSymbol* _tmp627_; _tmp403_ = vala_member_access_get_inner (self); _tmp404_ = _tmp403_; _tmp405_ = vala_expression_get_value_type (_tmp404_); @@ -2031,30 +2031,33 @@ ValaDynamicMethod* _tmp441_; ValaMethodCall* _tmp442_; ValaErrorType* err = NULL; - ValaErrorType* _tmp443_; - ValaErrorType* _tmp444_; - ValaDynamicMethod* _tmp445_; + ValaDynamicMethod* _tmp443_; + ValaSourceReference* _tmp444_; + ValaSourceReference* _tmp445_; ValaErrorType* _tmp446_; - ValaDynamicMethod* _tmp447_; + ValaErrorType* _tmp447_; ValaDynamicMethod* _tmp448_; - ValaParameter* _tmp449_; - ValaParameter* _tmp450_; + ValaErrorType* _tmp449_; + ValaDynamicMethod* _tmp450_; ValaDynamicMethod* _tmp451_; - ValaObjectType* _tmp452_; - ValaDataType* _tmp453_; - ValaDataType* _tmp454_; - ValaDynamicMethod* _tmp455_; - ValaSourceReference* _tmp456_; - ValaSourceReference* _tmp457_; - ValaParameter* _tmp458_; - ValaParameter* _tmp459_; - ValaObjectType* _tmp460_; - ValaTypeSymbol* _tmp461_; - ValaTypeSymbol* _tmp462_; - ValaScope* _tmp463_; - ValaScope* _tmp464_; - ValaDynamicMethod* _tmp465_; - ValaDynamicMethod* _tmp466_; + ValaParameter* _tmp452_; + ValaParameter* _tmp453_; + ValaDynamicMethod* _tmp454_; + ValaObjectType* _tmp455_; + ValaDataType* _tmp456_; + ValaDataType* _tmp457_; + ValaDynamicMethod* _tmp458_; + ValaSourceReference* _tmp459_; + ValaSourceReference* _tmp460_; + ValaParameter* _tmp461_; + ValaParameter* _tmp462_; + ValaObjectType* _tmp463_; + ValaTypeSymbol* _tmp464_; + ValaTypeSymbol* _tmp465_; + ValaScope* _tmp466_; + ValaScope* _tmp467_; + ValaDynamicMethod* _tmp468_; + ValaDynamicMethod* _tmp469_; _tmp415_ = invoc; _tmp416_ = vala_expression_get_target_type ((ValaExpression*) _tmp415_); _tmp417_ = _tmp416_; @@ -2112,634 +2115,637 @@ _tmp441_ = m; _tmp442_ = invoc; vala_dynamic_method_set_invocation (_tmp441_, _tmp442_); - _tmp443_ = vala_error_type_new (NULL, NULL, NULL); - err = _tmp443_; - _tmp444_ = err; - vala_error_type_set_dynamic_error (_tmp444_, TRUE); - _tmp445_ = m; - _tmp446_ = err; - vala_method_add_error_type ((ValaMethod*) _tmp445_, (ValaDataType*) _tmp446_); - _tmp447_ = m; - vala_symbol_set_access ((ValaSymbol*) _tmp447_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp443_ = m; + _tmp444_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp443_); + _tmp445_ = _tmp444_; + _tmp446_ = vala_error_type_new (NULL, NULL, _tmp445_); + err = _tmp446_; + _tmp447_ = err; + vala_error_type_set_dynamic_error (_tmp447_, TRUE); _tmp448_ = m; - _tmp449_ = vala_parameter_new_with_ellipsis (NULL); - _tmp450_ = _tmp449_; - vala_callable_add_parameter ((ValaCallable*) _tmp448_, _tmp450_); - _vala_code_node_unref0 (_tmp450_); + _tmp449_ = err; + vala_method_add_error_type ((ValaMethod*) _tmp448_, (ValaDataType*) _tmp449_); + _tmp450_ = m; + vala_symbol_set_access ((ValaSymbol*) _tmp450_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); _tmp451_ = m; - _tmp452_ = dynamic_object_type; - _tmp453_ = vala_data_type_copy ((ValaDataType*) _tmp452_); - _tmp454_ = _tmp453_; - _tmp455_ = m; - _tmp456_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp455_); + _tmp452_ = vala_parameter_new_with_ellipsis (NULL); + _tmp453_ = _tmp452_; + vala_callable_add_parameter ((ValaCallable*) _tmp451_, _tmp453_); + _vala_code_node_unref0 (_tmp453_); + _tmp454_ = m; + _tmp455_ = dynamic_object_type; + _tmp456_ = vala_data_type_copy ((ValaDataType*) _tmp455_); _tmp457_ = _tmp456_; - _tmp458_ = vala_parameter_new ("this", _tmp454_, _tmp457_); - _tmp459_ = _tmp458_; - vala_method_set_this_parameter ((ValaMethod*) _tmp451_, _tmp459_); - _vala_code_node_unref0 (_tmp459_); - _vala_code_node_unref0 (_tmp454_); - _tmp460_ = dynamic_object_type; - _tmp461_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp460_); + _tmp458_ = m; + _tmp459_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp458_); + _tmp460_ = _tmp459_; + _tmp461_ = vala_parameter_new ("this", _tmp457_, _tmp460_); _tmp462_ = _tmp461_; - _tmp463_ = vala_symbol_get_scope ((ValaSymbol*) _tmp462_); - _tmp464_ = _tmp463_; - _tmp465_ = m; - vala_scope_add (_tmp464_, NULL, (ValaSymbol*) _tmp465_); - _tmp466_ = m; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp466_); + vala_method_set_this_parameter ((ValaMethod*) _tmp454_, _tmp462_); + _vala_code_node_unref0 (_tmp462_); + _vala_code_node_unref0 (_tmp457_); + _tmp463_ = dynamic_object_type; + _tmp464_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp463_); + _tmp465_ = _tmp464_; + _tmp466_ = vala_symbol_get_scope ((ValaSymbol*) _tmp465_); + _tmp467_ = _tmp466_; + _tmp468_ = m; + vala_scope_add (_tmp467_, NULL, (ValaSymbol*) _tmp468_); + _tmp469_ = m; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp469_); _vala_code_node_unref0 (err); _vala_code_node_unref0 (m); _vala_code_node_unref0 (ret_type); } } else { - ValaCodeNode* _tmp467_; - ValaCodeNode* _tmp468_; - _tmp467_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp468_ = _tmp467_; - if (VALA_IS_ASSIGNMENT (_tmp468_)) { + ValaCodeNode* _tmp470_; + ValaCodeNode* _tmp471_; + _tmp470_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp471_ = _tmp470_; + if (VALA_IS_ASSIGNMENT (_tmp471_)) { ValaAssignment* a = NULL; - ValaCodeNode* _tmp469_; - ValaCodeNode* _tmp470_; - ValaAssignment* _tmp471_; - ValaExpression* _tmp472_; - ValaExpression* _tmp473_; - _tmp469_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp470_ = _tmp469_; - a = G_TYPE_CHECK_INSTANCE_CAST (_tmp470_, VALA_TYPE_ASSIGNMENT, ValaAssignment); - _tmp471_ = a; - _tmp472_ = vala_assignment_get_left (_tmp471_); + ValaCodeNode* _tmp472_; + ValaCodeNode* _tmp473_; + ValaAssignment* _tmp474_; + ValaExpression* _tmp475_; + ValaExpression* _tmp476_; + _tmp472_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); _tmp473_ = _tmp472_; - if (_tmp473_ == G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_EXPRESSION, ValaExpression)) { + a = G_TYPE_CHECK_INSTANCE_CAST (_tmp473_, VALA_TYPE_ASSIGNMENT, ValaAssignment); + _tmp474_ = a; + _tmp475_ = vala_assignment_get_left (_tmp474_); + _tmp476_ = _tmp475_; + if (_tmp476_ == G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_EXPRESSION, ValaExpression)) { ValaDynamicProperty* prop = NULL; - ValaExpression* _tmp474_; - ValaExpression* _tmp475_; - ValaDataType* _tmp476_; - ValaDataType* _tmp477_; - const gchar* _tmp478_; - ValaSourceReference* _tmp479_; - ValaSourceReference* _tmp480_; - ValaDynamicProperty* _tmp481_; - ValaDynamicProperty* _tmp482_; - ValaDynamicProperty* _tmp483_; + ValaExpression* _tmp477_; + ValaExpression* _tmp478_; + ValaDataType* _tmp479_; + ValaDataType* _tmp480_; + const gchar* _tmp481_; + ValaSourceReference* _tmp482_; + ValaSourceReference* _tmp483_; ValaDynamicProperty* _tmp484_; - ValaSourceReference* _tmp485_; - ValaSourceReference* _tmp486_; - ValaPropertyAccessor* _tmp487_; - ValaPropertyAccessor* _tmp488_; - ValaDynamicProperty* _tmp489_; - ValaExpression* _tmp490_; - ValaExpression* _tmp491_; - ValaDataType* _tmp492_; - ValaDataType* _tmp493_; - ValaTypeSymbol* _tmp494_; - ValaTypeSymbol* _tmp495_; - ValaScope* _tmp496_; - ValaScope* _tmp497_; - ValaObjectType* _tmp498_; - ValaTypeSymbol* _tmp499_; - ValaTypeSymbol* _tmp500_; - ValaScope* _tmp501_; - ValaScope* _tmp502_; - ValaDynamicProperty* _tmp503_; - ValaDynamicProperty* _tmp504_; - _tmp474_ = vala_member_access_get_inner (self); - _tmp475_ = _tmp474_; - _tmp476_ = vala_expression_get_value_type (_tmp475_); - _tmp477_ = _tmp476_; - _tmp478_ = self->priv->_member_name; - _tmp479_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + ValaDynamicProperty* _tmp485_; + ValaDynamicProperty* _tmp486_; + ValaDynamicProperty* _tmp487_; + ValaSourceReference* _tmp488_; + ValaSourceReference* _tmp489_; + ValaPropertyAccessor* _tmp490_; + ValaPropertyAccessor* _tmp491_; + ValaDynamicProperty* _tmp492_; + ValaExpression* _tmp493_; + ValaExpression* _tmp494_; + ValaDataType* _tmp495_; + ValaDataType* _tmp496_; + ValaTypeSymbol* _tmp497_; + ValaTypeSymbol* _tmp498_; + ValaScope* _tmp499_; + ValaScope* _tmp500_; + ValaObjectType* _tmp501_; + ValaTypeSymbol* _tmp502_; + ValaTypeSymbol* _tmp503_; + ValaScope* _tmp504_; + ValaScope* _tmp505_; + ValaDynamicProperty* _tmp506_; + ValaDynamicProperty* _tmp507_; + _tmp477_ = vala_member_access_get_inner (self); + _tmp478_ = _tmp477_; + _tmp479_ = vala_expression_get_value_type (_tmp478_); _tmp480_ = _tmp479_; - _tmp481_ = vala_dynamic_property_new (_tmp477_, _tmp478_, _tmp480_, NULL); - prop = _tmp481_; - _tmp482_ = prop; - vala_symbol_set_access ((ValaSymbol*) _tmp482_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); - _tmp483_ = prop; - _tmp484_ = prop; - _tmp485_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp484_); - _tmp486_ = _tmp485_; - _tmp487_ = vala_property_accessor_new (FALSE, TRUE, FALSE, NULL, NULL, _tmp486_, NULL); - _tmp488_ = _tmp487_; - vala_property_set_set_accessor ((ValaProperty*) _tmp483_, _tmp488_); - _vala_code_node_unref0 (_tmp488_); - _tmp489_ = prop; - _tmp490_ = vala_member_access_get_inner (self); + _tmp481_ = self->priv->_member_name; + _tmp482_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp483_ = _tmp482_; + _tmp484_ = vala_dynamic_property_new (_tmp480_, _tmp481_, _tmp483_, NULL); + prop = _tmp484_; + _tmp485_ = prop; + vala_symbol_set_access ((ValaSymbol*) _tmp485_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp486_ = prop; + _tmp487_ = prop; + _tmp488_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp487_); + _tmp489_ = _tmp488_; + _tmp490_ = vala_property_accessor_new (FALSE, TRUE, FALSE, NULL, NULL, _tmp489_, NULL); _tmp491_ = _tmp490_; - _tmp492_ = vala_expression_get_value_type (_tmp491_); - _tmp493_ = _tmp492_; - _tmp494_ = vala_data_type_get_type_symbol (_tmp493_); - _tmp495_ = _tmp494_; - _tmp496_ = vala_symbol_get_scope ((ValaSymbol*) _tmp495_); - _tmp497_ = _tmp496_; - vala_symbol_set_owner ((ValaSymbol*) _tmp489_, _tmp497_); - _tmp498_ = dynamic_object_type; - _tmp499_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp498_); + vala_property_set_set_accessor ((ValaProperty*) _tmp486_, _tmp491_); + _vala_code_node_unref0 (_tmp491_); + _tmp492_ = prop; + _tmp493_ = vala_member_access_get_inner (self); + _tmp494_ = _tmp493_; + _tmp495_ = vala_expression_get_value_type (_tmp494_); + _tmp496_ = _tmp495_; + _tmp497_ = vala_data_type_get_type_symbol (_tmp496_); + _tmp498_ = _tmp497_; + _tmp499_ = vala_symbol_get_scope ((ValaSymbol*) _tmp498_); _tmp500_ = _tmp499_; - _tmp501_ = vala_symbol_get_scope ((ValaSymbol*) _tmp500_); - _tmp502_ = _tmp501_; - _tmp503_ = prop; - vala_scope_add (_tmp502_, NULL, (ValaSymbol*) _tmp503_); - _tmp504_ = prop; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp504_); + vala_symbol_set_owner ((ValaSymbol*) _tmp492_, _tmp500_); + _tmp501_ = dynamic_object_type; + _tmp502_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp501_); + _tmp503_ = _tmp502_; + _tmp504_ = vala_symbol_get_scope ((ValaSymbol*) _tmp503_); + _tmp505_ = _tmp504_; + _tmp506_ = prop; + vala_scope_add (_tmp505_, NULL, (ValaSymbol*) _tmp506_); + _tmp507_ = prop; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp507_); _vala_code_node_unref0 (prop); } } else { - gboolean _tmp505_ = FALSE; - gboolean _tmp506_ = FALSE; - ValaCodeNode* _tmp507_; - ValaCodeNode* _tmp508_; - _tmp507_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp508_ = _tmp507_; - if (VALA_IS_MEMBER_ACCESS (_tmp508_)) { - ValaExpression* _tmp509_; - ValaExpression* _tmp510_; - _tmp509_ = vala_member_access_get_inner (self); - _tmp510_ = _tmp509_; - _tmp506_ = VALA_IS_MEMBER_ACCESS (_tmp510_); + gboolean _tmp508_ = FALSE; + gboolean _tmp509_ = FALSE; + ValaCodeNode* _tmp510_; + ValaCodeNode* _tmp511_; + _tmp510_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp511_ = _tmp510_; + if (VALA_IS_MEMBER_ACCESS (_tmp511_)) { + ValaExpression* _tmp512_; + ValaExpression* _tmp513_; + _tmp512_ = vala_member_access_get_inner (self); + _tmp513_ = _tmp512_; + _tmp509_ = VALA_IS_MEMBER_ACCESS (_tmp513_); } else { - _tmp506_ = FALSE; + _tmp509_ = FALSE; } - if (_tmp506_) { - ValaCodeNode* _tmp511_; - ValaCodeNode* _tmp512_; - ValaCodeNode* _tmp513_; + if (_tmp509_) { ValaCodeNode* _tmp514_; - _tmp511_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp512_ = _tmp511_; - _tmp513_ = vala_code_node_get_parent_node (_tmp512_); - _tmp514_ = _tmp513_; - _tmp505_ = VALA_IS_METHOD_CALL (_tmp514_); + ValaCodeNode* _tmp515_; + ValaCodeNode* _tmp516_; + ValaCodeNode* _tmp517_; + _tmp514_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp515_ = _tmp514_; + _tmp516_ = vala_code_node_get_parent_node (_tmp515_); + _tmp517_ = _tmp516_; + _tmp508_ = VALA_IS_METHOD_CALL (_tmp517_); } else { - _tmp505_ = FALSE; + _tmp508_ = FALSE; } - if (_tmp505_) { + if (_tmp508_) { ValaMemberAccess* ma = NULL; - ValaCodeNode* _tmp515_; - ValaCodeNode* _tmp516_; - gboolean _tmp517_ = FALSE; - ValaMemberAccess* _tmp518_; - const gchar* _tmp519_; - _tmp515_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp516_ = _tmp515_; - ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp516_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess); - _tmp518_ = ma; - _tmp519_ = _tmp518_->priv->_member_name; - if (g_strcmp0 (_tmp519_, "connect") == 0) { - _tmp517_ = TRUE; + ValaCodeNode* _tmp518_; + ValaCodeNode* _tmp519_; + gboolean _tmp520_ = FALSE; + ValaMemberAccess* _tmp521_; + const gchar* _tmp522_; + _tmp518_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp519_ = _tmp518_; + ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp519_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess); + _tmp521_ = ma; + _tmp522_ = _tmp521_->priv->_member_name; + if (g_strcmp0 (_tmp522_, "connect") == 0) { + _tmp520_ = TRUE; } else { - ValaMemberAccess* _tmp520_; - const gchar* _tmp521_; - _tmp520_ = ma; - _tmp521_ = _tmp520_->priv->_member_name; - _tmp517_ = g_strcmp0 (_tmp521_, "connect_after") == 0; + ValaMemberAccess* _tmp523_; + const gchar* _tmp524_; + _tmp523_ = ma; + _tmp524_ = _tmp523_->priv->_member_name; + _tmp520_ = g_strcmp0 (_tmp524_, "connect_after") == 0; } - if (_tmp517_) { + if (_tmp520_) { ValaDynamicSignal* s = NULL; - ValaExpression* _tmp522_; - ValaExpression* _tmp523_; - ValaDataType* _tmp524_; - ValaDataType* _tmp525_; - const gchar* _tmp526_; - ValaVoidType* _tmp527_; - ValaVoidType* _tmp528_; - ValaSourceReference* _tmp529_; - ValaSourceReference* _tmp530_; - ValaDynamicSignal* _tmp531_; - ValaDynamicSignal* _tmp532_; + ValaExpression* _tmp525_; + ValaExpression* _tmp526_; + ValaDataType* _tmp527_; + ValaDataType* _tmp528_; + const gchar* _tmp529_; + ValaVoidType* _tmp530_; + ValaVoidType* _tmp531_; + ValaSourceReference* _tmp532_; + ValaSourceReference* _tmp533_; + ValaDynamicSignal* _tmp534_; + ValaDynamicSignal* _tmp535_; ValaMethodCall* mcall = NULL; - ValaCodeNode* _tmp533_; - ValaCodeNode* _tmp534_; - ValaCodeNode* _tmp535_; ValaCodeNode* _tmp536_; - ValaMethodCall* _tmp537_; - ValaMethodCall* _tmp538_; - ValaList* _tmp539_; - gint _tmp540_; - gint _tmp541_; - ValaDynamicSignal* _tmp565_; - ValaObjectType* _tmp566_; - ValaTypeSymbol* _tmp567_; - ValaTypeSymbol* _tmp568_; - ValaScope* _tmp569_; - ValaScope* _tmp570_; - ValaDynamicSignal* _tmp571_; - ValaDynamicSignal* _tmp572_; - _tmp522_ = vala_member_access_get_inner (self); - _tmp523_ = _tmp522_; - _tmp524_ = vala_expression_get_value_type (_tmp523_); - _tmp525_ = _tmp524_; - _tmp526_ = self->priv->_member_name; - _tmp527_ = vala_void_type_new (NULL); + ValaCodeNode* _tmp537_; + ValaCodeNode* _tmp538_; + ValaCodeNode* _tmp539_; + ValaMethodCall* _tmp540_; + ValaMethodCall* _tmp541_; + ValaList* _tmp542_; + gint _tmp543_; + gint _tmp544_; + ValaDynamicSignal* _tmp568_; + ValaObjectType* _tmp569_; + ValaTypeSymbol* _tmp570_; + ValaTypeSymbol* _tmp571_; + ValaScope* _tmp572_; + ValaScope* _tmp573_; + ValaDynamicSignal* _tmp574_; + ValaDynamicSignal* _tmp575_; + _tmp525_ = vala_member_access_get_inner (self); + _tmp526_ = _tmp525_; + _tmp527_ = vala_expression_get_value_type (_tmp526_); _tmp528_ = _tmp527_; - _tmp529_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp530_ = _tmp529_; - _tmp531_ = vala_dynamic_signal_new (_tmp525_, _tmp526_, (ValaDataType*) _tmp528_, _tmp530_, NULL); - _tmp532_ = _tmp531_; - _vala_code_node_unref0 (_tmp528_); - s = _tmp532_; - _tmp533_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp534_ = _tmp533_; - _tmp535_ = vala_code_node_get_parent_node (_tmp534_); - _tmp536_ = _tmp535_; - _tmp537_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp536_, VALA_TYPE_METHOD_CALL, ValaMethodCall)); - mcall = _tmp537_; - _tmp538_ = mcall; - _tmp539_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) _tmp538_); - _tmp540_ = vala_collection_get_size ((ValaCollection*) _tmp539_); - _tmp541_ = _tmp540_; - if (_tmp541_ > 0) { - ValaDynamicSignal* _tmp542_; - ValaMethodCall* _tmp543_; - ValaList* _tmp544_; - gpointer _tmp545_; - ValaExpression* _tmp546_; - ValaMemberAccess* arg = NULL; - ValaDynamicSignal* _tmp547_; - ValaExpression* _tmp548_; + _tmp529_ = self->priv->_member_name; + _tmp530_ = vala_void_type_new (NULL); + _tmp531_ = _tmp530_; + _tmp532_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp533_ = _tmp532_; + _tmp534_ = vala_dynamic_signal_new (_tmp528_, _tmp529_, (ValaDataType*) _tmp531_, _tmp533_, NULL); + _tmp535_ = _tmp534_; + _vala_code_node_unref0 (_tmp531_); + s = _tmp535_; + _tmp536_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp537_ = _tmp536_; + _tmp538_ = vala_code_node_get_parent_node (_tmp537_); + _tmp539_ = _tmp538_; + _tmp540_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp539_, VALA_TYPE_METHOD_CALL, ValaMethodCall)); + mcall = _tmp540_; + _tmp541_ = mcall; + _tmp542_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) _tmp541_); + _tmp543_ = vala_collection_get_size ((ValaCollection*) _tmp542_); + _tmp544_ = _tmp543_; + if (_tmp544_ > 0) { + ValaDynamicSignal* _tmp545_; + ValaMethodCall* _tmp546_; + ValaList* _tmp547_; + gpointer _tmp548_; ValaExpression* _tmp549_; - gboolean _tmp550_ = FALSE; - gboolean _tmp551_ = FALSE; - ValaMemberAccess* _tmp552_; - _tmp542_ = s; - _tmp543_ = mcall; - _tmp544_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) _tmp543_); - _tmp545_ = vala_list_get (_tmp544_, 0); - _tmp546_ = (ValaExpression*) _tmp545_; - vala_dynamic_signal_set_handler (_tmp542_, _tmp546_); - _vala_code_node_unref0 (_tmp546_); - _tmp547_ = s; - _tmp548_ = vala_dynamic_signal_get_handler (_tmp547_); - _tmp549_ = _tmp548_; - arg = VALA_IS_MEMBER_ACCESS (_tmp549_) ? ((ValaMemberAccess*) _tmp549_) : NULL; - _tmp552_ = arg; - if (_tmp552_ == NULL) { - _tmp551_ = TRUE; + ValaMemberAccess* arg = NULL; + ValaDynamicSignal* _tmp550_; + ValaExpression* _tmp551_; + ValaExpression* _tmp552_; + gboolean _tmp553_ = FALSE; + gboolean _tmp554_ = FALSE; + ValaMemberAccess* _tmp555_; + _tmp545_ = s; + _tmp546_ = mcall; + _tmp547_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) _tmp546_); + _tmp548_ = vala_list_get (_tmp547_, 0); + _tmp549_ = (ValaExpression*) _tmp548_; + vala_dynamic_signal_set_handler (_tmp545_, _tmp549_); + _vala_code_node_unref0 (_tmp549_); + _tmp550_ = s; + _tmp551_ = vala_dynamic_signal_get_handler (_tmp550_); + _tmp552_ = _tmp551_; + arg = VALA_IS_MEMBER_ACCESS (_tmp552_) ? ((ValaMemberAccess*) _tmp552_) : NULL; + _tmp555_ = arg; + if (_tmp555_ == NULL) { + _tmp554_ = TRUE; } else { - ValaMemberAccess* _tmp553_; - _tmp553_ = arg; - _tmp551_ = !vala_code_node_check ((ValaCodeNode*) _tmp553_, context); + ValaMemberAccess* _tmp556_; + _tmp556_ = arg; + _tmp554_ = !vala_code_node_check ((ValaCodeNode*) _tmp556_, context); } - if (_tmp551_) { - _tmp550_ = TRUE; + if (_tmp554_) { + _tmp553_ = TRUE; } else { - ValaMemberAccess* _tmp554_; - ValaSymbol* _tmp555_; - ValaSymbol* _tmp556_; - _tmp554_ = arg; - _tmp555_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp554_); - _tmp556_ = _tmp555_; - _tmp550_ = !VALA_IS_METHOD (_tmp556_); + ValaMemberAccess* _tmp557_; + ValaSymbol* _tmp558_; + ValaSymbol* _tmp559_; + _tmp557_ = arg; + _tmp558_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp557_); + _tmp559_ = _tmp558_; + _tmp553_ = !VALA_IS_METHOD (_tmp559_); } - if (_tmp550_) { - ValaDynamicSignal* _tmp557_; - ValaExpression* _tmp558_; - ValaExpression* _tmp559_; - ValaSourceReference* _tmp560_; - ValaSourceReference* _tmp561_; - ValaDynamicSignal* _tmp562_; - gchar* _tmp563_; - gchar* _tmp564_; + if (_tmp553_) { + ValaDynamicSignal* _tmp560_; + ValaExpression* _tmp561_; + ValaExpression* _tmp562_; + ValaSourceReference* _tmp563_; + ValaSourceReference* _tmp564_; + ValaDynamicSignal* _tmp565_; + gchar* _tmp566_; + gchar* _tmp567_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp557_ = s; - _tmp558_ = vala_dynamic_signal_get_handler (_tmp557_); - _tmp559_ = _tmp558_; - _tmp560_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp559_); - _tmp561_ = _tmp560_; - _tmp562_ = s; - _tmp563_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp562_); + _tmp560_ = s; + _tmp561_ = vala_dynamic_signal_get_handler (_tmp560_); + _tmp562_ = _tmp561_; + _tmp563_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp562_); _tmp564_ = _tmp563_; - vala_report_error (_tmp561_, "Invalid handler for `%s'", _tmp564_); - _g_free0 (_tmp564_); + _tmp565_ = s; + _tmp566_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp565_); + _tmp567_ = _tmp566_; + vala_report_error (_tmp564_, "Invalid handler for `%s'", _tmp567_); + _g_free0 (_tmp567_); } } - _tmp565_ = s; - vala_symbol_set_access ((ValaSymbol*) _tmp565_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); - _tmp566_ = dynamic_object_type; - _tmp567_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp566_); - _tmp568_ = _tmp567_; - _tmp569_ = vala_symbol_get_scope ((ValaSymbol*) _tmp568_); - _tmp570_ = _tmp569_; - _tmp571_ = s; - vala_scope_add (_tmp570_, NULL, (ValaSymbol*) _tmp571_); - _tmp572_ = s; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp572_); + _tmp568_ = s; + vala_symbol_set_access ((ValaSymbol*) _tmp568_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp569_ = dynamic_object_type; + _tmp570_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp569_); + _tmp571_ = _tmp570_; + _tmp572_ = vala_symbol_get_scope ((ValaSymbol*) _tmp571_); + _tmp573_ = _tmp572_; + _tmp574_ = s; + vala_scope_add (_tmp573_, NULL, (ValaSymbol*) _tmp574_); + _tmp575_ = s; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp575_); _vala_code_node_unref0 (mcall); _vala_code_node_unref0 (s); } } } } - _tmp573_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp574_ = _tmp573_; - if (_tmp574_ == NULL) { + _tmp576_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp577_ = _tmp576_; + if (_tmp577_ == NULL) { ValaDynamicProperty* prop = NULL; - ValaExpression* _tmp575_; - ValaExpression* _tmp576_; - ValaDataType* _tmp577_; - ValaDataType* _tmp578_; - const gchar* _tmp579_; - ValaSourceReference* _tmp580_; - ValaSourceReference* _tmp581_; - ValaDynamicProperty* _tmp582_; - ValaDataType* _tmp583_; - ValaDataType* _tmp584_; - ValaDynamicProperty* _tmp595_; - ValaDynamicProperty* _tmp596_; - ValaDynamicProperty* _tmp597_; - ValaDataType* _tmp598_; - ValaDataType* _tmp599_; - ValaDataType* _tmp600_; + ValaExpression* _tmp578_; + ValaExpression* _tmp579_; + ValaDataType* _tmp580_; + ValaDataType* _tmp581_; + const gchar* _tmp582_; + ValaSourceReference* _tmp583_; + ValaSourceReference* _tmp584_; + ValaDynamicProperty* _tmp585_; + ValaDataType* _tmp586_; + ValaDataType* _tmp587_; + ValaDynamicProperty* _tmp598_; + ValaDynamicProperty* _tmp599_; + ValaDynamicProperty* _tmp600_; ValaDataType* _tmp601_; - ValaDynamicProperty* _tmp602_; - ValaSourceReference* _tmp603_; - ValaSourceReference* _tmp604_; - ValaPropertyAccessor* _tmp605_; - ValaPropertyAccessor* _tmp606_; - ValaDynamicProperty* _tmp607_; - ValaExpression* _tmp608_; - ValaExpression* _tmp609_; - ValaDataType* _tmp610_; - ValaDataType* _tmp611_; - ValaTypeSymbol* _tmp612_; - ValaTypeSymbol* _tmp613_; - ValaScope* _tmp614_; - ValaScope* _tmp615_; - ValaObjectType* _tmp616_; - ValaTypeSymbol* _tmp617_; - ValaTypeSymbol* _tmp618_; - ValaScope* _tmp619_; - ValaScope* _tmp620_; - ValaDynamicProperty* _tmp621_; - ValaDynamicProperty* _tmp622_; - _tmp575_ = vala_member_access_get_inner (self); - _tmp576_ = _tmp575_; - _tmp577_ = vala_expression_get_value_type (_tmp576_); - _tmp578_ = _tmp577_; - _tmp579_ = self->priv->_member_name; - _tmp580_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + ValaDataType* _tmp602_; + ValaDataType* _tmp603_; + ValaDataType* _tmp604_; + ValaDynamicProperty* _tmp605_; + ValaSourceReference* _tmp606_; + ValaSourceReference* _tmp607_; + ValaPropertyAccessor* _tmp608_; + ValaPropertyAccessor* _tmp609_; + ValaDynamicProperty* _tmp610_; + ValaExpression* _tmp611_; + ValaExpression* _tmp612_; + ValaDataType* _tmp613_; + ValaDataType* _tmp614_; + ValaTypeSymbol* _tmp615_; + ValaTypeSymbol* _tmp616_; + ValaScope* _tmp617_; + ValaScope* _tmp618_; + ValaObjectType* _tmp619_; + ValaTypeSymbol* _tmp620_; + ValaTypeSymbol* _tmp621_; + ValaScope* _tmp622_; + ValaScope* _tmp623_; + ValaDynamicProperty* _tmp624_; + ValaDynamicProperty* _tmp625_; + _tmp578_ = vala_member_access_get_inner (self); + _tmp579_ = _tmp578_; + _tmp580_ = vala_expression_get_value_type (_tmp579_); _tmp581_ = _tmp580_; - _tmp582_ = vala_dynamic_property_new (_tmp578_, _tmp579_, _tmp581_, NULL); - prop = _tmp582_; - _tmp583_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp582_ = self->priv->_member_name; + _tmp583_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp584_ = _tmp583_; - if (_tmp584_ != NULL) { - ValaDynamicProperty* _tmp585_; - ValaDataType* _tmp586_; - ValaDataType* _tmp587_; - _tmp585_ = prop; - _tmp586_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp587_ = _tmp586_; - vala_property_set_property_type ((ValaProperty*) _tmp585_, _tmp587_); - } else { + _tmp585_ = vala_dynamic_property_new (_tmp581_, _tmp582_, _tmp584_, NULL); + prop = _tmp585_; + _tmp586_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp587_ = _tmp586_; + if (_tmp587_ != NULL) { ValaDynamicProperty* _tmp588_; - ValaExpression* _tmp589_; - ValaExpression* _tmp590_; - ValaDataType* _tmp591_; - ValaDataType* _tmp592_; - ValaDataType* _tmp593_; - ValaDataType* _tmp594_; + ValaDataType* _tmp589_; + ValaDataType* _tmp590_; _tmp588_ = prop; - _tmp589_ = vala_member_access_get_inner (self); + _tmp589_ = vala_expression_get_target_type ((ValaExpression*) self); _tmp590_ = _tmp589_; - _tmp591_ = vala_expression_get_value_type (_tmp590_); - _tmp592_ = _tmp591_; - _tmp593_ = vala_data_type_copy (_tmp592_); - _tmp594_ = _tmp593_; - vala_property_set_property_type ((ValaProperty*) _tmp588_, _tmp594_); - _vala_code_node_unref0 (_tmp594_); + vala_property_set_property_type ((ValaProperty*) _tmp588_, _tmp590_); + } else { + ValaDynamicProperty* _tmp591_; + ValaExpression* _tmp592_; + ValaExpression* _tmp593_; + ValaDataType* _tmp594_; + ValaDataType* _tmp595_; + ValaDataType* _tmp596_; + ValaDataType* _tmp597_; + _tmp591_ = prop; + _tmp592_ = vala_member_access_get_inner (self); + _tmp593_ = _tmp592_; + _tmp594_ = vala_expression_get_value_type (_tmp593_); + _tmp595_ = _tmp594_; + _tmp596_ = vala_data_type_copy (_tmp595_); + _tmp597_ = _tmp596_; + vala_property_set_property_type ((ValaProperty*) _tmp591_, _tmp597_); + _vala_code_node_unref0 (_tmp597_); } - _tmp595_ = prop; - vala_symbol_set_access ((ValaSymbol*) _tmp595_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); - _tmp596_ = prop; - _tmp597_ = prop; - _tmp598_ = vala_property_get_property_type ((ValaProperty*) _tmp597_); - _tmp599_ = _tmp598_; - _tmp600_ = vala_data_type_copy (_tmp599_); - _tmp601_ = _tmp600_; - _tmp602_ = prop; - _tmp603_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp602_); + _tmp598_ = prop; + vala_symbol_set_access ((ValaSymbol*) _tmp598_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp599_ = prop; + _tmp600_ = prop; + _tmp601_ = vala_property_get_property_type ((ValaProperty*) _tmp600_); + _tmp602_ = _tmp601_; + _tmp603_ = vala_data_type_copy (_tmp602_); _tmp604_ = _tmp603_; - _tmp605_ = vala_property_accessor_new (TRUE, FALSE, FALSE, _tmp601_, NULL, _tmp604_, NULL); - _tmp606_ = _tmp605_; - vala_property_set_get_accessor ((ValaProperty*) _tmp596_, _tmp606_); - _vala_code_node_unref0 (_tmp606_); - _vala_code_node_unref0 (_tmp601_); - _tmp607_ = prop; - _tmp608_ = vala_member_access_get_inner (self); + _tmp605_ = prop; + _tmp606_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp605_); + _tmp607_ = _tmp606_; + _tmp608_ = vala_property_accessor_new (TRUE, FALSE, FALSE, _tmp604_, NULL, _tmp607_, NULL); _tmp609_ = _tmp608_; - _tmp610_ = vala_expression_get_value_type (_tmp609_); - _tmp611_ = _tmp610_; - _tmp612_ = vala_data_type_get_type_symbol (_tmp611_); - _tmp613_ = _tmp612_; - _tmp614_ = vala_symbol_get_scope ((ValaSymbol*) _tmp613_); - _tmp615_ = _tmp614_; - vala_symbol_set_owner ((ValaSymbol*) _tmp607_, _tmp615_); - _tmp616_ = dynamic_object_type; - _tmp617_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp616_); + vala_property_set_get_accessor ((ValaProperty*) _tmp599_, _tmp609_); + _vala_code_node_unref0 (_tmp609_); + _vala_code_node_unref0 (_tmp604_); + _tmp610_ = prop; + _tmp611_ = vala_member_access_get_inner (self); + _tmp612_ = _tmp611_; + _tmp613_ = vala_expression_get_value_type (_tmp612_); + _tmp614_ = _tmp613_; + _tmp615_ = vala_data_type_get_type_symbol (_tmp614_); + _tmp616_ = _tmp615_; + _tmp617_ = vala_symbol_get_scope ((ValaSymbol*) _tmp616_); _tmp618_ = _tmp617_; - _tmp619_ = vala_symbol_get_scope ((ValaSymbol*) _tmp618_); - _tmp620_ = _tmp619_; - _tmp621_ = prop; - vala_scope_add (_tmp620_, NULL, (ValaSymbol*) _tmp621_); - _tmp622_ = prop; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp622_); + vala_symbol_set_owner ((ValaSymbol*) _tmp610_, _tmp618_); + _tmp619_ = dynamic_object_type; + _tmp620_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp619_); + _tmp621_ = _tmp620_; + _tmp622_ = vala_symbol_get_scope ((ValaSymbol*) _tmp621_); + _tmp623_ = _tmp622_; + _tmp624_ = prop; + vala_scope_add (_tmp623_, NULL, (ValaSymbol*) _tmp624_); + _tmp625_ = prop; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp625_); _vala_code_node_unref0 (prop); } - _tmp623_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp624_ = _tmp623_; - if (_tmp624_ != NULL) { + _tmp626_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp627_ = _tmp626_; + if (_tmp627_ != NULL) { may_access_instance_members = TRUE; may_access_klass_members = TRUE; } _vala_code_node_unref0 (dynamic_object_type); } - _tmp625_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp626_ = _tmp625_; - if (VALA_IS_ARRAY_RESIZE_METHOD (_tmp626_)) { - ValaExpression* _tmp627_; - ValaExpression* _tmp628_; - ValaSymbol* _tmp629_; - ValaSymbol* _tmp630_; - _tmp627_ = vala_member_access_get_inner (self); - _tmp628_ = _tmp627_; - _tmp629_ = vala_expression_get_symbol_reference (_tmp628_); - _tmp630_ = _tmp629_; - if (VALA_IS_VARIABLE (_tmp630_)) { + _tmp628_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp629_ = _tmp628_; + if (VALA_IS_ARRAY_RESIZE_METHOD (_tmp629_)) { + ValaExpression* _tmp630_; + ValaExpression* _tmp631_; + ValaSymbol* _tmp632_; + ValaSymbol* _tmp633_; + _tmp630_ = vala_member_access_get_inner (self); + _tmp631_ = _tmp630_; + _tmp632_ = vala_expression_get_symbol_reference (_tmp631_); + _tmp633_ = _tmp632_; + if (VALA_IS_VARIABLE (_tmp633_)) { ValaArrayType* inner_type = NULL; - ValaSemanticAnalyzer* _tmp631_; - ValaSemanticAnalyzer* _tmp632_; - ValaExpression* _tmp633_; - ValaExpression* _tmp634_; - ValaSymbol* _tmp635_; - ValaSymbol* _tmp636_; - ValaDataType* _tmp637_; - ValaArrayType* _tmp638_; - gboolean _tmp639_ = FALSE; - ValaArrayType* _tmp640_; - _tmp631_ = vala_code_context_get_analyzer (context); - _tmp632_ = _tmp631_; - _tmp633_ = vala_member_access_get_inner (self); - _tmp634_ = _tmp633_; - _tmp635_ = vala_expression_get_symbol_reference (_tmp634_); - _tmp636_ = _tmp635_; - _tmp637_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp632_, _tmp636_, TRUE); - _tmp638_ = VALA_IS_ARRAY_TYPE (_tmp637_) ? ((ValaArrayType*) _tmp637_) : NULL; - if (_tmp638_ == NULL) { - _vala_code_node_unref0 (_tmp637_); + ValaSemanticAnalyzer* _tmp634_; + ValaSemanticAnalyzer* _tmp635_; + ValaExpression* _tmp636_; + ValaExpression* _tmp637_; + ValaSymbol* _tmp638_; + ValaSymbol* _tmp639_; + ValaDataType* _tmp640_; + ValaArrayType* _tmp641_; + gboolean _tmp642_ = FALSE; + ValaArrayType* _tmp643_; + _tmp634_ = vala_code_context_get_analyzer (context); + _tmp635_ = _tmp634_; + _tmp636_ = vala_member_access_get_inner (self); + _tmp637_ = _tmp636_; + _tmp638_ = vala_expression_get_symbol_reference (_tmp637_); + _tmp639_ = _tmp638_; + _tmp640_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp635_, _tmp639_, TRUE); + _tmp641_ = VALA_IS_ARRAY_TYPE (_tmp640_) ? ((ValaArrayType*) _tmp640_) : NULL; + if (_tmp641_ == NULL) { + _vala_code_node_unref0 (_tmp640_); } - inner_type = _tmp638_; - _tmp640_ = inner_type; - if (_tmp640_ != NULL) { - ValaArrayType* _tmp641_; - gboolean _tmp642_; - gboolean _tmp643_; - _tmp641_ = inner_type; - _tmp642_ = vala_array_type_get_inline_allocated (_tmp641_); - _tmp643_ = _tmp642_; - _tmp639_ = _tmp643_; + inner_type = _tmp641_; + _tmp643_ = inner_type; + if (_tmp643_ != NULL) { + ValaArrayType* _tmp644_; + gboolean _tmp645_; + gboolean _tmp646_; + _tmp644_ = inner_type; + _tmp645_ = vala_array_type_get_inline_allocated (_tmp644_); + _tmp646_ = _tmp645_; + _tmp642_ = _tmp646_; } else { - _tmp639_ = FALSE; + _tmp642_ = FALSE; } - if (_tmp639_) { - ValaSourceReference* _tmp644_; - ValaSourceReference* _tmp645_; - _tmp644_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp645_ = _tmp644_; - vala_report_error (_tmp645_, "`resize' is not supported for arrays with fixed length"); + if (_tmp642_) { + ValaSourceReference* _tmp647_; + ValaSourceReference* _tmp648_; + _tmp647_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp648_ = _tmp647_; + vala_report_error (_tmp648_, "`resize' is not supported for arrays with fixed length"); vala_code_node_set_error ((ValaCodeNode*) self, TRUE); } else { - gboolean _tmp646_ = FALSE; - ValaArrayType* _tmp647_; - _tmp647_ = inner_type; - if (_tmp647_ != NULL) { - ValaArrayType* _tmp648_; - gboolean _tmp649_; - gboolean _tmp650_; - _tmp648_ = inner_type; - _tmp649_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp648_); - _tmp650_ = _tmp649_; - _tmp646_ = !_tmp650_; + gboolean _tmp649_ = FALSE; + ValaArrayType* _tmp650_; + _tmp650_ = inner_type; + if (_tmp650_ != NULL) { + ValaArrayType* _tmp651_; + gboolean _tmp652_; + gboolean _tmp653_; + _tmp651_ = inner_type; + _tmp652_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp651_); + _tmp653_ = _tmp652_; + _tmp649_ = !_tmp653_; } else { - _tmp646_ = FALSE; + _tmp649_ = FALSE; } - if (_tmp646_) { - ValaSourceReference* _tmp651_; - ValaSourceReference* _tmp652_; - _tmp651_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp652_ = _tmp651_; - vala_report_error (_tmp652_, "`resize' is not allowed for unowned array references"); + if (_tmp649_) { + ValaSourceReference* _tmp654_; + ValaSourceReference* _tmp655_; + _tmp654_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp655_ = _tmp654_; + vala_report_error (_tmp655_, "`resize' is not allowed for unowned array references"); vala_code_node_set_error ((ValaCodeNode*) self, TRUE); } } _vala_code_node_unref0 (inner_type); } else { - ValaExpression* _tmp653_; - ValaExpression* _tmp654_; - ValaSymbol* _tmp655_; - ValaSymbol* _tmp656_; - _tmp653_ = vala_member_access_get_inner (self); - _tmp654_ = _tmp653_; - _tmp655_ = vala_expression_get_symbol_reference (_tmp654_); - _tmp656_ = _tmp655_; - if (VALA_IS_CONSTANT (_tmp656_)) { - ValaSourceReference* _tmp657_; - ValaSourceReference* _tmp658_; - _tmp657_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp658_ = _tmp657_; - vala_report_error (_tmp658_, "`resize' is not allowed for constant arrays"); + ValaExpression* _tmp656_; + ValaExpression* _tmp657_; + ValaSymbol* _tmp658_; + ValaSymbol* _tmp659_; + _tmp656_ = vala_member_access_get_inner (self); + _tmp657_ = _tmp656_; + _tmp658_ = vala_expression_get_symbol_reference (_tmp657_); + _tmp659_ = _tmp658_; + if (VALA_IS_CONSTANT (_tmp659_)) { + ValaSourceReference* _tmp660_; + ValaSourceReference* _tmp661_; + _tmp660_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp661_ = _tmp660_; + vala_report_error (_tmp661_, "`resize' is not allowed for constant arrays"); vala_code_node_set_error ((ValaCodeNode*) self, TRUE); } } } } } - _tmp662_ = vala_member_access_get_inner (self); - _tmp663_ = _tmp662_; - if (_tmp663_ == NULL) { - ValaSymbol* _tmp664_; - ValaSymbol* _tmp665_; - _tmp664_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp665_ = _tmp664_; - _tmp661_ = _tmp665_ == NULL; - } else { - _tmp661_ = FALSE; - } - if (_tmp661_) { - ValaDataType* _tmp666_; - ValaDataType* _tmp667_; - _tmp666_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp667_ = _tmp666_; - _tmp660_ = _tmp667_ != NULL; + _tmp665_ = vala_member_access_get_inner (self); + _tmp666_ = _tmp665_; + if (_tmp666_ == NULL) { + ValaSymbol* _tmp667_; + ValaSymbol* _tmp668_; + _tmp667_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp668_ = _tmp667_; + _tmp664_ = _tmp668_ == NULL; } else { - _tmp660_ = FALSE; + _tmp664_ = FALSE; } - if (_tmp660_) { - ValaDataType* _tmp668_; + if (_tmp664_) { ValaDataType* _tmp669_; - ValaTypeSymbol* _tmp670_; - ValaTypeSymbol* _tmp671_; - _tmp668_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp669_ = _tmp668_; - _tmp670_ = vala_data_type_get_type_symbol (_tmp669_); - _tmp671_ = _tmp670_; - _tmp659_ = VALA_IS_ENUM (_tmp671_); + ValaDataType* _tmp670_; + _tmp669_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp670_ = _tmp669_; + _tmp663_ = _tmp670_ != NULL; } else { - _tmp659_ = FALSE; + _tmp663_ = FALSE; } - if (_tmp659_) { - ValaEnum* enum_type = NULL; + if (_tmp663_) { + ValaDataType* _tmp671_; ValaDataType* _tmp672_; - ValaDataType* _tmp673_; + ValaTypeSymbol* _tmp673_; ValaTypeSymbol* _tmp674_; - ValaTypeSymbol* _tmp675_; - _tmp672_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp673_ = _tmp672_; - _tmp674_ = vala_data_type_get_type_symbol (_tmp673_); - _tmp675_ = _tmp674_; - enum_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp675_, VALA_TYPE_ENUM, ValaEnum); + _tmp671_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp672_ = _tmp671_; + _tmp673_ = vala_data_type_get_type_symbol (_tmp672_); + _tmp674_ = _tmp673_; + _tmp662_ = VALA_IS_ENUM (_tmp674_); + } else { + _tmp662_ = FALSE; + } + if (_tmp662_) { + ValaEnum* enum_type = NULL; + ValaDataType* _tmp675_; + ValaDataType* _tmp676_; + ValaTypeSymbol* _tmp677_; + ValaTypeSymbol* _tmp678_; + _tmp675_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp676_ = _tmp675_; + _tmp677_ = vala_data_type_get_type_symbol (_tmp676_); + _tmp678_ = _tmp677_; + enum_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp678_, VALA_TYPE_ENUM, ValaEnum); { ValaList* _val_list = NULL; - ValaEnum* _tmp676_; - ValaList* _tmp677_; + ValaEnum* _tmp679_; + ValaList* _tmp680_; gint _val_size = 0; - ValaList* _tmp678_; - gint _tmp679_; - gint _tmp680_; + ValaList* _tmp681_; + gint _tmp682_; + gint _tmp683_; gint _val_index = 0; - _tmp676_ = enum_type; - _tmp677_ = vala_enum_get_values (_tmp676_); - _val_list = _tmp677_; - _tmp678_ = _val_list; - _tmp679_ = vala_collection_get_size ((ValaCollection*) _tmp678_); - _tmp680_ = _tmp679_; - _val_size = _tmp680_; + _tmp679_ = enum_type; + _tmp680_ = vala_enum_get_values (_tmp679_); + _val_list = _tmp680_; + _tmp681_ = _val_list; + _tmp682_ = vala_collection_get_size ((ValaCollection*) _tmp681_); + _tmp683_ = _tmp682_; + _val_size = _tmp683_; _val_index = -1; while (TRUE) { - gint _tmp681_; - gint _tmp682_; + gint _tmp684_; + gint _tmp685_; ValaEnumValue* val = NULL; - ValaList* _tmp683_; - gpointer _tmp684_; - const gchar* _tmp685_; - ValaEnumValue* _tmp686_; - const gchar* _tmp687_; + ValaList* _tmp686_; + gpointer _tmp687_; const gchar* _tmp688_; + ValaEnumValue* _tmp689_; + const gchar* _tmp690_; + const gchar* _tmp691_; _val_index = _val_index + 1; - _tmp681_ = _val_index; - _tmp682_ = _val_size; - if (!(_tmp681_ < _tmp682_)) { + _tmp684_ = _val_index; + _tmp685_ = _val_size; + if (!(_tmp684_ < _tmp685_)) { break; } - _tmp683_ = _val_list; - _tmp684_ = vala_list_get (_tmp683_, _val_index); - val = (ValaEnumValue*) _tmp684_; - _tmp685_ = self->priv->_member_name; - _tmp686_ = val; - _tmp687_ = vala_symbol_get_name ((ValaSymbol*) _tmp686_); - _tmp688_ = _tmp687_; - if (g_strcmp0 (_tmp685_, _tmp688_) == 0) { - ValaEnumValue* _tmp689_; - _tmp689_ = val; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp689_); + _tmp686_ = _val_list; + _tmp687_ = vala_list_get (_tmp686_, _val_index); + val = (ValaEnumValue*) _tmp687_; + _tmp688_ = self->priv->_member_name; + _tmp689_ = val; + _tmp690_ = vala_symbol_get_name ((ValaSymbol*) _tmp689_); + _tmp691_ = _tmp690_; + if (g_strcmp0 (_tmp688_, _tmp691_) == 0) { + ValaEnumValue* _tmp692_; + _tmp692_ = val; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp692_); _vala_code_node_unref0 (val); break; } @@ -2747,197 +2753,197 @@ } } } - _tmp690_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp691_ = _tmp690_; - if (_tmp691_ == NULL) { + _tmp693_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp694_ = _tmp693_; + if (_tmp694_ == NULL) { gchar* base_type_name = NULL; - gchar* _tmp692_; + gchar* _tmp695_; ValaSymbol* base_type = NULL; - gboolean _tmp693_ = FALSE; - ValaExpression* _tmp694_; - ValaExpression* _tmp695_; + gboolean _tmp696_ = FALSE; + ValaExpression* _tmp697_; + ValaExpression* _tmp698_; gchar* base_type_package = NULL; - gchar* _tmp715_; - gboolean _tmp716_ = FALSE; - ValaSymbol* _tmp717_; + gchar* _tmp718_; + gboolean _tmp719_ = FALSE; + ValaSymbol* _tmp720_; gchar* visited_types_string = NULL; - gchar* _tmp732_; - ValaSourceReference* _tmp748_; - ValaSourceReference* _tmp749_; - const gchar* _tmp750_; - const gchar* _tmp751_; - const gchar* _tmp752_; + gchar* _tmp735_; + ValaSourceReference* _tmp751_; + ValaSourceReference* _tmp752_; const gchar* _tmp753_; - ValaInvalidType* _tmp754_; - ValaInvalidType* _tmp755_; + const gchar* _tmp754_; + const gchar* _tmp755_; + const gchar* _tmp756_; + ValaInvalidType* _tmp757_; + ValaInvalidType* _tmp758_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp692_ = g_strdup ("(null)"); - base_type_name = _tmp692_; + _tmp695_ = g_strdup ("(null)"); + base_type_name = _tmp695_; base_type = NULL; - _tmp694_ = vala_member_access_get_inner (self); - _tmp695_ = _tmp694_; - if (_tmp695_ != NULL) { - ValaExpression* _tmp696_; - ValaExpression* _tmp697_; - ValaDataType* _tmp698_; - ValaDataType* _tmp699_; - _tmp696_ = vala_member_access_get_inner (self); - _tmp697_ = _tmp696_; - _tmp698_ = vala_expression_get_value_type (_tmp697_); - _tmp699_ = _tmp698_; - _tmp693_ = _tmp699_ != NULL; - } else { - _tmp693_ = FALSE; - } - if (_tmp693_) { + _tmp697_ = vala_member_access_get_inner (self); + _tmp698_ = _tmp697_; + if (_tmp698_ != NULL) { + ValaExpression* _tmp699_; ValaExpression* _tmp700_; - ValaExpression* _tmp701_; + ValaDataType* _tmp701_; ValaDataType* _tmp702_; - ValaDataType* _tmp703_; - gchar* _tmp704_; - ValaExpression* _tmp705_; - ValaExpression* _tmp706_; - ValaDataType* _tmp707_; - ValaDataType* _tmp708_; - ValaTypeSymbol* _tmp709_; - ValaTypeSymbol* _tmp710_; - _tmp700_ = vala_member_access_get_inner (self); - _tmp701_ = _tmp700_; - _tmp702_ = vala_expression_get_value_type (_tmp701_); - _tmp703_ = _tmp702_; - _tmp704_ = vala_code_node_to_string ((ValaCodeNode*) _tmp703_); - _g_free0 (base_type_name); - base_type_name = _tmp704_; - _tmp705_ = vala_member_access_get_inner (self); + _tmp699_ = vala_member_access_get_inner (self); + _tmp700_ = _tmp699_; + _tmp701_ = vala_expression_get_value_type (_tmp700_); + _tmp702_ = _tmp701_; + _tmp696_ = _tmp702_ != NULL; + } else { + _tmp696_ = FALSE; + } + if (_tmp696_) { + ValaExpression* _tmp703_; + ValaExpression* _tmp704_; + ValaDataType* _tmp705_; + ValaDataType* _tmp706_; + gchar* _tmp707_; + ValaExpression* _tmp708_; + ValaExpression* _tmp709_; + ValaDataType* _tmp710_; + ValaDataType* _tmp711_; + ValaTypeSymbol* _tmp712_; + ValaTypeSymbol* _tmp713_; + _tmp703_ = vala_member_access_get_inner (self); + _tmp704_ = _tmp703_; + _tmp705_ = vala_expression_get_value_type (_tmp704_); _tmp706_ = _tmp705_; - _tmp707_ = vala_expression_get_value_type (_tmp706_); - _tmp708_ = _tmp707_; - _tmp709_ = vala_data_type_get_type_symbol (_tmp708_); - _tmp710_ = _tmp709_; - base_type = (ValaSymbol*) _tmp710_; + _tmp707_ = vala_code_node_to_string ((ValaCodeNode*) _tmp706_); + _g_free0 (base_type_name); + base_type_name = _tmp707_; + _tmp708_ = vala_member_access_get_inner (self); + _tmp709_ = _tmp708_; + _tmp710_ = vala_expression_get_value_type (_tmp709_); + _tmp711_ = _tmp710_; + _tmp712_ = vala_data_type_get_type_symbol (_tmp711_); + _tmp713_ = _tmp712_; + base_type = (ValaSymbol*) _tmp713_; } else { - ValaSymbol* _tmp711_; - _tmp711_ = base_symbol; - if (_tmp711_ != NULL) { - ValaSymbol* _tmp712_; - gchar* _tmp713_; - ValaSymbol* _tmp714_; - _tmp712_ = base_symbol; - _tmp713_ = vala_symbol_get_full_name (_tmp712_); + ValaSymbol* _tmp714_; + _tmp714_ = base_symbol; + if (_tmp714_ != NULL) { + ValaSymbol* _tmp715_; + gchar* _tmp716_; + ValaSymbol* _tmp717_; + _tmp715_ = base_symbol; + _tmp716_ = vala_symbol_get_full_name (_tmp715_); _g_free0 (base_type_name); - base_type_name = _tmp713_; - _tmp714_ = base_symbol; - base_type = _tmp714_; - } - } - _tmp715_ = g_strdup (""); - base_type_package = _tmp715_; - _tmp717_ = base_type; - if (_tmp717_ != NULL) { - ValaSymbol* _tmp718_; - gboolean _tmp719_; - gboolean _tmp720_; - _tmp718_ = base_type; - _tmp719_ = vala_symbol_get_external_package (_tmp718_); - _tmp720_ = _tmp719_; - _tmp716_ = _tmp720_; - } else { - _tmp716_ = FALSE; + base_type_name = _tmp716_; + _tmp717_ = base_symbol; + base_type = _tmp717_; + } } - if (_tmp716_) { + _tmp718_ = g_strdup (""); + base_type_package = _tmp718_; + _tmp720_ = base_type; + if (_tmp720_ != NULL) { ValaSymbol* _tmp721_; - ValaSourceReference* _tmp722_; - ValaSourceReference* _tmp723_; - ValaSourceFile* _tmp724_; - ValaSourceFile* _tmp725_; - const gchar* _tmp726_; - const gchar* _tmp727_; - gchar* _tmp728_; - const gchar* _tmp729_; - _tmp721_ = base_symbol; - _tmp722_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp721_); + gboolean _tmp722_; + gboolean _tmp723_; + _tmp721_ = base_type; + _tmp722_ = vala_symbol_get_external_package (_tmp721_); _tmp723_ = _tmp722_; - _tmp724_ = vala_source_reference_get_file (_tmp723_); - _tmp725_ = _tmp724_; - _tmp726_ = vala_source_file_get_package_name (_tmp725_); - _tmp727_ = _tmp726_; - _tmp728_ = g_strdup (_tmp727_); + _tmp719_ = _tmp723_; + } else { + _tmp719_ = FALSE; + } + if (_tmp719_) { + ValaSymbol* _tmp724_; + ValaSourceReference* _tmp725_; + ValaSourceReference* _tmp726_; + ValaSourceFile* _tmp727_; + ValaSourceFile* _tmp728_; + const gchar* _tmp729_; + const gchar* _tmp730_; + gchar* _tmp731_; + const gchar* _tmp732_; + _tmp724_ = base_symbol; + _tmp725_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp724_); + _tmp726_ = _tmp725_; + _tmp727_ = vala_source_reference_get_file (_tmp726_); + _tmp728_ = _tmp727_; + _tmp729_ = vala_source_file_get_package_name (_tmp728_); + _tmp730_ = _tmp729_; + _tmp731_ = g_strdup (_tmp730_); _g_free0 (base_type_package); - base_type_package = _tmp728_; - _tmp729_ = base_type_package; - if (_tmp729_ != NULL) { - const gchar* _tmp730_; - gchar* _tmp731_; - _tmp730_ = base_type_package; - _tmp731_ = g_strdup_printf (" (%s)", _tmp730_); + base_type_package = _tmp731_; + _tmp732_ = base_type_package; + if (_tmp732_ != NULL) { + const gchar* _tmp733_; + gchar* _tmp734_; + _tmp733_ = base_type_package; + _tmp734_ = g_strdup_printf (" (%s)", _tmp733_); _g_free0 (base_type_package); - base_type_package = _tmp731_; + base_type_package = _tmp734_; } } - _tmp732_ = g_strdup (""); - visited_types_string = _tmp732_; + _tmp735_ = g_strdup (""); + visited_types_string = _tmp735_; { ValaArrayList* _type_list = NULL; - ValaArrayList* _tmp733_; + ValaArrayList* _tmp736_; gint _type_size = 0; - ValaArrayList* _tmp734_; - gint _tmp735_; - gint _tmp736_; + ValaArrayList* _tmp737_; + gint _tmp738_; + gint _tmp739_; gint _type_index = 0; - _tmp733_ = visited_types; - _type_list = _tmp733_; - _tmp734_ = _type_list; - _tmp735_ = vala_collection_get_size ((ValaCollection*) _tmp734_); - _tmp736_ = _tmp735_; - _type_size = _tmp736_; + _tmp736_ = visited_types; + _type_list = _tmp736_; + _tmp737_ = _type_list; + _tmp738_ = vala_collection_get_size ((ValaCollection*) _tmp737_); + _tmp739_ = _tmp738_; + _type_size = _tmp739_; _type_index = -1; while (TRUE) { - gint _tmp737_; - gint _tmp738_; + gint _tmp740_; + gint _tmp741_; ValaDataType* type = NULL; - ValaArrayList* _tmp739_; - gpointer _tmp740_; - const gchar* _tmp741_; - ValaDataType* _tmp742_; - gchar* _tmp743_; - gchar* _tmp744_; - gchar* _tmp745_; + ValaArrayList* _tmp742_; + gpointer _tmp743_; + const gchar* _tmp744_; + ValaDataType* _tmp745_; gchar* _tmp746_; gchar* _tmp747_; + gchar* _tmp748_; + gchar* _tmp749_; + gchar* _tmp750_; _type_index = _type_index + 1; - _tmp737_ = _type_index; - _tmp738_ = _type_size; - if (!(_tmp737_ < _tmp738_)) { + _tmp740_ = _type_index; + _tmp741_ = _type_size; + if (!(_tmp740_ < _tmp741_)) { break; } - _tmp739_ = _type_list; - _tmp740_ = vala_list_get ((ValaList*) _tmp739_, _type_index); - type = (ValaDataType*) _tmp740_; - _tmp741_ = visited_types_string; - _tmp742_ = type; - _tmp743_ = vala_code_node_to_string ((ValaCodeNode*) _tmp742_); - _tmp744_ = _tmp743_; - _tmp745_ = g_strdup_printf (" or `%s'", _tmp744_); - _tmp746_ = _tmp745_; - _tmp747_ = g_strconcat (_tmp741_, _tmp746_, NULL); + _tmp742_ = _type_list; + _tmp743_ = vala_list_get ((ValaList*) _tmp742_, _type_index); + type = (ValaDataType*) _tmp743_; + _tmp744_ = visited_types_string; + _tmp745_ = type; + _tmp746_ = vala_code_node_to_string ((ValaCodeNode*) _tmp745_); + _tmp747_ = _tmp746_; + _tmp748_ = g_strdup_printf (" or `%s'", _tmp747_); + _tmp749_ = _tmp748_; + _tmp750_ = g_strconcat (_tmp744_, _tmp749_, NULL); _g_free0 (visited_types_string); - visited_types_string = _tmp747_; - _g_free0 (_tmp746_); - _g_free0 (_tmp744_); + visited_types_string = _tmp750_; + _g_free0 (_tmp749_); + _g_free0 (_tmp747_); _vala_code_node_unref0 (type); } } - _tmp748_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp749_ = _tmp748_; - _tmp750_ = self->priv->_member_name; - _tmp751_ = base_type_name; - _tmp752_ = base_type_package; - _tmp753_ = visited_types_string; - vala_report_error (_tmp749_, "The name `%s' does not exist in the context of `%s'%s%s", _tmp750_, _tmp751_, _tmp752_, _tmp753_); - _tmp754_ = vala_invalid_type_new (); - _tmp755_ = _tmp754_; - vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp755_); - _vala_code_node_unref0 (_tmp755_); + _tmp751_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp752_ = _tmp751_; + _tmp753_ = self->priv->_member_name; + _tmp754_ = base_type_name; + _tmp755_ = base_type_package; + _tmp756_ = visited_types_string; + vala_report_error (_tmp752_, "The name `%s' does not exist in the context of `%s'%s%s", _tmp753_, _tmp754_, _tmp755_, _tmp756_); + _tmp757_ = vala_invalid_type_new (); + _tmp758_ = _tmp757_; + vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp758_); + _vala_code_node_unref0 (_tmp758_); result = FALSE; _g_free0 (visited_types_string); _g_free0 (base_type_package); @@ -2945,966 +2951,966 @@ _vala_iterable_unref0 (visited_types); return result; } else { - ValaSymbol* _tmp756_; - ValaSymbol* _tmp757_; - gboolean _tmp758_; - gboolean _tmp759_; - _tmp756_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp757_ = _tmp756_; - _tmp758_ = vala_code_node_get_error ((ValaCodeNode*) _tmp757_); - _tmp759_ = _tmp758_; - if (_tmp759_) { + ValaSymbol* _tmp759_; + ValaSymbol* _tmp760_; + gboolean _tmp761_; + gboolean _tmp762_; + _tmp759_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp760_ = _tmp759_; + _tmp761_ = vala_code_node_get_error ((ValaCodeNode*) _tmp760_); + _tmp762_ = _tmp761_; + if (_tmp762_) { vala_code_node_set_error ((ValaCodeNode*) self, TRUE); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } } - _tmp760_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp761_ = _tmp760_; - if (VALA_IS_SIGNAL (_tmp761_)) { + _tmp763_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp764_ = _tmp763_; + if (VALA_IS_SIGNAL (_tmp764_)) { ValaSignal* sig = NULL; - ValaSymbol* _tmp762_; - ValaSymbol* _tmp763_; + ValaSymbol* _tmp765_; + ValaSymbol* _tmp766_; ValaCodeNode* ma = NULL; ValaCodeNode* parent = NULL; - ValaCodeNode* _tmp770_; - ValaCodeNode* _tmp771_; - ValaCodeNode* _tmp772_; - gboolean _tmp773_ = FALSE; - gboolean _tmp774_ = FALSE; - gboolean _tmp775_ = FALSE; - ValaCodeNode* _tmp776_; - _tmp762_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp763_ = _tmp762_; - sig = G_TYPE_CHECK_INSTANCE_CAST (_tmp763_, VALA_TYPE_SIGNAL, ValaSignal); + ValaCodeNode* _tmp773_; + ValaCodeNode* _tmp774_; + ValaCodeNode* _tmp775_; + gboolean _tmp776_ = FALSE; + gboolean _tmp777_ = FALSE; + gboolean _tmp778_ = FALSE; + ValaCodeNode* _tmp779_; + _tmp765_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp766_ = _tmp765_; + sig = G_TYPE_CHECK_INSTANCE_CAST (_tmp766_, VALA_TYPE_SIGNAL, ValaSignal); ma = (ValaCodeNode*) self; while (TRUE) { - ValaCodeNode* _tmp764_; - ValaCodeNode* _tmp765_; - ValaCodeNode* _tmp766_; ValaCodeNode* _tmp767_; ValaCodeNode* _tmp768_; ValaCodeNode* _tmp769_; - _tmp764_ = ma; - _tmp765_ = vala_code_node_get_parent_node (_tmp764_); - _tmp766_ = _tmp765_; - if (!VALA_IS_MEMBER_ACCESS (_tmp766_)) { - break; - } + ValaCodeNode* _tmp770_; + ValaCodeNode* _tmp771_; + ValaCodeNode* _tmp772_; _tmp767_ = ma; _tmp768_ = vala_code_node_get_parent_node (_tmp767_); _tmp769_ = _tmp768_; - ma = _tmp769_; - } - _tmp770_ = ma; - _tmp771_ = vala_code_node_get_parent_node (_tmp770_); - _tmp772_ = _tmp771_; - parent = _tmp772_; - _tmp776_ = parent; - if (_tmp776_ != NULL) { - ValaCodeNode* _tmp777_; - _tmp777_ = parent; - _tmp775_ = !VALA_IS_ELEMENT_ACCESS (_tmp777_); + if (!VALA_IS_MEMBER_ACCESS (_tmp769_)) { + break; + } + _tmp770_ = ma; + _tmp771_ = vala_code_node_get_parent_node (_tmp770_); + _tmp772_ = _tmp771_; + ma = _tmp772_; + } + _tmp773_ = ma; + _tmp774_ = vala_code_node_get_parent_node (_tmp773_); + _tmp775_ = _tmp774_; + parent = _tmp775_; + _tmp779_ = parent; + if (_tmp779_ != NULL) { + ValaCodeNode* _tmp780_; + _tmp780_ = parent; + _tmp778_ = !VALA_IS_ELEMENT_ACCESS (_tmp780_); } else { - _tmp775_ = FALSE; + _tmp778_ = FALSE; } - if (_tmp775_) { - ValaCodeNode* _tmp778_; - ValaExpression* _tmp779_; - ValaExpression* _tmp780_; - _tmp778_ = ma; - _tmp779_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp778_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); - _tmp780_ = _tmp779_; - _tmp774_ = !VALA_IS_BASE_ACCESS (_tmp780_); + if (_tmp778_) { + ValaCodeNode* _tmp781_; + ValaExpression* _tmp782_; + ValaExpression* _tmp783_; + _tmp781_ = ma; + _tmp782_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp781_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); + _tmp783_ = _tmp782_; + _tmp777_ = !VALA_IS_BASE_ACCESS (_tmp783_); } else { - _tmp774_ = FALSE; + _tmp777_ = FALSE; } - if (_tmp774_) { - gboolean _tmp781_ = FALSE; - ValaCodeNode* _tmp782_; - _tmp782_ = parent; - if (!VALA_IS_METHOD_CALL (_tmp782_)) { - _tmp781_ = TRUE; + if (_tmp777_) { + gboolean _tmp784_ = FALSE; + ValaCodeNode* _tmp785_; + _tmp785_ = parent; + if (!VALA_IS_METHOD_CALL (_tmp785_)) { + _tmp784_ = TRUE; } else { - ValaCodeNode* _tmp783_; - ValaList* _tmp784_; - _tmp783_ = parent; - _tmp784_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) G_TYPE_CHECK_INSTANCE_CAST (_tmp783_, VALA_TYPE_METHOD_CALL, ValaMethodCall)); - _tmp781_ = vala_collection_contains ((ValaCollection*) _tmp784_, (ValaExpression*) self); + ValaCodeNode* _tmp786_; + ValaList* _tmp787_; + _tmp786_ = parent; + _tmp787_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) G_TYPE_CHECK_INSTANCE_CAST (_tmp786_, VALA_TYPE_METHOD_CALL, ValaMethodCall)); + _tmp784_ = vala_collection_contains ((ValaCollection*) _tmp787_, (ValaExpression*) self); } - _tmp773_ = _tmp781_; + _tmp776_ = _tmp784_; } else { - _tmp773_ = FALSE; + _tmp776_ = FALSE; } - if (_tmp773_) { - ValaSignal* _tmp785_; - ValaAttribute* _tmp786_; - _tmp785_ = sig; - _tmp786_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp785_, "HasEmitter"); - if (_tmp786_ != NULL) { - ValaSignal* _tmp787_; - ValaSignal* _tmp788_; - ValaMethod* _tmp789_; - ValaMethod* _tmp790_; - _tmp787_ = sig; - if (!vala_code_node_check ((ValaCodeNode*) _tmp787_, context)) { + if (_tmp776_) { + ValaSignal* _tmp788_; + ValaAttribute* _tmp789_; + _tmp788_ = sig; + _tmp789_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp788_, "HasEmitter"); + if (_tmp789_ != NULL) { + ValaSignal* _tmp790_; + ValaSignal* _tmp791_; + ValaMethod* _tmp792_; + ValaMethod* _tmp793_; + _tmp790_ = sig; + if (!vala_code_node_check ((ValaCodeNode*) _tmp790_, context)) { result = FALSE; _vala_iterable_unref0 (visited_types); return result; } - _tmp788_ = sig; - _tmp789_ = vala_signal_get_emitter (_tmp788_); - _tmp790_ = _tmp789_; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp790_); + _tmp791_ = sig; + _tmp792_ = vala_signal_get_emitter (_tmp791_); + _tmp793_ = _tmp792_; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp793_); } else { - ValaSourceReference* _tmp791_; - ValaSourceReference* _tmp792_; - ValaSymbol* _tmp793_; - ValaSymbol* _tmp794_; - gchar* _tmp795_; - gchar* _tmp796_; + ValaSourceReference* _tmp794_; + ValaSourceReference* _tmp795_; + ValaSymbol* _tmp796_; + ValaSymbol* _tmp797_; + gchar* _tmp798_; + gchar* _tmp799_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp791_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp792_ = _tmp791_; - _tmp793_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp794_ = _tmp793_; - _tmp795_ = vala_symbol_get_full_name (_tmp794_); - _tmp796_ = _tmp795_; - vala_report_error (_tmp792_, "Signal `%s' requires emitter in this context", _tmp796_); - _g_free0 (_tmp796_); + _tmp794_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp795_ = _tmp794_; + _tmp796_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp797_ = _tmp796_; + _tmp798_ = vala_symbol_get_full_name (_tmp797_); + _tmp799_ = _tmp798_; + vala_report_error (_tmp795_, "Signal `%s' requires emitter in this context", _tmp799_); + _g_free0 (_tmp799_); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } } } - _tmp797_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp798_ = _tmp797_; - member = _tmp798_; + _tmp800_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp801_ = _tmp800_; + member = _tmp801_; access = VALA_SYMBOL_ACCESSIBILITY_PUBLIC; instance = FALSE; klass = FALSE; generics = FALSE; - _tmp799_ = member; - if (!vala_code_node_check ((ValaCodeNode*) _tmp799_, context)) { + _tmp802_ = member; + if (!vala_code_node_check ((ValaCodeNode*) _tmp802_, context)) { result = FALSE; _vala_iterable_unref0 (visited_types); return result; } - _tmp800_ = member; - if (VALA_IS_LOCAL_VARIABLE (_tmp800_)) { + _tmp803_ = member; + if (VALA_IS_LOCAL_VARIABLE (_tmp803_)) { ValaLocalVariable* local = NULL; - ValaSymbol* _tmp801_; - ValaBlock* block = NULL; - ValaLocalVariable* _tmp802_; - ValaSymbol* _tmp803_; ValaSymbol* _tmp804_; - gboolean _tmp805_ = FALSE; - ValaBlock* _tmp806_; - _tmp801_ = member; - local = G_TYPE_CHECK_INSTANCE_CAST (_tmp801_, VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable); - _tmp802_ = local; - _tmp803_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp802_); - _tmp804_ = _tmp803_; - block = VALA_IS_BLOCK (_tmp804_) ? ((ValaBlock*) _tmp804_) : NULL; - _tmp806_ = block; - if (_tmp806_ != NULL) { - ValaBlock* _tmp807_; - ValaSymbol* _tmp808_; - ValaSemanticAnalyzer* _tmp809_; - ValaSemanticAnalyzer* _tmp810_; + ValaBlock* block = NULL; + ValaLocalVariable* _tmp805_; + ValaSymbol* _tmp806_; + ValaSymbol* _tmp807_; + gboolean _tmp808_ = FALSE; + ValaBlock* _tmp809_; + _tmp804_ = member; + local = G_TYPE_CHECK_INSTANCE_CAST (_tmp804_, VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable); + _tmp805_ = local; + _tmp806_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp805_); + _tmp807_ = _tmp806_; + block = VALA_IS_BLOCK (_tmp807_) ? ((ValaBlock*) _tmp807_) : NULL; + _tmp809_ = block; + if (_tmp809_ != NULL) { + ValaBlock* _tmp810_; ValaSymbol* _tmp811_; - ValaSymbol* _tmp812_; - _tmp807_ = block; - _tmp808_ = vala_semantic_analyzer_find_parent_method_or_property_accessor ((ValaSymbol*) _tmp807_); - _tmp809_ = vala_code_context_get_analyzer (context); - _tmp810_ = _tmp809_; - _tmp811_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp810_); - _tmp812_ = _tmp811_; - _tmp805_ = _tmp808_ != _tmp812_; + ValaSemanticAnalyzer* _tmp812_; + ValaSemanticAnalyzer* _tmp813_; + ValaSymbol* _tmp814_; + ValaSymbol* _tmp815_; + _tmp810_ = block; + _tmp811_ = vala_semantic_analyzer_find_parent_method_or_property_accessor ((ValaSymbol*) _tmp810_); + _tmp812_ = vala_code_context_get_analyzer (context); + _tmp813_ = _tmp812_; + _tmp814_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp813_); + _tmp815_ = _tmp814_; + _tmp808_ = _tmp811_ != _tmp815_; } else { - _tmp805_ = FALSE; + _tmp808_ = FALSE; } - if (_tmp805_) { + if (_tmp808_) { ValaSymbol* sym = NULL; - ValaSemanticAnalyzer* _tmp813_; - ValaSemanticAnalyzer* _tmp814_; - ValaSymbol* _tmp815_; - ValaSymbol* _tmp816_; - ValaLocalVariable* _tmp827_; - ValaBlock* _tmp828_; - ValaLocalVariable* _tmp829_; - ValaDataType* _tmp830_; - ValaDataType* _tmp831_; - ValaTypeSymbol* _tmp832_; - ValaTypeSymbol* _tmp833_; - ValaSemanticAnalyzer* _tmp834_; - ValaSemanticAnalyzer* _tmp835_; - ValaDataType* _tmp836_; - ValaTypeSymbol* _tmp837_; - ValaTypeSymbol* _tmp838_; - _tmp813_ = vala_code_context_get_analyzer (context); - _tmp814_ = _tmp813_; - _tmp815_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp814_); - _tmp816_ = _tmp815_; - sym = _tmp816_; + ValaSemanticAnalyzer* _tmp816_; + ValaSemanticAnalyzer* _tmp817_; + ValaSymbol* _tmp818_; + ValaSymbol* _tmp819_; + ValaLocalVariable* _tmp830_; + ValaBlock* _tmp831_; + ValaLocalVariable* _tmp832_; + ValaDataType* _tmp833_; + ValaDataType* _tmp834_; + ValaTypeSymbol* _tmp835_; + ValaTypeSymbol* _tmp836_; + ValaSemanticAnalyzer* _tmp837_; + ValaSemanticAnalyzer* _tmp838_; + ValaDataType* _tmp839_; + ValaTypeSymbol* _tmp840_; + ValaTypeSymbol* _tmp841_; + _tmp816_ = vala_code_context_get_analyzer (context); + _tmp817_ = _tmp816_; + _tmp818_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp817_); + _tmp819_ = _tmp818_; + sym = _tmp819_; while (TRUE) { - ValaSymbol* _tmp817_; - ValaBlock* _tmp818_; + ValaSymbol* _tmp820_; + ValaBlock* _tmp821_; ValaMethod* method = NULL; - ValaSymbol* _tmp819_; - ValaMethod* _tmp820_; - ValaSymbol* _tmp824_; - ValaSymbol* _tmp825_; - ValaSymbol* _tmp826_; - _tmp817_ = sym; - _tmp818_ = block; - if (!(_tmp817_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp818_, VALA_TYPE_SYMBOL, ValaSymbol))) { + ValaSymbol* _tmp822_; + ValaMethod* _tmp823_; + ValaSymbol* _tmp827_; + ValaSymbol* _tmp828_; + ValaSymbol* _tmp829_; + _tmp820_ = sym; + _tmp821_ = block; + if (!(_tmp820_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp821_, VALA_TYPE_SYMBOL, ValaSymbol))) { break; } - _tmp819_ = sym; - method = VALA_IS_METHOD (_tmp819_) ? ((ValaMethod*) _tmp819_) : NULL; - _tmp820_ = method; - if (_tmp820_ != NULL) { - ValaMethod* _tmp821_; - ValaMethod* _tmp822_; - ValaLocalVariable* _tmp823_; - _tmp821_ = method; - vala_method_set_closure (_tmp821_, TRUE); - _tmp822_ = method; - _tmp823_ = local; - vala_method_add_captured_variable (_tmp822_, _tmp823_); - } - _tmp824_ = sym; - _tmp825_ = vala_symbol_get_parent_symbol (_tmp824_); - _tmp826_ = _tmp825_; - sym = _tmp826_; - } - _tmp827_ = local; - vala_local_variable_set_captured (_tmp827_, TRUE); - _tmp828_ = block; - vala_block_set_captured (_tmp828_, TRUE); - _tmp829_ = local; - _tmp830_ = vala_variable_get_variable_type ((ValaVariable*) _tmp829_); - _tmp831_ = _tmp830_; - _tmp832_ = vala_data_type_get_type_symbol (_tmp831_); - _tmp833_ = _tmp832_; - _tmp834_ = vala_code_context_get_analyzer (context); - _tmp835_ = _tmp834_; - _tmp836_ = _tmp835_->va_list_type; - _tmp837_ = vala_data_type_get_type_symbol (_tmp836_); + _tmp822_ = sym; + method = VALA_IS_METHOD (_tmp822_) ? ((ValaMethod*) _tmp822_) : NULL; + _tmp823_ = method; + if (_tmp823_ != NULL) { + ValaMethod* _tmp824_; + ValaMethod* _tmp825_; + ValaLocalVariable* _tmp826_; + _tmp824_ = method; + vala_method_set_closure (_tmp824_, TRUE); + _tmp825_ = method; + _tmp826_ = local; + vala_method_add_captured_variable (_tmp825_, _tmp826_); + } + _tmp827_ = sym; + _tmp828_ = vala_symbol_get_parent_symbol (_tmp827_); + _tmp829_ = _tmp828_; + sym = _tmp829_; + } + _tmp830_ = local; + vala_local_variable_set_captured (_tmp830_, TRUE); + _tmp831_ = block; + vala_block_set_captured (_tmp831_, TRUE); + _tmp832_ = local; + _tmp833_ = vala_variable_get_variable_type ((ValaVariable*) _tmp832_); + _tmp834_ = _tmp833_; + _tmp835_ = vala_data_type_get_type_symbol (_tmp834_); + _tmp836_ = _tmp835_; + _tmp837_ = vala_code_context_get_analyzer (context); _tmp838_ = _tmp837_; - if (_tmp833_ == _tmp838_) { - ValaSourceReference* _tmp839_; - ValaSourceReference* _tmp840_; - ValaLocalVariable* _tmp841_; - gchar* _tmp842_; - gchar* _tmp843_; + _tmp839_ = _tmp838_->va_list_type; + _tmp840_ = vala_data_type_get_type_symbol (_tmp839_); + _tmp841_ = _tmp840_; + if (_tmp836_ == _tmp841_) { + ValaSourceReference* _tmp842_; + ValaSourceReference* _tmp843_; + ValaLocalVariable* _tmp844_; + gchar* _tmp845_; + gchar* _tmp846_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp839_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp840_ = _tmp839_; - _tmp841_ = local; - _tmp842_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp841_); + _tmp842_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp843_ = _tmp842_; - vala_report_error (_tmp840_, "Capturing `va_list' variable `%s' is not allowed", _tmp843_); - _g_free0 (_tmp843_); + _tmp844_ = local; + _tmp845_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp844_); + _tmp846_ = _tmp845_; + vala_report_error (_tmp843_, "Capturing `va_list' variable `%s' is not allowed", _tmp846_); + _g_free0 (_tmp846_); } } } else { - ValaSymbol* _tmp844_; - _tmp844_ = member; - if (VALA_IS_PARAMETER (_tmp844_)) { + ValaSymbol* _tmp847_; + _tmp847_ = member; + if (VALA_IS_PARAMETER (_tmp847_)) { ValaParameter* param = NULL; - ValaSymbol* _tmp845_; - ValaMethod* m = NULL; - ValaParameter* _tmp846_; - ValaSymbol* _tmp847_; ValaSymbol* _tmp848_; - gboolean _tmp849_ = FALSE; - gboolean _tmp850_ = FALSE; - ValaMethod* _tmp851_; - _tmp845_ = member; - param = G_TYPE_CHECK_INSTANCE_CAST (_tmp845_, VALA_TYPE_PARAMETER, ValaParameter); - _tmp846_ = param; - _tmp847_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp846_); - _tmp848_ = _tmp847_; - m = VALA_IS_METHOD (_tmp848_) ? ((ValaMethod*) _tmp848_) : NULL; - _tmp851_ = m; - if (_tmp851_ != NULL) { - ValaMethod* _tmp852_; - ValaSemanticAnalyzer* _tmp853_; - ValaSemanticAnalyzer* _tmp854_; - ValaSymbol* _tmp855_; - ValaSymbol* _tmp856_; - _tmp852_ = m; - _tmp853_ = vala_code_context_get_analyzer (context); - _tmp854_ = _tmp853_; - _tmp855_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp854_); - _tmp856_ = _tmp855_; - _tmp850_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp852_, VALA_TYPE_SYMBOL, ValaSymbol) != _tmp856_; + ValaMethod* m = NULL; + ValaParameter* _tmp849_; + ValaSymbol* _tmp850_; + ValaSymbol* _tmp851_; + gboolean _tmp852_ = FALSE; + gboolean _tmp853_ = FALSE; + ValaMethod* _tmp854_; + _tmp848_ = member; + param = G_TYPE_CHECK_INSTANCE_CAST (_tmp848_, VALA_TYPE_PARAMETER, ValaParameter); + _tmp849_ = param; + _tmp850_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp849_); + _tmp851_ = _tmp850_; + m = VALA_IS_METHOD (_tmp851_) ? ((ValaMethod*) _tmp851_) : NULL; + _tmp854_ = m; + if (_tmp854_ != NULL) { + ValaMethod* _tmp855_; + ValaSemanticAnalyzer* _tmp856_; + ValaSemanticAnalyzer* _tmp857_; + ValaSymbol* _tmp858_; + ValaSymbol* _tmp859_; + _tmp855_ = m; + _tmp856_ = vala_code_context_get_analyzer (context); + _tmp857_ = _tmp856_; + _tmp858_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp857_); + _tmp859_ = _tmp858_; + _tmp853_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp855_, VALA_TYPE_SYMBOL, ValaSymbol) != _tmp859_; } else { - _tmp850_ = FALSE; + _tmp853_ = FALSE; } - if (_tmp850_) { - ValaParameter* _tmp857_; - ValaMethod* _tmp858_; - ValaParameter* _tmp859_; + if (_tmp853_) { ValaParameter* _tmp860_; - _tmp857_ = param; - _tmp858_ = m; - _tmp859_ = vala_method_get_this_parameter (_tmp858_); - _tmp860_ = _tmp859_; - _tmp849_ = _tmp857_ != _tmp860_; + ValaMethod* _tmp861_; + ValaParameter* _tmp862_; + ValaParameter* _tmp863_; + _tmp860_ = param; + _tmp861_ = m; + _tmp862_ = vala_method_get_this_parameter (_tmp861_); + _tmp863_ = _tmp862_; + _tmp852_ = _tmp860_ != _tmp863_; } else { - _tmp849_ = FALSE; + _tmp852_ = FALSE; } - if (_tmp849_) { + if (_tmp852_) { ValaSymbol* sym = NULL; - ValaSemanticAnalyzer* _tmp861_; - ValaSemanticAnalyzer* _tmp862_; - ValaSymbol* _tmp863_; - ValaSymbol* _tmp864_; - ValaParameter* _tmp873_; - ValaMethod* _tmp874_; - ValaBlock* _tmp875_; - ValaBlock* _tmp876_; - ValaParameter* _tmp877_; - ValaParameterDirection _tmp878_; - ValaParameterDirection _tmp879_; - ValaParameter* _tmp885_; - ValaDataType* _tmp886_; - ValaDataType* _tmp887_; - ValaTypeSymbol* _tmp888_; - ValaTypeSymbol* _tmp889_; - ValaSemanticAnalyzer* _tmp890_; - ValaSemanticAnalyzer* _tmp891_; - ValaDataType* _tmp892_; - ValaTypeSymbol* _tmp893_; - ValaTypeSymbol* _tmp894_; - _tmp861_ = vala_code_context_get_analyzer (context); - _tmp862_ = _tmp861_; - _tmp863_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp862_); - _tmp864_ = _tmp863_; - sym = _tmp864_; + ValaSemanticAnalyzer* _tmp864_; + ValaSemanticAnalyzer* _tmp865_; + ValaSymbol* _tmp866_; + ValaSymbol* _tmp867_; + ValaParameter* _tmp876_; + ValaMethod* _tmp877_; + ValaBlock* _tmp878_; + ValaBlock* _tmp879_; + ValaParameter* _tmp880_; + ValaParameterDirection _tmp881_; + ValaParameterDirection _tmp882_; + ValaParameter* _tmp888_; + ValaDataType* _tmp889_; + ValaDataType* _tmp890_; + ValaTypeSymbol* _tmp891_; + ValaTypeSymbol* _tmp892_; + ValaSemanticAnalyzer* _tmp893_; + ValaSemanticAnalyzer* _tmp894_; + ValaDataType* _tmp895_; + ValaTypeSymbol* _tmp896_; + ValaTypeSymbol* _tmp897_; + _tmp864_ = vala_code_context_get_analyzer (context); + _tmp865_ = _tmp864_; + _tmp866_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp865_); + _tmp867_ = _tmp866_; + sym = _tmp867_; while (TRUE) { - ValaSymbol* _tmp865_; - ValaMethod* _tmp866_; + ValaSymbol* _tmp868_; + ValaMethod* _tmp869_; ValaMethod* method = NULL; - ValaSymbol* _tmp867_; - ValaMethod* _tmp868_; ValaSymbol* _tmp870_; - ValaSymbol* _tmp871_; - ValaSymbol* _tmp872_; - _tmp865_ = sym; - _tmp866_ = m; - if (!(_tmp865_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp866_, VALA_TYPE_SYMBOL, ValaSymbol))) { + ValaMethod* _tmp871_; + ValaSymbol* _tmp873_; + ValaSymbol* _tmp874_; + ValaSymbol* _tmp875_; + _tmp868_ = sym; + _tmp869_ = m; + if (!(_tmp868_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp869_, VALA_TYPE_SYMBOL, ValaSymbol))) { break; } - _tmp867_ = sym; - method = VALA_IS_METHOD (_tmp867_) ? ((ValaMethod*) _tmp867_) : NULL; - _tmp868_ = method; - if (_tmp868_ != NULL) { - ValaMethod* _tmp869_; - _tmp869_ = method; - vala_method_set_closure (_tmp869_, TRUE); - } _tmp870_ = sym; - _tmp871_ = vala_symbol_get_parent_symbol (_tmp870_); - _tmp872_ = _tmp871_; - sym = _tmp872_; - } - _tmp873_ = param; - vala_parameter_set_captured (_tmp873_, TRUE); - _tmp874_ = m; - _tmp875_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp874_); - _tmp876_ = _tmp875_; - vala_block_set_captured (_tmp876_, TRUE); - _tmp877_ = param; - _tmp878_ = vala_parameter_get_direction (_tmp877_); + method = VALA_IS_METHOD (_tmp870_) ? ((ValaMethod*) _tmp870_) : NULL; + _tmp871_ = method; + if (_tmp871_ != NULL) { + ValaMethod* _tmp872_; + _tmp872_ = method; + vala_method_set_closure (_tmp872_, TRUE); + } + _tmp873_ = sym; + _tmp874_ = vala_symbol_get_parent_symbol (_tmp873_); + _tmp875_ = _tmp874_; + sym = _tmp875_; + } + _tmp876_ = param; + vala_parameter_set_captured (_tmp876_, TRUE); + _tmp877_ = m; + _tmp878_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp877_); _tmp879_ = _tmp878_; - if (_tmp879_ != VALA_PARAMETER_DIRECTION_IN) { - ValaSourceReference* _tmp880_; - ValaSourceReference* _tmp881_; - ValaParameter* _tmp882_; - gchar* _tmp883_; - gchar* _tmp884_; + vala_block_set_captured (_tmp879_, TRUE); + _tmp880_ = param; + _tmp881_ = vala_parameter_get_direction (_tmp880_); + _tmp882_ = _tmp881_; + if (_tmp882_ != VALA_PARAMETER_DIRECTION_IN) { + ValaSourceReference* _tmp883_; + ValaSourceReference* _tmp884_; + ValaParameter* _tmp885_; + gchar* _tmp886_; + gchar* _tmp887_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp880_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp881_ = _tmp880_; - _tmp882_ = param; - _tmp883_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp882_); + _tmp883_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp884_ = _tmp883_; - vala_report_error (_tmp881_, "Cannot capture reference or output parameter `%s'", _tmp884_); - _g_free0 (_tmp884_); - } - _tmp885_ = param; - _tmp886_ = vala_variable_get_variable_type ((ValaVariable*) _tmp885_); - _tmp887_ = _tmp886_; - _tmp888_ = vala_data_type_get_type_symbol (_tmp887_); - _tmp889_ = _tmp888_; - _tmp890_ = vala_code_context_get_analyzer (context); - _tmp891_ = _tmp890_; - _tmp892_ = _tmp891_->va_list_type; - _tmp893_ = vala_data_type_get_type_symbol (_tmp892_); + _tmp885_ = param; + _tmp886_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp885_); + _tmp887_ = _tmp886_; + vala_report_error (_tmp884_, "Cannot capture reference or output parameter `%s'", _tmp887_); + _g_free0 (_tmp887_); + } + _tmp888_ = param; + _tmp889_ = vala_variable_get_variable_type ((ValaVariable*) _tmp888_); + _tmp890_ = _tmp889_; + _tmp891_ = vala_data_type_get_type_symbol (_tmp890_); + _tmp892_ = _tmp891_; + _tmp893_ = vala_code_context_get_analyzer (context); _tmp894_ = _tmp893_; - if (_tmp889_ == _tmp894_) { - ValaSourceReference* _tmp895_; - ValaSourceReference* _tmp896_; - ValaParameter* _tmp897_; - gchar* _tmp898_; - gchar* _tmp899_; + _tmp895_ = _tmp894_->va_list_type; + _tmp896_ = vala_data_type_get_type_symbol (_tmp895_); + _tmp897_ = _tmp896_; + if (_tmp892_ == _tmp897_) { + ValaSourceReference* _tmp898_; + ValaSourceReference* _tmp899_; + ValaParameter* _tmp900_; + gchar* _tmp901_; + gchar* _tmp902_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp895_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp896_ = _tmp895_; - _tmp897_ = param; - _tmp898_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp897_); + _tmp898_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp899_ = _tmp898_; - vala_report_error (_tmp896_, "Capturing `va_list' parameter `%s' is not allowed", _tmp899_); - _g_free0 (_tmp899_); + _tmp900_ = param; + _tmp901_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp900_); + _tmp902_ = _tmp901_; + vala_report_error (_tmp899_, "Capturing `va_list' parameter `%s' is not allowed", _tmp902_); + _g_free0 (_tmp902_); } } else { ValaPropertyAccessor* acc = NULL; - ValaParameter* _tmp900_; - ValaSymbol* _tmp901_; - ValaSymbol* _tmp902_; - ValaSymbol* _tmp903_; + ValaParameter* _tmp903_; ValaSymbol* _tmp904_; - gboolean _tmp905_ = FALSE; - gboolean _tmp906_ = FALSE; - ValaPropertyAccessor* _tmp907_; - _tmp900_ = param; - _tmp901_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp900_); - _tmp902_ = _tmp901_; - _tmp903_ = vala_symbol_get_parent_symbol (_tmp902_); - _tmp904_ = _tmp903_; - acc = VALA_IS_PROPERTY_ACCESSOR (_tmp904_) ? ((ValaPropertyAccessor*) _tmp904_) : NULL; - _tmp907_ = acc; - if (_tmp907_ != NULL) { - ValaPropertyAccessor* _tmp908_; - ValaSemanticAnalyzer* _tmp909_; - ValaSemanticAnalyzer* _tmp910_; - ValaSymbol* _tmp911_; - ValaSymbol* _tmp912_; - _tmp908_ = acc; - _tmp909_ = vala_code_context_get_analyzer (context); - _tmp910_ = _tmp909_; - _tmp911_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp910_); - _tmp912_ = _tmp911_; - _tmp906_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp908_, VALA_TYPE_SYMBOL, ValaSymbol) != _tmp912_; + ValaSymbol* _tmp905_; + ValaSymbol* _tmp906_; + ValaSymbol* _tmp907_; + gboolean _tmp908_ = FALSE; + gboolean _tmp909_ = FALSE; + ValaPropertyAccessor* _tmp910_; + _tmp903_ = param; + _tmp904_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp903_); + _tmp905_ = _tmp904_; + _tmp906_ = vala_symbol_get_parent_symbol (_tmp905_); + _tmp907_ = _tmp906_; + acc = VALA_IS_PROPERTY_ACCESSOR (_tmp907_) ? ((ValaPropertyAccessor*) _tmp907_) : NULL; + _tmp910_ = acc; + if (_tmp910_ != NULL) { + ValaPropertyAccessor* _tmp911_; + ValaSemanticAnalyzer* _tmp912_; + ValaSemanticAnalyzer* _tmp913_; + ValaSymbol* _tmp914_; + ValaSymbol* _tmp915_; + _tmp911_ = acc; + _tmp912_ = vala_code_context_get_analyzer (context); + _tmp913_ = _tmp912_; + _tmp914_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp913_); + _tmp915_ = _tmp914_; + _tmp909_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp911_, VALA_TYPE_SYMBOL, ValaSymbol) != _tmp915_; } else { - _tmp906_ = FALSE; + _tmp909_ = FALSE; } - if (_tmp906_) { - ValaParameter* _tmp913_; - ValaPropertyAccessor* _tmp914_; - ValaProperty* _tmp915_; - ValaProperty* _tmp916_; - ValaParameter* _tmp917_; - ValaParameter* _tmp918_; - _tmp913_ = param; - _tmp914_ = acc; - _tmp915_ = vala_property_accessor_get_prop (_tmp914_); - _tmp916_ = _tmp915_; - _tmp917_ = vala_property_get_this_parameter (_tmp916_); - _tmp918_ = _tmp917_; - _tmp905_ = _tmp913_ != _tmp918_; + if (_tmp909_) { + ValaParameter* _tmp916_; + ValaPropertyAccessor* _tmp917_; + ValaProperty* _tmp918_; + ValaProperty* _tmp919_; + ValaParameter* _tmp920_; + ValaParameter* _tmp921_; + _tmp916_ = param; + _tmp917_ = acc; + _tmp918_ = vala_property_accessor_get_prop (_tmp917_); + _tmp919_ = _tmp918_; + _tmp920_ = vala_property_get_this_parameter (_tmp919_); + _tmp921_ = _tmp920_; + _tmp908_ = _tmp916_ != _tmp921_; } else { - _tmp905_ = FALSE; + _tmp908_ = FALSE; } - if (_tmp905_) { + if (_tmp908_) { ValaSymbol* sym = NULL; - ValaSemanticAnalyzer* _tmp919_; - ValaSemanticAnalyzer* _tmp920_; - ValaSymbol* _tmp921_; - ValaSymbol* _tmp922_; - ValaParameter* _tmp931_; - ValaPropertyAccessor* _tmp932_; - ValaBlock* _tmp933_; - ValaBlock* _tmp934_; - _tmp919_ = vala_code_context_get_analyzer (context); - _tmp920_ = _tmp919_; - _tmp921_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp920_); - _tmp922_ = _tmp921_; - sym = _tmp922_; + ValaSemanticAnalyzer* _tmp922_; + ValaSemanticAnalyzer* _tmp923_; + ValaSymbol* _tmp924_; + ValaSymbol* _tmp925_; + ValaParameter* _tmp934_; + ValaPropertyAccessor* _tmp935_; + ValaBlock* _tmp936_; + ValaBlock* _tmp937_; + _tmp922_ = vala_code_context_get_analyzer (context); + _tmp923_ = _tmp922_; + _tmp924_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp923_); + _tmp925_ = _tmp924_; + sym = _tmp925_; while (TRUE) { - ValaSymbol* _tmp923_; - ValaMethod* _tmp924_; + ValaSymbol* _tmp926_; + ValaMethod* _tmp927_; ValaMethod* method = NULL; - ValaSymbol* _tmp925_; - ValaMethod* _tmp926_; ValaSymbol* _tmp928_; - ValaSymbol* _tmp929_; - ValaSymbol* _tmp930_; - _tmp923_ = sym; - _tmp924_ = m; - if (!(_tmp923_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp924_, VALA_TYPE_SYMBOL, ValaSymbol))) { + ValaMethod* _tmp929_; + ValaSymbol* _tmp931_; + ValaSymbol* _tmp932_; + ValaSymbol* _tmp933_; + _tmp926_ = sym; + _tmp927_ = m; + if (!(_tmp926_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp927_, VALA_TYPE_SYMBOL, ValaSymbol))) { break; } - _tmp925_ = sym; - method = VALA_IS_METHOD (_tmp925_) ? ((ValaMethod*) _tmp925_) : NULL; - _tmp926_ = method; - if (_tmp926_ != NULL) { - ValaMethod* _tmp927_; - _tmp927_ = method; - vala_method_set_closure (_tmp927_, TRUE); - } _tmp928_ = sym; - _tmp929_ = vala_symbol_get_parent_symbol (_tmp928_); - _tmp930_ = _tmp929_; - sym = _tmp930_; + method = VALA_IS_METHOD (_tmp928_) ? ((ValaMethod*) _tmp928_) : NULL; + _tmp929_ = method; + if (_tmp929_ != NULL) { + ValaMethod* _tmp930_; + _tmp930_ = method; + vala_method_set_closure (_tmp930_, TRUE); + } + _tmp931_ = sym; + _tmp932_ = vala_symbol_get_parent_symbol (_tmp931_); + _tmp933_ = _tmp932_; + sym = _tmp933_; } - _tmp931_ = param; - vala_parameter_set_captured (_tmp931_, TRUE); - _tmp932_ = acc; - _tmp933_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp932_); - _tmp934_ = _tmp933_; - vala_block_set_captured (_tmp934_, TRUE); + _tmp934_ = param; + vala_parameter_set_captured (_tmp934_, TRUE); + _tmp935_ = acc; + _tmp936_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp935_); + _tmp937_ = _tmp936_; + vala_block_set_captured (_tmp937_, TRUE); } } } else { - ValaSymbol* _tmp935_; - _tmp935_ = member; - if (VALA_IS_FIELD (_tmp935_)) { + ValaSymbol* _tmp938_; + _tmp938_ = member; + if (VALA_IS_FIELD (_tmp938_)) { ValaField* f = NULL; - ValaSymbol* _tmp936_; - ValaField* _tmp937_; - ValaSymbolAccessibility _tmp938_; - ValaSymbolAccessibility _tmp939_; + ValaSymbol* _tmp939_; ValaField* _tmp940_; - ValaMemberBinding _tmp941_; - ValaMemberBinding _tmp942_; + ValaSymbolAccessibility _tmp941_; + ValaSymbolAccessibility _tmp942_; ValaField* _tmp943_; ValaMemberBinding _tmp944_; ValaMemberBinding _tmp945_; ValaField* _tmp946_; - ValaDataType* _tmp947_; - ValaDataType* _tmp948_; - _tmp936_ = member; - f = G_TYPE_CHECK_INSTANCE_CAST (_tmp936_, VALA_TYPE_FIELD, ValaField); - _tmp937_ = f; - _tmp938_ = vala_symbol_get_access ((ValaSymbol*) _tmp937_); - _tmp939_ = _tmp938_; - access = _tmp939_; + ValaMemberBinding _tmp947_; + ValaMemberBinding _tmp948_; + ValaField* _tmp949_; + ValaDataType* _tmp950_; + ValaDataType* _tmp951_; + _tmp939_ = member; + f = G_TYPE_CHECK_INSTANCE_CAST (_tmp939_, VALA_TYPE_FIELD, ValaField); _tmp940_ = f; - _tmp941_ = vala_field_get_binding (_tmp940_); + _tmp941_ = vala_symbol_get_access ((ValaSymbol*) _tmp940_); _tmp942_ = _tmp941_; - instance = _tmp942_ == VALA_MEMBER_BINDING_INSTANCE; + access = _tmp942_; _tmp943_ = f; _tmp944_ = vala_field_get_binding (_tmp943_); _tmp945_ = _tmp944_; - klass = _tmp945_ == VALA_MEMBER_BINDING_CLASS; + instance = _tmp945_ == VALA_MEMBER_BINDING_INSTANCE; _tmp946_ = f; - _tmp947_ = vala_variable_get_variable_type ((ValaVariable*) _tmp946_); + _tmp947_ = vala_field_get_binding (_tmp946_); _tmp948_ = _tmp947_; - if (VALA_IS_GENERIC_TYPE (_tmp948_)) { + klass = _tmp948_ == VALA_MEMBER_BINDING_CLASS; + _tmp949_ = f; + _tmp950_ = vala_variable_get_variable_type ((ValaVariable*) _tmp949_); + _tmp951_ = _tmp950_; + if (VALA_IS_GENERIC_TYPE (_tmp951_)) { generics = TRUE; } } else { - ValaSymbol* _tmp949_; - _tmp949_ = member; - if (VALA_IS_CONSTANT (_tmp949_)) { + ValaSymbol* _tmp952_; + _tmp952_ = member; + if (VALA_IS_CONSTANT (_tmp952_)) { ValaConstant* c = NULL; - ValaSymbol* _tmp950_; - ValaConstant* _tmp951_; - ValaSymbolAccessibility _tmp952_; - ValaSymbolAccessibility _tmp953_; - ValaBlock* block = NULL; + ValaSymbol* _tmp953_; ValaConstant* _tmp954_; - ValaSymbol* _tmp955_; - ValaSymbol* _tmp956_; - gboolean _tmp957_ = FALSE; - ValaBlock* _tmp958_; - _tmp950_ = member; - c = G_TYPE_CHECK_INSTANCE_CAST (_tmp950_, VALA_TYPE_CONSTANT, ValaConstant); - _tmp951_ = c; - _tmp952_ = vala_symbol_get_access ((ValaSymbol*) _tmp951_); - _tmp953_ = _tmp952_; - access = _tmp953_; + ValaSymbolAccessibility _tmp955_; + ValaSymbolAccessibility _tmp956_; + ValaBlock* block = NULL; + ValaConstant* _tmp957_; + ValaSymbol* _tmp958_; + ValaSymbol* _tmp959_; + gboolean _tmp960_ = FALSE; + ValaBlock* _tmp961_; + _tmp953_ = member; + c = G_TYPE_CHECK_INSTANCE_CAST (_tmp953_, VALA_TYPE_CONSTANT, ValaConstant); _tmp954_ = c; - _tmp955_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp954_); + _tmp955_ = vala_symbol_get_access ((ValaSymbol*) _tmp954_); _tmp956_ = _tmp955_; - block = VALA_IS_BLOCK (_tmp956_) ? ((ValaBlock*) _tmp956_) : NULL; - _tmp958_ = block; - if (_tmp958_ != NULL) { - ValaBlock* _tmp959_; - ValaSymbol* _tmp960_; - ValaSemanticAnalyzer* _tmp961_; - ValaSemanticAnalyzer* _tmp962_; + access = _tmp956_; + _tmp957_ = c; + _tmp958_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp957_); + _tmp959_ = _tmp958_; + block = VALA_IS_BLOCK (_tmp959_) ? ((ValaBlock*) _tmp959_) : NULL; + _tmp961_ = block; + if (_tmp961_ != NULL) { + ValaBlock* _tmp962_; ValaSymbol* _tmp963_; - ValaSymbol* _tmp964_; - _tmp959_ = block; - _tmp960_ = vala_semantic_analyzer_find_parent_method_or_property_accessor ((ValaSymbol*) _tmp959_); - _tmp961_ = vala_code_context_get_analyzer (context); - _tmp962_ = _tmp961_; - _tmp963_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp962_); - _tmp964_ = _tmp963_; - _tmp957_ = _tmp960_ != _tmp964_; + ValaSemanticAnalyzer* _tmp964_; + ValaSemanticAnalyzer* _tmp965_; + ValaSymbol* _tmp966_; + ValaSymbol* _tmp967_; + _tmp962_ = block; + _tmp963_ = vala_semantic_analyzer_find_parent_method_or_property_accessor ((ValaSymbol*) _tmp962_); + _tmp964_ = vala_code_context_get_analyzer (context); + _tmp965_ = _tmp964_; + _tmp966_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp965_); + _tmp967_ = _tmp966_; + _tmp960_ = _tmp963_ != _tmp967_; } else { - _tmp957_ = FALSE; + _tmp960_ = FALSE; } - if (_tmp957_) { - ValaSourceReference* _tmp965_; - ValaSourceReference* _tmp966_; + if (_tmp960_) { + ValaSourceReference* _tmp968_; + ValaSourceReference* _tmp969_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp965_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp966_ = _tmp965_; - vala_report_error (_tmp966_, "internal error: accessing local constants of outer methods is not supp" \ + _tmp968_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp969_ = _tmp968_; + vala_report_error (_tmp969_, "internal error: accessing local constants of outer methods is not supp" \ "orted yet"); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } } else { - ValaSymbol* _tmp967_; - _tmp967_ = member; - if (VALA_IS_METHOD (_tmp967_)) { + ValaSymbol* _tmp970_; + _tmp970_ = member; + if (VALA_IS_METHOD (_tmp970_)) { ValaMethod* m = NULL; - ValaSymbol* _tmp968_; - ValaMethod* _tmp969_; - gboolean _tmp970_; - gboolean _tmp971_; - ValaMethod* _tmp1058_; - ValaSymbolAccessibility _tmp1059_; - ValaSymbolAccessibility _tmp1060_; + ValaSymbol* _tmp971_; + ValaMethod* _tmp972_; + gboolean _tmp973_; + gboolean _tmp974_; ValaMethod* _tmp1061_; - ValaMethod* _tmp1065_; - ValaMemberBinding _tmp1066_; - ValaMemberBinding _tmp1067_; + ValaSymbolAccessibility _tmp1062_; + ValaSymbolAccessibility _tmp1063_; + ValaMethod* _tmp1064_; + ValaMethod* _tmp1068_; + ValaMemberBinding _tmp1069_; + ValaMemberBinding _tmp1070_; ValaGenericType* generic_type = NULL; - ValaMethod* _tmp1087_; - ValaDataType* _tmp1088_; - ValaDataType* _tmp1089_; - gboolean _tmp1090_ = FALSE; - ValaGenericType* _tmp1091_; - _tmp968_ = member; - m = G_TYPE_CHECK_INSTANCE_CAST (_tmp968_, VALA_TYPE_METHOD, ValaMethod); - _tmp969_ = m; - _tmp970_ = vala_method_get_is_async_callback (_tmp969_); - _tmp971_ = _tmp970_; - if (_tmp971_) { + ValaMethod* _tmp1090_; + ValaDataType* _tmp1091_; + ValaDataType* _tmp1092_; + gboolean _tmp1093_ = FALSE; + ValaGenericType* _tmp1094_; + _tmp971_ = member; + m = G_TYPE_CHECK_INSTANCE_CAST (_tmp971_, VALA_TYPE_METHOD, ValaMethod); + _tmp972_ = m; + _tmp973_ = vala_method_get_is_async_callback (_tmp972_); + _tmp974_ = _tmp973_; + if (_tmp974_) { ValaMethod* async_method = NULL; - ValaSemanticAnalyzer* _tmp972_; - ValaSemanticAnalyzer* _tmp973_; - ValaMethod* _tmp974_; - ValaMethod* _tmp975_; + ValaSemanticAnalyzer* _tmp975_; + ValaSemanticAnalyzer* _tmp976_; + ValaMethod* _tmp977_; + ValaMethod* _tmp978_; gboolean is_valid_access = FALSE; - ValaMethod* _tmp976_; - ValaMethod* _tmp1003_; - ValaSemanticAnalyzer* _tmp1004_; - ValaSemanticAnalyzer* _tmp1005_; + ValaMethod* _tmp979_; ValaMethod* _tmp1006_; - ValaMethod* _tmp1007_; - ValaMethod* _tmp1023_; - ValaMethod* _tmp1024_; - ValaMethod* _tmp1025_; - ValaSymbol* _tmp1026_; - ValaSymbol* _tmp1027_; - _tmp972_ = vala_code_context_get_analyzer (context); - _tmp973_ = _tmp972_; - _tmp974_ = vala_semantic_analyzer_get_current_async_method (_tmp973_); - _tmp975_ = _tmp974_; - async_method = _tmp975_; + ValaSemanticAnalyzer* _tmp1007_; + ValaSemanticAnalyzer* _tmp1008_; + ValaMethod* _tmp1009_; + ValaMethod* _tmp1010_; + ValaMethod* _tmp1026_; + ValaMethod* _tmp1027_; + ValaMethod* _tmp1028_; + ValaSymbol* _tmp1029_; + ValaSymbol* _tmp1030_; + _tmp975_ = vala_code_context_get_analyzer (context); + _tmp976_ = _tmp975_; + _tmp977_ = vala_semantic_analyzer_get_current_async_method (_tmp976_); + _tmp978_ = _tmp977_; + async_method = _tmp978_; is_valid_access = FALSE; - _tmp976_ = async_method; - if (_tmp976_ != NULL) { - ValaMethod* _tmp977_; - ValaMethod* _tmp978_; - ValaMethod* _tmp979_; - _tmp977_ = m; - _tmp978_ = async_method; - _tmp979_ = vala_method_get_callback_method (_tmp978_); - if (_tmp977_ == _tmp979_) { + _tmp979_ = async_method; + if (_tmp979_ != NULL) { + ValaMethod* _tmp980_; + ValaMethod* _tmp981_; + ValaMethod* _tmp982_; + _tmp980_ = m; + _tmp981_ = async_method; + _tmp982_ = vala_method_get_callback_method (_tmp981_); + if (_tmp980_ == _tmp982_) { is_valid_access = TRUE; } else { - gboolean _tmp980_ = FALSE; - ValaMethod* _tmp981_; - ValaMethod* _tmp982_; - ValaMethod* _tmp983_; - _tmp981_ = async_method; - _tmp982_ = vala_method_get_base_method (_tmp981_); - _tmp983_ = _tmp982_; - if (_tmp983_ != NULL) { - ValaMethod* _tmp984_; - ValaMethod* _tmp985_; - ValaMethod* _tmp986_; + gboolean _tmp983_ = FALSE; + ValaMethod* _tmp984_; + ValaMethod* _tmp985_; + ValaMethod* _tmp986_; + _tmp984_ = async_method; + _tmp985_ = vala_method_get_base_method (_tmp984_); + _tmp986_ = _tmp985_; + if (_tmp986_ != NULL) { ValaMethod* _tmp987_; ValaMethod* _tmp988_; - _tmp984_ = m; - _tmp985_ = async_method; - _tmp986_ = vala_method_get_base_method (_tmp985_); - _tmp987_ = _tmp986_; - _tmp988_ = vala_method_get_callback_method (_tmp987_); - _tmp980_ = _tmp984_ == _tmp988_; + ValaMethod* _tmp989_; + ValaMethod* _tmp990_; + ValaMethod* _tmp991_; + _tmp987_ = m; + _tmp988_ = async_method; + _tmp989_ = vala_method_get_base_method (_tmp988_); + _tmp990_ = _tmp989_; + _tmp991_ = vala_method_get_callback_method (_tmp990_); + _tmp983_ = _tmp987_ == _tmp991_; } else { - _tmp980_ = FALSE; + _tmp983_ = FALSE; } - if (_tmp980_) { + if (_tmp983_) { is_valid_access = TRUE; } else { - gboolean _tmp989_ = FALSE; - ValaMethod* _tmp990_; - ValaMethod* _tmp991_; - ValaMethod* _tmp992_; - _tmp990_ = async_method; - _tmp991_ = vala_method_get_base_interface_method (_tmp990_); - _tmp992_ = _tmp991_; - if (_tmp992_ != NULL) { - ValaMethod* _tmp993_; - ValaMethod* _tmp994_; - ValaMethod* _tmp995_; + gboolean _tmp992_ = FALSE; + ValaMethod* _tmp993_; + ValaMethod* _tmp994_; + ValaMethod* _tmp995_; + _tmp993_ = async_method; + _tmp994_ = vala_method_get_base_interface_method (_tmp993_); + _tmp995_ = _tmp994_; + if (_tmp995_ != NULL) { ValaMethod* _tmp996_; ValaMethod* _tmp997_; - _tmp993_ = m; - _tmp994_ = async_method; - _tmp995_ = vala_method_get_base_interface_method (_tmp994_); - _tmp996_ = _tmp995_; - _tmp997_ = vala_method_get_callback_method (_tmp996_); - _tmp989_ = _tmp993_ == _tmp997_; + ValaMethod* _tmp998_; + ValaMethod* _tmp999_; + ValaMethod* _tmp1000_; + _tmp996_ = m; + _tmp997_ = async_method; + _tmp998_ = vala_method_get_base_interface_method (_tmp997_); + _tmp999_ = _tmp998_; + _tmp1000_ = vala_method_get_callback_method (_tmp999_); + _tmp992_ = _tmp996_ == _tmp1000_; } else { - _tmp989_ = FALSE; + _tmp992_ = FALSE; } - if (_tmp989_) { + if (_tmp992_) { is_valid_access = TRUE; } } } } if (!is_valid_access) { - ValaSourceReference* _tmp998_; - ValaSourceReference* _tmp999_; - ValaMethod* _tmp1000_; - gchar* _tmp1001_; - gchar* _tmp1002_; + ValaSourceReference* _tmp1001_; + ValaSourceReference* _tmp1002_; + ValaMethod* _tmp1003_; + gchar* _tmp1004_; + gchar* _tmp1005_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp998_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp999_ = _tmp998_; - _tmp1000_ = m; - _tmp1001_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1000_); + _tmp1001_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp1002_ = _tmp1001_; - vala_report_error (_tmp999_, "Access to async callback `%s' not allowed in this context", _tmp1002_); - _g_free0 (_tmp1002_); + _tmp1003_ = m; + _tmp1004_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1003_); + _tmp1005_ = _tmp1004_; + vala_report_error (_tmp1002_, "Access to async callback `%s' not allowed in this context", _tmp1005_); + _g_free0 (_tmp1005_); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } - _tmp1003_ = async_method; - _tmp1004_ = vala_code_context_get_analyzer (context); - _tmp1005_ = _tmp1004_; - _tmp1006_ = vala_semantic_analyzer_get_current_method (_tmp1005_); - _tmp1007_ = _tmp1006_; - if (_tmp1003_ != _tmp1007_) { + _tmp1006_ = async_method; + _tmp1007_ = vala_code_context_get_analyzer (context); + _tmp1008_ = _tmp1007_; + _tmp1009_ = vala_semantic_analyzer_get_current_method (_tmp1008_); + _tmp1010_ = _tmp1009_; + if (_tmp1006_ != _tmp1010_) { ValaSymbol* sym = NULL; - ValaSemanticAnalyzer* _tmp1008_; - ValaSemanticAnalyzer* _tmp1009_; - ValaMethod* _tmp1010_; - ValaMethod* _tmp1011_; - ValaMethod* _tmp1020_; - ValaBlock* _tmp1021_; - ValaBlock* _tmp1022_; - _tmp1008_ = vala_code_context_get_analyzer (context); - _tmp1009_ = _tmp1008_; - _tmp1010_ = vala_semantic_analyzer_get_current_method (_tmp1009_); - _tmp1011_ = _tmp1010_; - sym = (ValaSymbol*) _tmp1011_; + ValaSemanticAnalyzer* _tmp1011_; + ValaSemanticAnalyzer* _tmp1012_; + ValaMethod* _tmp1013_; + ValaMethod* _tmp1014_; + ValaMethod* _tmp1023_; + ValaBlock* _tmp1024_; + ValaBlock* _tmp1025_; + _tmp1011_ = vala_code_context_get_analyzer (context); + _tmp1012_ = _tmp1011_; + _tmp1013_ = vala_semantic_analyzer_get_current_method (_tmp1012_); + _tmp1014_ = _tmp1013_; + sym = (ValaSymbol*) _tmp1014_; while (TRUE) { - ValaSymbol* _tmp1012_; - ValaMethod* _tmp1013_; + ValaSymbol* _tmp1015_; + ValaMethod* _tmp1016_; ValaMethod* method = NULL; - ValaSymbol* _tmp1014_; - ValaMethod* _tmp1015_; ValaSymbol* _tmp1017_; - ValaSymbol* _tmp1018_; - ValaSymbol* _tmp1019_; - _tmp1012_ = sym; - _tmp1013_ = async_method; - if (!(_tmp1012_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp1013_, VALA_TYPE_SYMBOL, ValaSymbol))) { + ValaMethod* _tmp1018_; + ValaSymbol* _tmp1020_; + ValaSymbol* _tmp1021_; + ValaSymbol* _tmp1022_; + _tmp1015_ = sym; + _tmp1016_ = async_method; + if (!(_tmp1015_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp1016_, VALA_TYPE_SYMBOL, ValaSymbol))) { break; } - _tmp1014_ = sym; - method = VALA_IS_METHOD (_tmp1014_) ? ((ValaMethod*) _tmp1014_) : NULL; - _tmp1015_ = method; - if (_tmp1015_ != NULL) { - ValaMethod* _tmp1016_; - _tmp1016_ = method; - vala_method_set_closure (_tmp1016_, TRUE); - } _tmp1017_ = sym; - _tmp1018_ = vala_symbol_get_parent_symbol (_tmp1017_); - _tmp1019_ = _tmp1018_; - sym = _tmp1019_; + method = VALA_IS_METHOD (_tmp1017_) ? ((ValaMethod*) _tmp1017_) : NULL; + _tmp1018_ = method; + if (_tmp1018_ != NULL) { + ValaMethod* _tmp1019_; + _tmp1019_ = method; + vala_method_set_closure (_tmp1019_, TRUE); + } + _tmp1020_ = sym; + _tmp1021_ = vala_symbol_get_parent_symbol (_tmp1020_); + _tmp1022_ = _tmp1021_; + sym = _tmp1022_; } - _tmp1020_ = async_method; - _tmp1021_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1020_); - _tmp1022_ = _tmp1021_; - vala_block_set_captured (_tmp1022_, TRUE); + _tmp1023_ = async_method; + _tmp1024_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1023_); + _tmp1025_ = _tmp1024_; + vala_block_set_captured (_tmp1025_, TRUE); } - _tmp1023_ = async_method; - _tmp1024_ = vala_method_get_callback_method (_tmp1023_); - m = _tmp1024_; - _tmp1025_ = m; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1025_); - _tmp1026_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1027_ = _tmp1026_; - member = _tmp1027_; - } else { - ValaMethod* _tmp1028_; - ValaMethod* _tmp1029_; - ValaMethod* _tmp1030_; + _tmp1026_ = async_method; + _tmp1027_ = vala_method_get_callback_method (_tmp1026_); + m = _tmp1027_; _tmp1028_ = m; - _tmp1029_ = vala_method_get_base_method (_tmp1028_); + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1028_); + _tmp1029_ = vala_expression_get_symbol_reference ((ValaExpression*) self); _tmp1030_ = _tmp1029_; - if (_tmp1030_ != NULL) { - ValaMethod* _tmp1031_; - ValaMethod* _tmp1032_; - ValaMethod* _tmp1033_; + member = _tmp1030_; + } else { + ValaMethod* _tmp1031_; + ValaMethod* _tmp1032_; + ValaMethod* _tmp1033_; + _tmp1031_ = m; + _tmp1032_ = vala_method_get_base_method (_tmp1031_); + _tmp1033_ = _tmp1032_; + if (_tmp1033_ != NULL) { ValaMethod* _tmp1034_; - ValaSignal* _tmp1035_; - ValaSignal* _tmp1036_; - ValaSymbol* _tmp1041_; - ValaSymbol* _tmp1042_; - _tmp1031_ = m; - _tmp1032_ = vala_method_get_base_method (_tmp1031_); - _tmp1033_ = _tmp1032_; - m = _tmp1033_; + ValaMethod* _tmp1035_; + ValaMethod* _tmp1036_; + ValaMethod* _tmp1037_; + ValaSignal* _tmp1038_; + ValaSignal* _tmp1039_; + ValaSymbol* _tmp1044_; + ValaSymbol* _tmp1045_; _tmp1034_ = m; - _tmp1035_ = vala_method_get_signal_reference (_tmp1034_); + _tmp1035_ = vala_method_get_base_method (_tmp1034_); _tmp1036_ = _tmp1035_; - if (_tmp1036_ != NULL) { - ValaMethod* _tmp1037_; - ValaSignal* _tmp1038_; - ValaSignal* _tmp1039_; - _tmp1037_ = m; - _tmp1038_ = vala_method_get_signal_reference (_tmp1037_); - _tmp1039_ = _tmp1038_; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1039_); - } else { + m = _tmp1036_; + _tmp1037_ = m; + _tmp1038_ = vala_method_get_signal_reference (_tmp1037_); + _tmp1039_ = _tmp1038_; + if (_tmp1039_ != NULL) { ValaMethod* _tmp1040_; + ValaSignal* _tmp1041_; + ValaSignal* _tmp1042_; _tmp1040_ = m; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1040_); + _tmp1041_ = vala_method_get_signal_reference (_tmp1040_); + _tmp1042_ = _tmp1041_; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1042_); + } else { + ValaMethod* _tmp1043_; + _tmp1043_ = m; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1043_); } - _tmp1041_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1042_ = _tmp1041_; - member = _tmp1042_; - } else { - ValaMethod* _tmp1043_; - ValaMethod* _tmp1044_; - ValaMethod* _tmp1045_; - _tmp1043_ = m; - _tmp1044_ = vala_method_get_base_interface_method (_tmp1043_); + _tmp1044_ = vala_expression_get_symbol_reference ((ValaExpression*) self); _tmp1045_ = _tmp1044_; - if (_tmp1045_ != NULL) { - ValaMethod* _tmp1046_; - ValaMethod* _tmp1047_; - ValaMethod* _tmp1048_; + member = _tmp1045_; + } else { + ValaMethod* _tmp1046_; + ValaMethod* _tmp1047_; + ValaMethod* _tmp1048_; + _tmp1046_ = m; + _tmp1047_ = vala_method_get_base_interface_method (_tmp1046_); + _tmp1048_ = _tmp1047_; + if (_tmp1048_ != NULL) { ValaMethod* _tmp1049_; - ValaSignal* _tmp1050_; - ValaSignal* _tmp1051_; - ValaSymbol* _tmp1056_; - ValaSymbol* _tmp1057_; - _tmp1046_ = m; - _tmp1047_ = vala_method_get_base_interface_method (_tmp1046_); - _tmp1048_ = _tmp1047_; - m = _tmp1048_; + ValaMethod* _tmp1050_; + ValaMethod* _tmp1051_; + ValaMethod* _tmp1052_; + ValaSignal* _tmp1053_; + ValaSignal* _tmp1054_; + ValaSymbol* _tmp1059_; + ValaSymbol* _tmp1060_; _tmp1049_ = m; - _tmp1050_ = vala_method_get_signal_reference (_tmp1049_); + _tmp1050_ = vala_method_get_base_interface_method (_tmp1049_); _tmp1051_ = _tmp1050_; - if (_tmp1051_ != NULL) { - ValaMethod* _tmp1052_; - ValaSignal* _tmp1053_; - ValaSignal* _tmp1054_; - _tmp1052_ = m; - _tmp1053_ = vala_method_get_signal_reference (_tmp1052_); - _tmp1054_ = _tmp1053_; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1054_); - } else { + m = _tmp1051_; + _tmp1052_ = m; + _tmp1053_ = vala_method_get_signal_reference (_tmp1052_); + _tmp1054_ = _tmp1053_; + if (_tmp1054_ != NULL) { ValaMethod* _tmp1055_; + ValaSignal* _tmp1056_; + ValaSignal* _tmp1057_; _tmp1055_ = m; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1055_); + _tmp1056_ = vala_method_get_signal_reference (_tmp1055_); + _tmp1057_ = _tmp1056_; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1057_); + } else { + ValaMethod* _tmp1058_; + _tmp1058_ = m; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1058_); } - _tmp1056_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1057_ = _tmp1056_; - member = _tmp1057_; + _tmp1059_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1060_ = _tmp1059_; + member = _tmp1060_; } } } - _tmp1058_ = m; - _tmp1059_ = vala_symbol_get_access ((ValaSymbol*) _tmp1058_); - _tmp1060_ = _tmp1059_; - access = _tmp1060_; _tmp1061_ = m; - if (!VALA_IS_CREATION_METHOD (_tmp1061_)) { - ValaMethod* _tmp1062_; - ValaMemberBinding _tmp1063_; - ValaMemberBinding _tmp1064_; - _tmp1062_ = m; - _tmp1063_ = vala_method_get_binding (_tmp1062_); - _tmp1064_ = _tmp1063_; - instance = _tmp1064_ == VALA_MEMBER_BINDING_INSTANCE; + _tmp1062_ = vala_symbol_get_access ((ValaSymbol*) _tmp1061_); + _tmp1063_ = _tmp1062_; + access = _tmp1063_; + _tmp1064_ = m; + if (!VALA_IS_CREATION_METHOD (_tmp1064_)) { + ValaMethod* _tmp1065_; + ValaMemberBinding _tmp1066_; + ValaMemberBinding _tmp1067_; + _tmp1065_ = m; + _tmp1066_ = vala_method_get_binding (_tmp1065_); + _tmp1067_ = _tmp1066_; + instance = _tmp1067_ == VALA_MEMBER_BINDING_INSTANCE; } - _tmp1065_ = m; - _tmp1066_ = vala_method_get_binding (_tmp1065_); - _tmp1067_ = _tmp1066_; - klass = _tmp1067_ == VALA_MEMBER_BINDING_CLASS; + _tmp1068_ = m; + _tmp1069_ = vala_method_get_binding (_tmp1068_); + _tmp1070_ = _tmp1069_; + klass = _tmp1070_ == VALA_MEMBER_BINDING_CLASS; { ValaList* _param_list = NULL; - ValaMethod* _tmp1068_; - ValaList* _tmp1069_; + ValaMethod* _tmp1071_; + ValaList* _tmp1072_; gint _param_size = 0; - ValaList* _tmp1070_; - gint _tmp1071_; - gint _tmp1072_; + ValaList* _tmp1073_; + gint _tmp1074_; + gint _tmp1075_; gint _param_index = 0; - _tmp1068_ = m; - _tmp1069_ = vala_callable_get_parameters ((ValaCallable*) _tmp1068_); - _param_list = _tmp1069_; - _tmp1070_ = _param_list; - _tmp1071_ = vala_collection_get_size ((ValaCollection*) _tmp1070_); - _tmp1072_ = _tmp1071_; - _param_size = _tmp1072_; + _tmp1071_ = m; + _tmp1072_ = vala_callable_get_parameters ((ValaCallable*) _tmp1071_); + _param_list = _tmp1072_; + _tmp1073_ = _param_list; + _tmp1074_ = vala_collection_get_size ((ValaCollection*) _tmp1073_); + _tmp1075_ = _tmp1074_; + _param_size = _tmp1075_; _param_index = -1; while (TRUE) { - gint _tmp1073_; - gint _tmp1074_; + gint _tmp1076_; + gint _tmp1077_; ValaParameter* param = NULL; - ValaList* _tmp1075_; - gpointer _tmp1076_; + ValaList* _tmp1078_; + gpointer _tmp1079_; ValaGenericType* generic_type = NULL; - ValaParameter* _tmp1077_; - ValaDataType* _tmp1078_; - ValaDataType* _tmp1079_; - gboolean _tmp1080_ = FALSE; - ValaGenericType* _tmp1081_; + ValaParameter* _tmp1080_; + ValaDataType* _tmp1081_; + ValaDataType* _tmp1082_; + gboolean _tmp1083_ = FALSE; + ValaGenericType* _tmp1084_; _param_index = _param_index + 1; - _tmp1073_ = _param_index; - _tmp1074_ = _param_size; - if (!(_tmp1073_ < _tmp1074_)) { + _tmp1076_ = _param_index; + _tmp1077_ = _param_size; + if (!(_tmp1076_ < _tmp1077_)) { break; } - _tmp1075_ = _param_list; - _tmp1076_ = vala_list_get (_tmp1075_, _param_index); - param = (ValaParameter*) _tmp1076_; - _tmp1077_ = param; - _tmp1078_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1077_); - _tmp1079_ = _tmp1078_; - generic_type = VALA_IS_GENERIC_TYPE (_tmp1079_) ? ((ValaGenericType*) _tmp1079_) : NULL; - _tmp1081_ = generic_type; - if (_tmp1081_ != NULL) { - ValaGenericType* _tmp1082_; - ValaTypeParameter* _tmp1083_; - ValaTypeParameter* _tmp1084_; - ValaSymbol* _tmp1085_; - ValaSymbol* _tmp1086_; - _tmp1082_ = generic_type; - _tmp1083_ = vala_generic_type_get_type_parameter (_tmp1082_); - _tmp1084_ = _tmp1083_; - _tmp1085_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1084_); - _tmp1086_ = _tmp1085_; - _tmp1080_ = VALA_IS_TYPESYMBOL (_tmp1086_); + _tmp1078_ = _param_list; + _tmp1079_ = vala_list_get (_tmp1078_, _param_index); + param = (ValaParameter*) _tmp1079_; + _tmp1080_ = param; + _tmp1081_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1080_); + _tmp1082_ = _tmp1081_; + generic_type = VALA_IS_GENERIC_TYPE (_tmp1082_) ? ((ValaGenericType*) _tmp1082_) : NULL; + _tmp1084_ = generic_type; + if (_tmp1084_ != NULL) { + ValaGenericType* _tmp1085_; + ValaTypeParameter* _tmp1086_; + ValaTypeParameter* _tmp1087_; + ValaSymbol* _tmp1088_; + ValaSymbol* _tmp1089_; + _tmp1085_ = generic_type; + _tmp1086_ = vala_generic_type_get_type_parameter (_tmp1085_); + _tmp1087_ = _tmp1086_; + _tmp1088_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1087_); + _tmp1089_ = _tmp1088_; + _tmp1083_ = VALA_IS_TYPESYMBOL (_tmp1089_); } else { - _tmp1080_ = FALSE; + _tmp1083_ = FALSE; } - if (_tmp1080_) { + if (_tmp1083_) { generics = TRUE; _vala_code_node_unref0 (param); break; @@ -3912,239 +3918,239 @@ _vala_code_node_unref0 (param); } } - _tmp1087_ = m; - _tmp1088_ = vala_callable_get_return_type ((ValaCallable*) _tmp1087_); - _tmp1089_ = _tmp1088_; - generic_type = VALA_IS_GENERIC_TYPE (_tmp1089_) ? ((ValaGenericType*) _tmp1089_) : NULL; - _tmp1091_ = generic_type; - if (_tmp1091_ != NULL) { - ValaGenericType* _tmp1092_; - ValaTypeParameter* _tmp1093_; - ValaTypeParameter* _tmp1094_; - ValaSymbol* _tmp1095_; - ValaSymbol* _tmp1096_; - _tmp1092_ = generic_type; - _tmp1093_ = vala_generic_type_get_type_parameter (_tmp1092_); - _tmp1094_ = _tmp1093_; - _tmp1095_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1094_); - _tmp1096_ = _tmp1095_; - _tmp1090_ = VALA_IS_TYPESYMBOL (_tmp1096_); + _tmp1090_ = m; + _tmp1091_ = vala_callable_get_return_type ((ValaCallable*) _tmp1090_); + _tmp1092_ = _tmp1091_; + generic_type = VALA_IS_GENERIC_TYPE (_tmp1092_) ? ((ValaGenericType*) _tmp1092_) : NULL; + _tmp1094_ = generic_type; + if (_tmp1094_ != NULL) { + ValaGenericType* _tmp1095_; + ValaTypeParameter* _tmp1096_; + ValaTypeParameter* _tmp1097_; + ValaSymbol* _tmp1098_; + ValaSymbol* _tmp1099_; + _tmp1095_ = generic_type; + _tmp1096_ = vala_generic_type_get_type_parameter (_tmp1095_); + _tmp1097_ = _tmp1096_; + _tmp1098_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1097_); + _tmp1099_ = _tmp1098_; + _tmp1093_ = VALA_IS_TYPESYMBOL (_tmp1099_); } else { - _tmp1090_ = FALSE; + _tmp1093_ = FALSE; } - if (_tmp1090_) { + if (_tmp1093_) { generics = TRUE; } } else { - ValaSymbol* _tmp1097_; - _tmp1097_ = member; - if (VALA_IS_PROPERTY (_tmp1097_)) { + ValaSymbol* _tmp1100_; + _tmp1100_ = member; + if (VALA_IS_PROPERTY (_tmp1100_)) { ValaProperty* prop = NULL; - ValaSymbol* _tmp1098_; - ValaProperty* _tmp1099_; - ValaProperty* _tmp1100_; - ValaProperty* _tmp1101_; + ValaSymbol* _tmp1101_; ValaProperty* _tmp1102_; - ValaProperty* _tmp1118_; - ValaSymbolAccessibility _tmp1119_; - ValaSymbolAccessibility _tmp1120_; - gboolean _tmp1121_; - gboolean _tmp1122_; - ValaProperty* _tmp1221_; - ValaMemberBinding _tmp1222_; - ValaMemberBinding _tmp1223_; + ValaProperty* _tmp1103_; + ValaProperty* _tmp1104_; + ValaProperty* _tmp1105_; + ValaProperty* _tmp1121_; + ValaSymbolAccessibility _tmp1122_; + ValaSymbolAccessibility _tmp1123_; + gboolean _tmp1124_; + gboolean _tmp1125_; ValaProperty* _tmp1224_; - ValaDataType* _tmp1225_; - ValaDataType* _tmp1226_; - _tmp1098_ = member; - prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp1098_, VALA_TYPE_PROPERTY, ValaProperty); - _tmp1099_ = prop; - if (!vala_code_node_check ((ValaCodeNode*) _tmp1099_, context)) { + ValaMemberBinding _tmp1225_; + ValaMemberBinding _tmp1226_; + ValaProperty* _tmp1227_; + ValaDataType* _tmp1228_; + ValaDataType* _tmp1229_; + _tmp1101_ = member; + prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp1101_, VALA_TYPE_PROPERTY, ValaProperty); + _tmp1102_ = prop; + if (!vala_code_node_check ((ValaCodeNode*) _tmp1102_, context)) { vala_code_node_set_error ((ValaCodeNode*) self, TRUE); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } - _tmp1100_ = prop; - _tmp1101_ = vala_property_get_base_property (_tmp1100_); - _tmp1102_ = _tmp1101_; - if (_tmp1102_ != NULL) { - ValaProperty* _tmp1103_; - ValaProperty* _tmp1104_; - ValaProperty* _tmp1105_; + _tmp1103_ = prop; + _tmp1104_ = vala_property_get_base_property (_tmp1103_); + _tmp1105_ = _tmp1104_; + if (_tmp1105_ != NULL) { ValaProperty* _tmp1106_; - ValaSymbol* _tmp1107_; - ValaSymbol* _tmp1108_; - _tmp1103_ = prop; - _tmp1104_ = vala_property_get_base_property (_tmp1103_); - _tmp1105_ = _tmp1104_; - prop = _tmp1105_; + ValaProperty* _tmp1107_; + ValaProperty* _tmp1108_; + ValaProperty* _tmp1109_; + ValaSymbol* _tmp1110_; + ValaSymbol* _tmp1111_; _tmp1106_ = prop; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1106_); - _tmp1107_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1107_ = vala_property_get_base_property (_tmp1106_); _tmp1108_ = _tmp1107_; - member = _tmp1108_; - } else { - ValaProperty* _tmp1109_; - ValaProperty* _tmp1110_; - ValaProperty* _tmp1111_; + prop = _tmp1108_; _tmp1109_ = prop; - _tmp1110_ = vala_property_get_base_interface_property (_tmp1109_); + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1109_); + _tmp1110_ = vala_expression_get_symbol_reference ((ValaExpression*) self); _tmp1111_ = _tmp1110_; - if (_tmp1111_ != NULL) { - ValaProperty* _tmp1112_; - ValaProperty* _tmp1113_; - ValaProperty* _tmp1114_; + member = _tmp1111_; + } else { + ValaProperty* _tmp1112_; + ValaProperty* _tmp1113_; + ValaProperty* _tmp1114_; + _tmp1112_ = prop; + _tmp1113_ = vala_property_get_base_interface_property (_tmp1112_); + _tmp1114_ = _tmp1113_; + if (_tmp1114_ != NULL) { ValaProperty* _tmp1115_; - ValaSymbol* _tmp1116_; - ValaSymbol* _tmp1117_; - _tmp1112_ = prop; - _tmp1113_ = vala_property_get_base_interface_property (_tmp1112_); - _tmp1114_ = _tmp1113_; - prop = _tmp1114_; + ValaProperty* _tmp1116_; + ValaProperty* _tmp1117_; + ValaProperty* _tmp1118_; + ValaSymbol* _tmp1119_; + ValaSymbol* _tmp1120_; _tmp1115_ = prop; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1115_); - _tmp1116_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1116_ = vala_property_get_base_interface_property (_tmp1115_); _tmp1117_ = _tmp1116_; - member = _tmp1117_; + prop = _tmp1117_; + _tmp1118_ = prop; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1118_); + _tmp1119_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1120_ = _tmp1119_; + member = _tmp1120_; } } - _tmp1118_ = prop; - _tmp1119_ = vala_symbol_get_access ((ValaSymbol*) _tmp1118_); - _tmp1120_ = _tmp1119_; - access = _tmp1120_; - _tmp1121_ = vala_expression_get_lvalue ((ValaExpression*) self); - _tmp1122_ = _tmp1121_; - if (_tmp1122_) { - ValaProperty* _tmp1123_; - ValaPropertyAccessor* _tmp1124_; - ValaPropertyAccessor* _tmp1125_; - ValaProperty* _tmp1169_; - ValaSymbolAccessibility _tmp1170_; - ValaSymbolAccessibility _tmp1171_; - _tmp1123_ = prop; - _tmp1124_ = vala_property_get_set_accessor (_tmp1123_); - _tmp1125_ = _tmp1124_; - if (_tmp1125_ == NULL) { - ValaSourceReference* _tmp1126_; - ValaSourceReference* _tmp1127_; - ValaProperty* _tmp1128_; - gchar* _tmp1129_; - gchar* _tmp1130_; + _tmp1121_ = prop; + _tmp1122_ = vala_symbol_get_access ((ValaSymbol*) _tmp1121_); + _tmp1123_ = _tmp1122_; + access = _tmp1123_; + _tmp1124_ = vala_expression_get_lvalue ((ValaExpression*) self); + _tmp1125_ = _tmp1124_; + if (_tmp1125_) { + ValaProperty* _tmp1126_; + ValaPropertyAccessor* _tmp1127_; + ValaPropertyAccessor* _tmp1128_; + ValaProperty* _tmp1172_; + ValaSymbolAccessibility _tmp1173_; + ValaSymbolAccessibility _tmp1174_; + _tmp1126_ = prop; + _tmp1127_ = vala_property_get_set_accessor (_tmp1126_); + _tmp1128_ = _tmp1127_; + if (_tmp1128_ == NULL) { + ValaSourceReference* _tmp1129_; + ValaSourceReference* _tmp1130_; + ValaProperty* _tmp1131_; + gchar* _tmp1132_; + gchar* _tmp1133_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp1126_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1127_ = _tmp1126_; - _tmp1128_ = prop; - _tmp1129_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1128_); + _tmp1129_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp1130_ = _tmp1129_; - vala_report_error (_tmp1127_, "Property `%s' is read-only", _tmp1130_); - _g_free0 (_tmp1130_); + _tmp1131_ = prop; + _tmp1132_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1131_); + _tmp1133_ = _tmp1132_; + vala_report_error (_tmp1130_, "Property `%s' is read-only", _tmp1133_); + _g_free0 (_tmp1133_); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } else { - gboolean _tmp1131_ = FALSE; - ValaProperty* _tmp1132_; - ValaPropertyAccessor* _tmp1133_; - ValaPropertyAccessor* _tmp1134_; - gboolean _tmp1135_; - gboolean _tmp1136_; - _tmp1132_ = prop; - _tmp1133_ = vala_property_get_set_accessor (_tmp1132_); - _tmp1134_ = _tmp1133_; - _tmp1135_ = vala_property_accessor_get_writable (_tmp1134_); - _tmp1136_ = _tmp1135_; - if (!_tmp1136_) { - ValaProperty* _tmp1137_; - ValaPropertyAccessor* _tmp1138_; - ValaPropertyAccessor* _tmp1139_; - gboolean _tmp1140_; - gboolean _tmp1141_; - _tmp1137_ = prop; - _tmp1138_ = vala_property_get_set_accessor (_tmp1137_); - _tmp1139_ = _tmp1138_; - _tmp1140_ = vala_property_accessor_get_construction (_tmp1139_); - _tmp1141_ = _tmp1140_; - _tmp1131_ = _tmp1141_; + gboolean _tmp1134_ = FALSE; + ValaProperty* _tmp1135_; + ValaPropertyAccessor* _tmp1136_; + ValaPropertyAccessor* _tmp1137_; + gboolean _tmp1138_; + gboolean _tmp1139_; + _tmp1135_ = prop; + _tmp1136_ = vala_property_get_set_accessor (_tmp1135_); + _tmp1137_ = _tmp1136_; + _tmp1138_ = vala_property_accessor_get_writable (_tmp1137_); + _tmp1139_ = _tmp1138_; + if (!_tmp1139_) { + ValaProperty* _tmp1140_; + ValaPropertyAccessor* _tmp1141_; + ValaPropertyAccessor* _tmp1142_; + gboolean _tmp1143_; + gboolean _tmp1144_; + _tmp1140_ = prop; + _tmp1141_ = vala_property_get_set_accessor (_tmp1140_); + _tmp1142_ = _tmp1141_; + _tmp1143_ = vala_property_accessor_get_construction (_tmp1142_); + _tmp1144_ = _tmp1143_; + _tmp1134_ = _tmp1144_; } else { - _tmp1131_ = FALSE; + _tmp1134_ = FALSE; } - if (_tmp1131_) { - ValaSemanticAnalyzer* _tmp1142_; - ValaSemanticAnalyzer* _tmp1143_; - ValaMethod* _tmp1144_; - _tmp1142_ = vala_code_context_get_analyzer (context); - _tmp1143_ = _tmp1142_; - _tmp1144_ = vala_semantic_analyzer_find_current_method (_tmp1143_); - if (VALA_IS_CREATION_METHOD (_tmp1144_)) { - ValaSourceReference* _tmp1145_; - ValaSourceReference* _tmp1146_; + if (_tmp1134_) { + ValaSemanticAnalyzer* _tmp1145_; + ValaSemanticAnalyzer* _tmp1146_; + ValaMethod* _tmp1147_; + _tmp1145_ = vala_code_context_get_analyzer (context); + _tmp1146_ = _tmp1145_; + _tmp1147_ = vala_semantic_analyzer_find_current_method (_tmp1146_); + if (VALA_IS_CREATION_METHOD (_tmp1147_)) { + ValaSourceReference* _tmp1148_; + ValaSourceReference* _tmp1149_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp1145_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1146_ = _tmp1145_; - vala_report_error (_tmp1146_, "Cannot assign to construct-only properties, use Object (property: valu" \ + _tmp1148_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp1149_ = _tmp1148_; + vala_report_error (_tmp1149_, "Cannot assign to construct-only properties, use Object (property: valu" \ "e) constructor chain up"); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } else { - ValaSemanticAnalyzer* _tmp1147_; - ValaSemanticAnalyzer* _tmp1148_; - _tmp1147_ = vala_code_context_get_analyzer (context); - _tmp1148_ = _tmp1147_; - if (vala_semantic_analyzer_is_in_constructor (_tmp1148_)) { - ValaSemanticAnalyzer* _tmp1149_; - ValaSemanticAnalyzer* _tmp1150_; - ValaTypeSymbol* _tmp1151_; - ValaTypeSymbol* _tmp1152_; - ValaProperty* _tmp1153_; - ValaSymbol* _tmp1154_; - ValaSymbol* _tmp1155_; - _tmp1149_ = vala_code_context_get_analyzer (context); - _tmp1150_ = _tmp1149_; - _tmp1151_ = vala_semantic_analyzer_get_current_type_symbol (_tmp1150_); - _tmp1152_ = _tmp1151_; - _tmp1153_ = prop; - _tmp1154_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1153_); + ValaSemanticAnalyzer* _tmp1150_; + ValaSemanticAnalyzer* _tmp1151_; + _tmp1150_ = vala_code_context_get_analyzer (context); + _tmp1151_ = _tmp1150_; + if (vala_semantic_analyzer_is_in_constructor (_tmp1151_)) { + ValaSemanticAnalyzer* _tmp1152_; + ValaSemanticAnalyzer* _tmp1153_; + ValaTypeSymbol* _tmp1154_; + ValaTypeSymbol* _tmp1155_; + ValaProperty* _tmp1156_; + ValaSymbol* _tmp1157_; + ValaSymbol* _tmp1158_; + _tmp1152_ = vala_code_context_get_analyzer (context); + _tmp1153_ = _tmp1152_; + _tmp1154_ = vala_semantic_analyzer_get_current_type_symbol (_tmp1153_); _tmp1155_ = _tmp1154_; - if (!vala_typesymbol_is_subtype_of (_tmp1152_, G_TYPE_CHECK_INSTANCE_CAST (_tmp1155_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol))) { - ValaSourceReference* _tmp1156_; - ValaSourceReference* _tmp1157_; - ValaProperty* _tmp1158_; - gchar* _tmp1159_; - gchar* _tmp1160_; - ValaSemanticAnalyzer* _tmp1161_; - ValaSemanticAnalyzer* _tmp1162_; - ValaTypeSymbol* _tmp1163_; - ValaTypeSymbol* _tmp1164_; - gchar* _tmp1165_; - gchar* _tmp1166_; + _tmp1156_ = prop; + _tmp1157_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1156_); + _tmp1158_ = _tmp1157_; + if (!vala_typesymbol_is_subtype_of (_tmp1155_, G_TYPE_CHECK_INSTANCE_CAST (_tmp1158_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol))) { + ValaSourceReference* _tmp1159_; + ValaSourceReference* _tmp1160_; + ValaProperty* _tmp1161_; + gchar* _tmp1162_; + gchar* _tmp1163_; + ValaSemanticAnalyzer* _tmp1164_; + ValaSemanticAnalyzer* _tmp1165_; + ValaTypeSymbol* _tmp1166_; + ValaTypeSymbol* _tmp1167_; + gchar* _tmp1168_; + gchar* _tmp1169_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp1156_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1157_ = _tmp1156_; - _tmp1158_ = prop; - _tmp1159_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1158_); + _tmp1159_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp1160_ = _tmp1159_; - _tmp1161_ = vala_code_context_get_analyzer (context); - _tmp1162_ = _tmp1161_; - _tmp1163_ = vala_semantic_analyzer_get_current_type_symbol (_tmp1162_); - _tmp1164_ = _tmp1163_; - _tmp1165_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1164_); - _tmp1166_ = _tmp1165_; - vala_report_error (_tmp1157_, "Cannot assign to construct-only property `%s' in `construct' of `%s'", _tmp1160_, _tmp1166_); - _g_free0 (_tmp1166_); - _g_free0 (_tmp1160_); + _tmp1161_ = prop; + _tmp1162_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1161_); + _tmp1163_ = _tmp1162_; + _tmp1164_ = vala_code_context_get_analyzer (context); + _tmp1165_ = _tmp1164_; + _tmp1166_ = vala_semantic_analyzer_get_current_type_symbol (_tmp1165_); + _tmp1167_ = _tmp1166_; + _tmp1168_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1167_); + _tmp1169_ = _tmp1168_; + vala_report_error (_tmp1160_, "Cannot assign to construct-only property `%s' in `construct' of `%s'", _tmp1163_, _tmp1169_); + _g_free0 (_tmp1169_); + _g_free0 (_tmp1163_); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } } else { - ValaSourceReference* _tmp1167_; - ValaSourceReference* _tmp1168_; + ValaSourceReference* _tmp1170_; + ValaSourceReference* _tmp1171_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp1167_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1168_ = _tmp1167_; - vala_report_error (_tmp1168_, "Cannot assign to construct-only property in this context"); + _tmp1170_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp1171_ = _tmp1170_; + vala_report_error (_tmp1171_, "Cannot assign to construct-only property in this context"); result = FALSE; _vala_iterable_unref0 (visited_types); return result; @@ -4152,185 +4158,185 @@ } } } - _tmp1169_ = prop; - _tmp1170_ = vala_symbol_get_access ((ValaSymbol*) _tmp1169_); - _tmp1171_ = _tmp1170_; - if (_tmp1171_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) { - ValaProperty* _tmp1172_; - ValaPropertyAccessor* _tmp1173_; - ValaPropertyAccessor* _tmp1174_; - ValaSymbolAccessibility _tmp1175_; - ValaSymbolAccessibility _tmp1176_; - _tmp1172_ = prop; - _tmp1173_ = vala_property_get_set_accessor (_tmp1172_); - _tmp1174_ = _tmp1173_; - _tmp1175_ = vala_symbol_get_access ((ValaSymbol*) _tmp1174_); - _tmp1176_ = _tmp1175_; - access = _tmp1176_; - } else { - gboolean _tmp1177_ = FALSE; - ValaProperty* _tmp1178_; + _tmp1172_ = prop; + _tmp1173_ = vala_symbol_get_access ((ValaSymbol*) _tmp1172_); + _tmp1174_ = _tmp1173_; + if (_tmp1174_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) { + ValaProperty* _tmp1175_; + ValaPropertyAccessor* _tmp1176_; + ValaPropertyAccessor* _tmp1177_; + ValaSymbolAccessibility _tmp1178_; ValaSymbolAccessibility _tmp1179_; - ValaSymbolAccessibility _tmp1180_; - _tmp1178_ = prop; - _tmp1179_ = vala_symbol_get_access ((ValaSymbol*) _tmp1178_); - _tmp1180_ = _tmp1179_; - if (_tmp1180_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) { - ValaProperty* _tmp1181_; - ValaPropertyAccessor* _tmp1182_; - ValaPropertyAccessor* _tmp1183_; - ValaSymbolAccessibility _tmp1184_; - ValaSymbolAccessibility _tmp1185_; - _tmp1181_ = prop; - _tmp1182_ = vala_property_get_set_accessor (_tmp1181_); - _tmp1183_ = _tmp1182_; - _tmp1184_ = vala_symbol_get_access ((ValaSymbol*) _tmp1183_); - _tmp1185_ = _tmp1184_; - _tmp1177_ = _tmp1185_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC; + _tmp1175_ = prop; + _tmp1176_ = vala_property_get_set_accessor (_tmp1175_); + _tmp1177_ = _tmp1176_; + _tmp1178_ = vala_symbol_get_access ((ValaSymbol*) _tmp1177_); + _tmp1179_ = _tmp1178_; + access = _tmp1179_; + } else { + gboolean _tmp1180_ = FALSE; + ValaProperty* _tmp1181_; + ValaSymbolAccessibility _tmp1182_; + ValaSymbolAccessibility _tmp1183_; + _tmp1181_ = prop; + _tmp1182_ = vala_symbol_get_access ((ValaSymbol*) _tmp1181_); + _tmp1183_ = _tmp1182_; + if (_tmp1183_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) { + ValaProperty* _tmp1184_; + ValaPropertyAccessor* _tmp1185_; + ValaPropertyAccessor* _tmp1186_; + ValaSymbolAccessibility _tmp1187_; + ValaSymbolAccessibility _tmp1188_; + _tmp1184_ = prop; + _tmp1185_ = vala_property_get_set_accessor (_tmp1184_); + _tmp1186_ = _tmp1185_; + _tmp1187_ = vala_symbol_get_access ((ValaSymbol*) _tmp1186_); + _tmp1188_ = _tmp1187_; + _tmp1180_ = _tmp1188_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC; } else { - _tmp1177_ = FALSE; + _tmp1180_ = FALSE; } - if (_tmp1177_) { - ValaProperty* _tmp1186_; - ValaPropertyAccessor* _tmp1187_; - ValaPropertyAccessor* _tmp1188_; - ValaSymbolAccessibility _tmp1189_; - ValaSymbolAccessibility _tmp1190_; - _tmp1186_ = prop; - _tmp1187_ = vala_property_get_set_accessor (_tmp1186_); - _tmp1188_ = _tmp1187_; - _tmp1189_ = vala_symbol_get_access ((ValaSymbol*) _tmp1188_); - _tmp1190_ = _tmp1189_; - access = _tmp1190_; + if (_tmp1180_) { + ValaProperty* _tmp1189_; + ValaPropertyAccessor* _tmp1190_; + ValaPropertyAccessor* _tmp1191_; + ValaSymbolAccessibility _tmp1192_; + ValaSymbolAccessibility _tmp1193_; + _tmp1189_ = prop; + _tmp1190_ = vala_property_get_set_accessor (_tmp1189_); + _tmp1191_ = _tmp1190_; + _tmp1192_ = vala_symbol_get_access ((ValaSymbol*) _tmp1191_); + _tmp1193_ = _tmp1192_; + access = _tmp1193_; } } } else { - ValaProperty* _tmp1191_; - ValaPropertyAccessor* _tmp1192_; - ValaPropertyAccessor* _tmp1193_; - ValaProperty* _tmp1199_; - ValaSymbolAccessibility _tmp1200_; - ValaSymbolAccessibility _tmp1201_; - _tmp1191_ = prop; - _tmp1192_ = vala_property_get_get_accessor (_tmp1191_); - _tmp1193_ = _tmp1192_; - if (_tmp1193_ == NULL) { - ValaSourceReference* _tmp1194_; - ValaSourceReference* _tmp1195_; - ValaProperty* _tmp1196_; - gchar* _tmp1197_; - gchar* _tmp1198_; + ValaProperty* _tmp1194_; + ValaPropertyAccessor* _tmp1195_; + ValaPropertyAccessor* _tmp1196_; + ValaProperty* _tmp1202_; + ValaSymbolAccessibility _tmp1203_; + ValaSymbolAccessibility _tmp1204_; + _tmp1194_ = prop; + _tmp1195_ = vala_property_get_get_accessor (_tmp1194_); + _tmp1196_ = _tmp1195_; + if (_tmp1196_ == NULL) { + ValaSourceReference* _tmp1197_; + ValaSourceReference* _tmp1198_; + ValaProperty* _tmp1199_; + gchar* _tmp1200_; + gchar* _tmp1201_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp1194_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1195_ = _tmp1194_; - _tmp1196_ = prop; - _tmp1197_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1196_); + _tmp1197_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp1198_ = _tmp1197_; - vala_report_error (_tmp1195_, "Property `%s' is write-only", _tmp1198_); - _g_free0 (_tmp1198_); + _tmp1199_ = prop; + _tmp1200_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1199_); + _tmp1201_ = _tmp1200_; + vala_report_error (_tmp1198_, "Property `%s' is write-only", _tmp1201_); + _g_free0 (_tmp1201_); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } - _tmp1199_ = prop; - _tmp1200_ = vala_symbol_get_access ((ValaSymbol*) _tmp1199_); - _tmp1201_ = _tmp1200_; - if (_tmp1201_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) { - ValaProperty* _tmp1202_; - ValaPropertyAccessor* _tmp1203_; - ValaPropertyAccessor* _tmp1204_; - ValaSymbolAccessibility _tmp1205_; - ValaSymbolAccessibility _tmp1206_; - _tmp1202_ = prop; - _tmp1203_ = vala_property_get_get_accessor (_tmp1202_); - _tmp1204_ = _tmp1203_; - _tmp1205_ = vala_symbol_get_access ((ValaSymbol*) _tmp1204_); - _tmp1206_ = _tmp1205_; - access = _tmp1206_; - } else { - gboolean _tmp1207_ = FALSE; - ValaProperty* _tmp1208_; + _tmp1202_ = prop; + _tmp1203_ = vala_symbol_get_access ((ValaSymbol*) _tmp1202_); + _tmp1204_ = _tmp1203_; + if (_tmp1204_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) { + ValaProperty* _tmp1205_; + ValaPropertyAccessor* _tmp1206_; + ValaPropertyAccessor* _tmp1207_; + ValaSymbolAccessibility _tmp1208_; ValaSymbolAccessibility _tmp1209_; - ValaSymbolAccessibility _tmp1210_; - _tmp1208_ = prop; - _tmp1209_ = vala_symbol_get_access ((ValaSymbol*) _tmp1208_); - _tmp1210_ = _tmp1209_; - if (_tmp1210_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) { - ValaProperty* _tmp1211_; - ValaPropertyAccessor* _tmp1212_; - ValaPropertyAccessor* _tmp1213_; - ValaSymbolAccessibility _tmp1214_; - ValaSymbolAccessibility _tmp1215_; - _tmp1211_ = prop; - _tmp1212_ = vala_property_get_get_accessor (_tmp1211_); - _tmp1213_ = _tmp1212_; - _tmp1214_ = vala_symbol_get_access ((ValaSymbol*) _tmp1213_); - _tmp1215_ = _tmp1214_; - _tmp1207_ = _tmp1215_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC; + _tmp1205_ = prop; + _tmp1206_ = vala_property_get_get_accessor (_tmp1205_); + _tmp1207_ = _tmp1206_; + _tmp1208_ = vala_symbol_get_access ((ValaSymbol*) _tmp1207_); + _tmp1209_ = _tmp1208_; + access = _tmp1209_; + } else { + gboolean _tmp1210_ = FALSE; + ValaProperty* _tmp1211_; + ValaSymbolAccessibility _tmp1212_; + ValaSymbolAccessibility _tmp1213_; + _tmp1211_ = prop; + _tmp1212_ = vala_symbol_get_access ((ValaSymbol*) _tmp1211_); + _tmp1213_ = _tmp1212_; + if (_tmp1213_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) { + ValaProperty* _tmp1214_; + ValaPropertyAccessor* _tmp1215_; + ValaPropertyAccessor* _tmp1216_; + ValaSymbolAccessibility _tmp1217_; + ValaSymbolAccessibility _tmp1218_; + _tmp1214_ = prop; + _tmp1215_ = vala_property_get_get_accessor (_tmp1214_); + _tmp1216_ = _tmp1215_; + _tmp1217_ = vala_symbol_get_access ((ValaSymbol*) _tmp1216_); + _tmp1218_ = _tmp1217_; + _tmp1210_ = _tmp1218_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC; } else { - _tmp1207_ = FALSE; + _tmp1210_ = FALSE; } - if (_tmp1207_) { - ValaProperty* _tmp1216_; - ValaPropertyAccessor* _tmp1217_; - ValaPropertyAccessor* _tmp1218_; - ValaSymbolAccessibility _tmp1219_; - ValaSymbolAccessibility _tmp1220_; - _tmp1216_ = prop; - _tmp1217_ = vala_property_get_get_accessor (_tmp1216_); - _tmp1218_ = _tmp1217_; - _tmp1219_ = vala_symbol_get_access ((ValaSymbol*) _tmp1218_); - _tmp1220_ = _tmp1219_; - access = _tmp1220_; + if (_tmp1210_) { + ValaProperty* _tmp1219_; + ValaPropertyAccessor* _tmp1220_; + ValaPropertyAccessor* _tmp1221_; + ValaSymbolAccessibility _tmp1222_; + ValaSymbolAccessibility _tmp1223_; + _tmp1219_ = prop; + _tmp1220_ = vala_property_get_get_accessor (_tmp1219_); + _tmp1221_ = _tmp1220_; + _tmp1222_ = vala_symbol_get_access ((ValaSymbol*) _tmp1221_); + _tmp1223_ = _tmp1222_; + access = _tmp1223_; } } } - _tmp1221_ = prop; - _tmp1222_ = vala_property_get_binding (_tmp1221_); - _tmp1223_ = _tmp1222_; - instance = _tmp1223_ == VALA_MEMBER_BINDING_INSTANCE; _tmp1224_ = prop; - _tmp1225_ = vala_property_get_property_type (_tmp1224_); + _tmp1225_ = vala_property_get_binding (_tmp1224_); _tmp1226_ = _tmp1225_; - if (VALA_IS_GENERIC_TYPE (_tmp1226_)) { + instance = _tmp1226_ == VALA_MEMBER_BINDING_INSTANCE; + _tmp1227_ = prop; + _tmp1228_ = vala_property_get_property_type (_tmp1227_); + _tmp1229_ = _tmp1228_; + if (VALA_IS_GENERIC_TYPE (_tmp1229_)) { generics = TRUE; } } else { - ValaSymbol* _tmp1227_; - _tmp1227_ = member; - if (VALA_IS_SIGNAL (_tmp1227_)) { - ValaSymbol* _tmp1228_; - ValaSymbolAccessibility _tmp1229_; - ValaSymbolAccessibility _tmp1230_; + ValaSymbol* _tmp1230_; + _tmp1230_ = member; + if (VALA_IS_SIGNAL (_tmp1230_)) { + ValaSymbol* _tmp1231_; + ValaSymbolAccessibility _tmp1232_; + ValaSymbolAccessibility _tmp1233_; instance = TRUE; - _tmp1228_ = member; - _tmp1229_ = vala_symbol_get_access (_tmp1228_); - _tmp1230_ = _tmp1229_; - access = _tmp1230_; + _tmp1231_ = member; + _tmp1232_ = vala_symbol_get_access (_tmp1231_); + _tmp1233_ = _tmp1232_; + access = _tmp1233_; } else { - gboolean _tmp1231_ = FALSE; - gboolean _tmp1232_; - _tmp1232_ = self->priv->_creation_member; - if (!_tmp1232_) { - ValaSymbol* _tmp1233_; - _tmp1233_ = member; - _tmp1231_ = VALA_IS_ERROR_CODE (_tmp1233_); + gboolean _tmp1234_ = FALSE; + gboolean _tmp1235_; + _tmp1235_ = self->priv->_creation_member; + if (!_tmp1235_) { + ValaSymbol* _tmp1236_; + _tmp1236_ = member; + _tmp1234_ = VALA_IS_ERROR_CODE (_tmp1236_); } else { - _tmp1231_ = FALSE; + _tmp1234_ = FALSE; } - if (_tmp1231_) { - ValaSymbol* _tmp1234_; - ValaConstant* _tmp1235_; - ValaConstant* _tmp1236_; + if (_tmp1234_) { ValaSymbol* _tmp1237_; - ValaSymbol* _tmp1238_; - _tmp1234_ = member; - _tmp1235_ = vala_error_code_get_code (G_TYPE_CHECK_INSTANCE_CAST (_tmp1234_, VALA_TYPE_ERROR_CODE, ValaErrorCode)); - _tmp1236_ = _tmp1235_; - vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1236_); - _tmp1237_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1238_ = _tmp1237_; - member = _tmp1238_; + ValaConstant* _tmp1238_; + ValaConstant* _tmp1239_; + ValaSymbol* _tmp1240_; + ValaSymbol* _tmp1241_; + _tmp1237_ = member; + _tmp1238_ = vala_error_code_get_code (G_TYPE_CHECK_INSTANCE_CAST (_tmp1237_, VALA_TYPE_ERROR_CODE, ValaErrorCode)); + _tmp1239_ = _tmp1238_; + vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1239_); + _tmp1240_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1241_ = _tmp1240_; + member = _tmp1241_; } } } @@ -4341,132 +4347,132 @@ } parent = (ValaCodeNode*) self; while (TRUE) { - ValaCodeNode* _tmp1239_; - ValaSymbol* _tmp1240_; - ValaCodeNode* _tmp1241_; ValaCodeNode* _tmp1242_; - ValaCodeNode* _tmp1243_; - gboolean _tmp1244_ = FALSE; + ValaSymbol* _tmp1243_; + ValaCodeNode* _tmp1244_; ValaCodeNode* _tmp1245_; - _tmp1239_ = parent; - _tmp1240_ = member; - if (!(_tmp1239_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp1240_, VALA_TYPE_CODE_NODE, ValaCodeNode))) { + ValaCodeNode* _tmp1246_; + gboolean _tmp1247_ = FALSE; + ValaCodeNode* _tmp1248_; + _tmp1242_ = parent; + _tmp1243_ = member; + if (!(_tmp1242_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp1243_, VALA_TYPE_CODE_NODE, ValaCodeNode))) { break; } - _tmp1241_ = parent; - _tmp1242_ = vala_code_node_get_parent_node (_tmp1241_); - _tmp1243_ = _tmp1242_; - parent = _tmp1243_; - _tmp1245_ = parent; - if (_tmp1245_ == NULL) { - _tmp1244_ = TRUE; + _tmp1244_ = parent; + _tmp1245_ = vala_code_node_get_parent_node (_tmp1244_); + _tmp1246_ = _tmp1245_; + parent = _tmp1246_; + _tmp1248_ = parent; + if (_tmp1248_ == NULL) { + _tmp1247_ = TRUE; } else { - ValaCodeNode* _tmp1246_; - ValaSymbol* _tmp1247_; - _tmp1246_ = parent; - _tmp1247_ = member; - _tmp1244_ = _tmp1246_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1247_, VALA_TYPE_CODE_NODE, ValaCodeNode); + ValaCodeNode* _tmp1249_; + ValaSymbol* _tmp1250_; + _tmp1249_ = parent; + _tmp1250_ = member; + _tmp1247_ = _tmp1249_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1250_, VALA_TYPE_CODE_NODE, ValaCodeNode); } - if (_tmp1244_) { + if (_tmp1247_) { break; } } - _tmp1248_ = parent; - _tmp1249_ = member; - if (_tmp1248_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp1249_, VALA_TYPE_CODE_NODE, ValaCodeNode)) { - ValaSymbol* _tmp1250_; - _tmp1250_ = member; - vala_symbol_set_used (_tmp1250_, TRUE); - } - _tmp1251_ = member; - _tmp1252_ = vala_symbol_get_version (_tmp1251_); - _tmp1253_ = _tmp1252_; - _tmp1254_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1255_ = _tmp1254_; - vala_version_attribute_check (_tmp1253_, context, _tmp1255_); - _tmp1257_ = access; - if (_tmp1257_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) { - ValaSymbol* _tmp1258_; - ValaSymbol* _tmp1259_; - ValaSymbol* _tmp1260_; - _tmp1258_ = member; - _tmp1259_ = vala_symbol_get_parent_symbol (_tmp1258_); - _tmp1260_ = _tmp1259_; - _tmp1256_ = VALA_IS_TYPESYMBOL (_tmp1260_); - } else { - _tmp1256_ = FALSE; + _tmp1251_ = parent; + _tmp1252_ = member; + if (_tmp1251_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp1252_, VALA_TYPE_CODE_NODE, ValaCodeNode)) { + ValaSymbol* _tmp1253_; + _tmp1253_ = member; + vala_symbol_set_used (_tmp1253_, TRUE); } - if (_tmp1256_) { - ValaTypeSymbol* target_type = NULL; + _tmp1254_ = member; + _tmp1255_ = vala_symbol_get_version (_tmp1254_); + _tmp1256_ = _tmp1255_; + _tmp1257_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp1258_ = _tmp1257_; + vala_version_attribute_check (_tmp1256_, context, _tmp1258_); + _tmp1260_ = access; + if (_tmp1260_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) { ValaSymbol* _tmp1261_; ValaSymbol* _tmp1262_; ValaSymbol* _tmp1263_; - gboolean in_subtype = FALSE; _tmp1261_ = member; _tmp1262_ = vala_symbol_get_parent_symbol (_tmp1261_); _tmp1263_ = _tmp1262_; - target_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp1263_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol); + _tmp1259_ = VALA_IS_TYPESYMBOL (_tmp1263_); + } else { + _tmp1259_ = FALSE; + } + if (_tmp1259_) { + ValaTypeSymbol* target_type = NULL; + ValaSymbol* _tmp1264_; + ValaSymbol* _tmp1265_; + ValaSymbol* _tmp1266_; + gboolean in_subtype = FALSE; + _tmp1264_ = member; + _tmp1265_ = vala_symbol_get_parent_symbol (_tmp1264_); + _tmp1266_ = _tmp1265_; + target_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp1266_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol); in_subtype = FALSE; { ValaSymbol* this_symbol = NULL; - ValaSemanticAnalyzer* _tmp1264_; - ValaSemanticAnalyzer* _tmp1265_; - ValaSymbol* _tmp1266_; - ValaSymbol* _tmp1267_; - ValaSymbol* _tmp1268_; - _tmp1264_ = vala_code_context_get_analyzer (context); - _tmp1265_ = _tmp1264_; - _tmp1266_ = vala_semantic_analyzer_get_current_symbol (_tmp1265_); - _tmp1267_ = _tmp1266_; - _tmp1268_ = _vala_code_node_ref0 (_tmp1267_); - this_symbol = _tmp1268_; + ValaSemanticAnalyzer* _tmp1267_; + ValaSemanticAnalyzer* _tmp1268_; + ValaSymbol* _tmp1269_; + ValaSymbol* _tmp1270_; + ValaSymbol* _tmp1271_; + _tmp1267_ = vala_code_context_get_analyzer (context); + _tmp1268_ = _tmp1267_; + _tmp1269_ = vala_semantic_analyzer_get_current_symbol (_tmp1268_); + _tmp1270_ = _tmp1269_; + _tmp1271_ = _vala_code_node_ref0 (_tmp1270_); + this_symbol = _tmp1271_; { - gboolean _tmp1269_ = FALSE; - _tmp1269_ = TRUE; + gboolean _tmp1272_ = FALSE; + _tmp1272_ = TRUE; while (TRUE) { - ValaSymbol* _tmp1274_; - ValaSymbol* _tmp1275_; - ValaTypeSymbol* _tmp1276_; - ValaClass* cl = NULL; ValaSymbol* _tmp1277_; - gboolean _tmp1278_ = FALSE; - ValaClass* _tmp1279_; - if (!_tmp1269_) { - ValaSymbol* _tmp1270_; - ValaSymbol* _tmp1271_; - ValaSymbol* _tmp1272_; + ValaSymbol* _tmp1278_; + ValaTypeSymbol* _tmp1279_; + ValaClass* cl = NULL; + ValaSymbol* _tmp1280_; + gboolean _tmp1281_ = FALSE; + ValaClass* _tmp1282_; + if (!_tmp1272_) { ValaSymbol* _tmp1273_; - _tmp1270_ = this_symbol; - _tmp1271_ = vala_symbol_get_parent_symbol (_tmp1270_); - _tmp1272_ = _tmp1271_; - _tmp1273_ = _vala_code_node_ref0 (_tmp1272_); + ValaSymbol* _tmp1274_; + ValaSymbol* _tmp1275_; + ValaSymbol* _tmp1276_; + _tmp1273_ = this_symbol; + _tmp1274_ = vala_symbol_get_parent_symbol (_tmp1273_); + _tmp1275_ = _tmp1274_; + _tmp1276_ = _vala_code_node_ref0 (_tmp1275_); _vala_code_node_unref0 (this_symbol); - this_symbol = _tmp1273_; + this_symbol = _tmp1276_; } - _tmp1269_ = FALSE; - _tmp1274_ = this_symbol; - if (!(_tmp1274_ != NULL)) { + _tmp1272_ = FALSE; + _tmp1277_ = this_symbol; + if (!(_tmp1277_ != NULL)) { break; } - _tmp1275_ = this_symbol; - _tmp1276_ = target_type; - if (_tmp1275_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1276_, VALA_TYPE_SYMBOL, ValaSymbol)) { + _tmp1278_ = this_symbol; + _tmp1279_ = target_type; + if (_tmp1278_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1279_, VALA_TYPE_SYMBOL, ValaSymbol)) { in_subtype = TRUE; break; } - _tmp1277_ = this_symbol; - cl = VALA_IS_CLASS (_tmp1277_) ? ((ValaClass*) _tmp1277_) : NULL; - _tmp1279_ = cl; - if (_tmp1279_ != NULL) { - ValaClass* _tmp1280_; - ValaTypeSymbol* _tmp1281_; - _tmp1280_ = cl; - _tmp1281_ = target_type; - _tmp1278_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp1280_, _tmp1281_); + _tmp1280_ = this_symbol; + cl = VALA_IS_CLASS (_tmp1280_) ? ((ValaClass*) _tmp1280_) : NULL; + _tmp1282_ = cl; + if (_tmp1282_ != NULL) { + ValaClass* _tmp1283_; + ValaTypeSymbol* _tmp1284_; + _tmp1283_ = cl; + _tmp1284_ = target_type; + _tmp1281_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp1283_, _tmp1284_); } else { - _tmp1278_ = FALSE; + _tmp1281_ = FALSE; } - if (_tmp1278_) { + if (_tmp1281_) { in_subtype = TRUE; break; } @@ -4475,77 +4481,77 @@ _vala_code_node_unref0 (this_symbol); } if (!in_subtype) { - ValaSourceReference* _tmp1282_; - ValaSourceReference* _tmp1283_; - ValaSymbol* _tmp1284_; - gchar* _tmp1285_; - gchar* _tmp1286_; + ValaSourceReference* _tmp1285_; + ValaSourceReference* _tmp1286_; + ValaSymbol* _tmp1287_; + gchar* _tmp1288_; + gchar* _tmp1289_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp1282_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1283_ = _tmp1282_; - _tmp1284_ = member; - _tmp1285_ = vala_symbol_get_full_name (_tmp1284_); + _tmp1285_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp1286_ = _tmp1285_; - vala_report_error (_tmp1283_, "Access to protected member `%s' denied", _tmp1286_); - _g_free0 (_tmp1286_); + _tmp1287_ = member; + _tmp1288_ = vala_symbol_get_full_name (_tmp1287_); + _tmp1289_ = _tmp1288_; + vala_report_error (_tmp1286_, "Access to protected member `%s' denied", _tmp1289_); + _g_free0 (_tmp1289_); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } } else { - ValaSymbolAccessibility _tmp1287_; - _tmp1287_ = access; - if (_tmp1287_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) { + ValaSymbolAccessibility _tmp1290_; + _tmp1290_ = access; + if (_tmp1290_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) { ValaSymbol* target_type = NULL; - ValaSymbol* _tmp1288_; - ValaSymbol* _tmp1289_; - ValaSymbol* _tmp1290_; + ValaSymbol* _tmp1291_; + ValaSymbol* _tmp1292_; + ValaSymbol* _tmp1293_; gboolean in_target_type = FALSE; - _tmp1288_ = member; - _tmp1289_ = vala_symbol_get_parent_symbol (_tmp1288_); - _tmp1290_ = _tmp1289_; - target_type = _tmp1290_; + _tmp1291_ = member; + _tmp1292_ = vala_symbol_get_parent_symbol (_tmp1291_); + _tmp1293_ = _tmp1292_; + target_type = _tmp1293_; in_target_type = FALSE; { ValaSymbol* this_symbol = NULL; - ValaSemanticAnalyzer* _tmp1291_; - ValaSemanticAnalyzer* _tmp1292_; - ValaSymbol* _tmp1293_; - ValaSymbol* _tmp1294_; - ValaSymbol* _tmp1295_; - _tmp1291_ = vala_code_context_get_analyzer (context); - _tmp1292_ = _tmp1291_; - _tmp1293_ = vala_semantic_analyzer_get_current_symbol (_tmp1292_); - _tmp1294_ = _tmp1293_; - _tmp1295_ = _vala_code_node_ref0 (_tmp1294_); - this_symbol = _tmp1295_; + ValaSemanticAnalyzer* _tmp1294_; + ValaSemanticAnalyzer* _tmp1295_; + ValaSymbol* _tmp1296_; + ValaSymbol* _tmp1297_; + ValaSymbol* _tmp1298_; + _tmp1294_ = vala_code_context_get_analyzer (context); + _tmp1295_ = _tmp1294_; + _tmp1296_ = vala_semantic_analyzer_get_current_symbol (_tmp1295_); + _tmp1297_ = _tmp1296_; + _tmp1298_ = _vala_code_node_ref0 (_tmp1297_); + this_symbol = _tmp1298_; { - gboolean _tmp1296_ = FALSE; - _tmp1296_ = TRUE; + gboolean _tmp1299_ = FALSE; + _tmp1299_ = TRUE; while (TRUE) { - ValaSymbol* _tmp1301_; - ValaSymbol* _tmp1302_; - ValaSymbol* _tmp1303_; - if (!_tmp1296_) { - ValaSymbol* _tmp1297_; - ValaSymbol* _tmp1298_; - ValaSymbol* _tmp1299_; + ValaSymbol* _tmp1304_; + ValaSymbol* _tmp1305_; + ValaSymbol* _tmp1306_; + if (!_tmp1299_) { ValaSymbol* _tmp1300_; - _tmp1297_ = this_symbol; - _tmp1298_ = vala_symbol_get_parent_symbol (_tmp1297_); - _tmp1299_ = _tmp1298_; - _tmp1300_ = _vala_code_node_ref0 (_tmp1299_); + ValaSymbol* _tmp1301_; + ValaSymbol* _tmp1302_; + ValaSymbol* _tmp1303_; + _tmp1300_ = this_symbol; + _tmp1301_ = vala_symbol_get_parent_symbol (_tmp1300_); + _tmp1302_ = _tmp1301_; + _tmp1303_ = _vala_code_node_ref0 (_tmp1302_); _vala_code_node_unref0 (this_symbol); - this_symbol = _tmp1300_; + this_symbol = _tmp1303_; } - _tmp1296_ = FALSE; - _tmp1301_ = this_symbol; - if (!(_tmp1301_ != NULL)) { + _tmp1299_ = FALSE; + _tmp1304_ = this_symbol; + if (!(_tmp1304_ != NULL)) { break; } - _tmp1302_ = target_type; - _tmp1303_ = this_symbol; - if (_tmp1302_ == _tmp1303_) { + _tmp1305_ = target_type; + _tmp1306_ = this_symbol; + if (_tmp1305_ == _tmp1306_) { in_target_type = TRUE; break; } @@ -4554,19 +4560,19 @@ _vala_code_node_unref0 (this_symbol); } if (!in_target_type) { - ValaSourceReference* _tmp1304_; - ValaSourceReference* _tmp1305_; - ValaSymbol* _tmp1306_; - gchar* _tmp1307_; - gchar* _tmp1308_; + ValaSourceReference* _tmp1307_; + ValaSourceReference* _tmp1308_; + ValaSymbol* _tmp1309_; + gchar* _tmp1310_; + gchar* _tmp1311_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp1304_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1305_ = _tmp1304_; - _tmp1306_ = member; - _tmp1307_ = vala_symbol_get_full_name (_tmp1306_); + _tmp1307_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp1308_ = _tmp1307_; - vala_report_error (_tmp1305_, "Access to private member `%s' denied", _tmp1308_); - _g_free0 (_tmp1308_); + _tmp1309_ = member; + _tmp1310_ = vala_symbol_get_full_name (_tmp1309_); + _tmp1311_ = _tmp1310_; + vala_report_error (_tmp1308_, "Access to private member `%s' denied", _tmp1311_); + _g_free0 (_tmp1311_); result = FALSE; _vala_iterable_unref0 (visited_types); return result; @@ -4574,905 +4580,945 @@ } } if (generics) { - ValaExpression* _tmp1310_; - ValaExpression* _tmp1311_; - _tmp1310_ = vala_member_access_get_inner (self); - _tmp1311_ = _tmp1310_; - _tmp1309_ = _tmp1311_ != NULL; + ValaExpression* _tmp1313_; + ValaExpression* _tmp1314_; + _tmp1313_ = vala_member_access_get_inner (self); + _tmp1314_ = _tmp1313_; + _tmp1312_ = _tmp1314_ != NULL; } else { - _tmp1309_ = FALSE; + _tmp1312_ = FALSE; } - if (_tmp1309_) { + if (_tmp1312_) { ValaDataType* instance_type = NULL; - ValaExpression* _tmp1312_; - ValaExpression* _tmp1313_; - ValaDataType* _tmp1314_; - ValaDataType* _tmp1315_; - ValaPointerType* pointer_type = NULL; + ValaExpression* _tmp1315_; ValaExpression* _tmp1316_; - ValaExpression* _tmp1317_; + ValaDataType* _tmp1317_; ValaDataType* _tmp1318_; - ValaDataType* _tmp1319_; - ValaPointerType* _tmp1320_; + ValaPointerType* pointer_type = NULL; + ValaExpression* _tmp1319_; + ValaExpression* _tmp1320_; + ValaDataType* _tmp1321_; + ValaDataType* _tmp1322_; + ValaPointerType* _tmp1323_; ValaObjectType* object_type = NULL; - ValaDataType* _tmp1324_; - gboolean _tmp1325_ = FALSE; - gboolean _tmp1326_ = FALSE; - ValaObjectType* _tmp1327_; - _tmp1312_ = vala_member_access_get_inner (self); - _tmp1313_ = _tmp1312_; - _tmp1314_ = vala_expression_get_value_type (_tmp1313_); - _tmp1315_ = _tmp1314_; - instance_type = _tmp1315_; - _tmp1316_ = vala_member_access_get_inner (self); - _tmp1317_ = _tmp1316_; - _tmp1318_ = vala_expression_get_value_type (_tmp1317_); - _tmp1319_ = _tmp1318_; - pointer_type = VALA_IS_POINTER_TYPE (_tmp1319_) ? ((ValaPointerType*) _tmp1319_) : NULL; - _tmp1320_ = pointer_type; - if (_tmp1320_ != NULL) { - ValaPointerType* _tmp1321_; - ValaDataType* _tmp1322_; - ValaDataType* _tmp1323_; - _tmp1321_ = pointer_type; - _tmp1322_ = vala_pointer_type_get_base_type (_tmp1321_); - _tmp1323_ = _tmp1322_; - instance_type = _tmp1323_; - } - _tmp1324_ = instance_type; - object_type = VALA_IS_OBJECT_TYPE (_tmp1324_) ? ((ValaObjectType*) _tmp1324_) : NULL; - _tmp1327_ = object_type; - if (_tmp1327_ != NULL) { - ValaObjectType* _tmp1328_; - ValaObjectTypeSymbol* _tmp1329_; - ValaObjectTypeSymbol* _tmp1330_; - _tmp1328_ = object_type; - _tmp1329_ = vala_object_type_get_object_type_symbol (_tmp1328_); - _tmp1330_ = _tmp1329_; - _tmp1326_ = vala_object_type_symbol_has_type_parameters (_tmp1330_); + ValaDataType* _tmp1327_; + gboolean _tmp1328_ = FALSE; + gboolean _tmp1329_ = FALSE; + ValaObjectType* _tmp1330_; + _tmp1315_ = vala_member_access_get_inner (self); + _tmp1316_ = _tmp1315_; + _tmp1317_ = vala_expression_get_value_type (_tmp1316_); + _tmp1318_ = _tmp1317_; + instance_type = _tmp1318_; + _tmp1319_ = vala_member_access_get_inner (self); + _tmp1320_ = _tmp1319_; + _tmp1321_ = vala_expression_get_value_type (_tmp1320_); + _tmp1322_ = _tmp1321_; + pointer_type = VALA_IS_POINTER_TYPE (_tmp1322_) ? ((ValaPointerType*) _tmp1322_) : NULL; + _tmp1323_ = pointer_type; + if (_tmp1323_ != NULL) { + ValaPointerType* _tmp1324_; + ValaDataType* _tmp1325_; + ValaDataType* _tmp1326_; + _tmp1324_ = pointer_type; + _tmp1325_ = vala_pointer_type_get_base_type (_tmp1324_); + _tmp1326_ = _tmp1325_; + instance_type = _tmp1326_; + } + _tmp1327_ = instance_type; + object_type = VALA_IS_OBJECT_TYPE (_tmp1327_) ? ((ValaObjectType*) _tmp1327_) : NULL; + _tmp1330_ = object_type; + if (_tmp1330_ != NULL) { + ValaObjectType* _tmp1331_; + ValaObjectTypeSymbol* _tmp1332_; + ValaObjectTypeSymbol* _tmp1333_; + _tmp1331_ = object_type; + _tmp1332_ = vala_object_type_get_object_type_symbol (_tmp1331_); + _tmp1333_ = _tmp1332_; + _tmp1329_ = vala_object_type_symbol_has_type_parameters (_tmp1333_); } else { - _tmp1326_ = FALSE; + _tmp1329_ = FALSE; } - if (_tmp1326_) { - ValaDataType* _tmp1331_; - _tmp1331_ = instance_type; - _tmp1325_ = !vala_data_type_has_type_arguments (_tmp1331_); + if (_tmp1329_) { + ValaDataType* _tmp1334_; + _tmp1334_ = instance_type; + _tmp1328_ = !vala_data_type_has_type_arguments (_tmp1334_); } else { - _tmp1325_ = FALSE; + _tmp1328_ = FALSE; } - if (_tmp1325_) { - ValaExpression* _tmp1332_; - ValaExpression* _tmp1333_; - ValaSourceReference* _tmp1334_; - ValaSourceReference* _tmp1335_; + if (_tmp1328_) { + ValaExpression* _tmp1335_; + ValaExpression* _tmp1336_; + ValaSourceReference* _tmp1337_; + ValaSourceReference* _tmp1338_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp1332_ = vala_member_access_get_inner (self); - _tmp1333_ = _tmp1332_; - _tmp1334_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1333_); - _tmp1335_ = _tmp1334_; - vala_report_error (_tmp1335_, "missing generic type arguments"); + _tmp1335_ = vala_member_access_get_inner (self); + _tmp1336_ = _tmp1335_; + _tmp1337_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1336_); + _tmp1338_ = _tmp1337_; + vala_report_error (_tmp1338_, "missing generic type arguments"); result = FALSE; _vala_iterable_unref0 (visited_types); return result; } } if (instance) { - _tmp1337_ = !may_access_instance_members; + _tmp1340_ = !may_access_instance_members; } else { - _tmp1337_ = FALSE; + _tmp1340_ = FALSE; } - if (_tmp1337_) { - _tmp1336_ = TRUE; + if (_tmp1340_) { + _tmp1339_ = TRUE; } else { - gboolean _tmp1338_ = FALSE; + gboolean _tmp1341_ = FALSE; if (klass) { - _tmp1338_ = !may_access_klass_members; + _tmp1341_ = !may_access_klass_members; } else { - _tmp1338_ = FALSE; + _tmp1341_ = FALSE; } - _tmp1336_ = _tmp1338_; + _tmp1339_ = _tmp1341_; } - if (_tmp1336_) { - ValaSymbol* _tmp1339_; - ValaSymbol* _tmp1340_; - ValaDataType* _tmp1363_; - ValaDataType* _tmp1364_; + if (_tmp1339_) { + ValaSymbol* _tmp1342_; + ValaSymbol* _tmp1343_; + ValaDataType* _tmp1378_; + ValaDataType* _tmp1379_; vala_member_access_set_prototype_access (self, TRUE); - _tmp1339_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1340_ = _tmp1339_; - if (VALA_IS_METHOD (_tmp1340_)) { - ValaSemanticAnalyzer* _tmp1341_; - ValaSemanticAnalyzer* _tmp1342_; - ValaSymbol* _tmp1343_; - ValaSymbol* _tmp1344_; - gboolean _tmp1345_; - gboolean _tmp1346_; - ValaDataType* _tmp1347_; - ValaDataType* _tmp1348_; - _tmp1341_ = vala_code_context_get_analyzer (context); - _tmp1342_ = _tmp1341_; - _tmp1343_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1344_ = _tmp1343_; - _tmp1345_ = vala_expression_get_lvalue ((ValaExpression*) self); - _tmp1346_ = _tmp1345_; - _tmp1347_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp1342_, _tmp1344_, _tmp1346_); - _tmp1348_ = _tmp1347_; - vala_expression_set_value_type ((ValaExpression*) self, _tmp1348_); - _vala_code_node_unref0 (_tmp1348_); + _tmp1342_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1343_ = _tmp1342_; + if (VALA_IS_METHOD (_tmp1343_)) { + ValaSemanticAnalyzer* _tmp1344_; + ValaSemanticAnalyzer* _tmp1345_; + ValaSymbol* _tmp1346_; + ValaSymbol* _tmp1347_; + gboolean _tmp1348_; + gboolean _tmp1349_; + ValaDataType* _tmp1350_; + ValaDataType* _tmp1351_; + ValaDataType* _tmp1352_; + ValaDataType* _tmp1353_; + ValaSourceReference* _tmp1354_; + ValaSourceReference* _tmp1355_; + _tmp1344_ = vala_code_context_get_analyzer (context); + _tmp1345_ = _tmp1344_; + _tmp1346_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1347_ = _tmp1346_; + _tmp1348_ = vala_expression_get_lvalue ((ValaExpression*) self); + _tmp1349_ = _tmp1348_; + _tmp1350_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp1345_, _tmp1347_, _tmp1349_); + _tmp1351_ = _tmp1350_; + vala_expression_set_value_type ((ValaExpression*) self, _tmp1351_); + _vala_code_node_unref0 (_tmp1351_); + _tmp1352_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp1353_ = _tmp1352_; + _tmp1354_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp1355_ = _tmp1354_; + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp1353_, _tmp1355_); } else { - ValaSymbol* _tmp1349_; - ValaSymbol* _tmp1350_; - _tmp1349_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1350_ = _tmp1349_; - if (VALA_IS_FIELD (_tmp1350_)) { - ValaSymbol* _tmp1351_; - ValaSymbol* _tmp1352_; - ValaFieldPrototype* _tmp1353_; - ValaFieldPrototype* _tmp1354_; - _tmp1351_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1352_ = _tmp1351_; - _tmp1353_ = vala_field_prototype_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1352_, VALA_TYPE_FIELD, ValaField)); - _tmp1354_ = _tmp1353_; - vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1354_); - _vala_code_node_unref0 (_tmp1354_); + ValaSymbol* _tmp1356_; + ValaSymbol* _tmp1357_; + _tmp1356_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1357_ = _tmp1356_; + if (VALA_IS_FIELD (_tmp1357_)) { + ValaSymbol* _tmp1358_; + ValaSymbol* _tmp1359_; + ValaFieldPrototype* _tmp1360_; + ValaFieldPrototype* _tmp1361_; + ValaDataType* _tmp1362_; + ValaDataType* _tmp1363_; + ValaSourceReference* _tmp1364_; + ValaSourceReference* _tmp1365_; + _tmp1358_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1359_ = _tmp1358_; + _tmp1360_ = vala_field_prototype_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1359_, VALA_TYPE_FIELD, ValaField)); + _tmp1361_ = _tmp1360_; + vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1361_); + _vala_code_node_unref0 (_tmp1361_); + _tmp1362_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp1363_ = _tmp1362_; + _tmp1364_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp1365_ = _tmp1364_; + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp1363_, _tmp1365_); } else { - ValaSymbol* _tmp1355_; - ValaSymbol* _tmp1356_; - _tmp1355_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1356_ = _tmp1355_; - if (VALA_IS_PROPERTY (_tmp1356_)) { - ValaSymbol* _tmp1357_; - ValaSymbol* _tmp1358_; - ValaPropertyPrototype* _tmp1359_; - ValaPropertyPrototype* _tmp1360_; - _tmp1357_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1358_ = _tmp1357_; - _tmp1359_ = vala_property_prototype_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1358_, VALA_TYPE_PROPERTY, ValaProperty)); - _tmp1360_ = _tmp1359_; - vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1360_); - _vala_code_node_unref0 (_tmp1360_); + ValaSymbol* _tmp1366_; + ValaSymbol* _tmp1367_; + _tmp1366_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1367_ = _tmp1366_; + if (VALA_IS_PROPERTY (_tmp1367_)) { + ValaSymbol* _tmp1368_; + ValaSymbol* _tmp1369_; + ValaPropertyPrototype* _tmp1370_; + ValaPropertyPrototype* _tmp1371_; + ValaDataType* _tmp1372_; + ValaDataType* _tmp1373_; + ValaSourceReference* _tmp1374_; + ValaSourceReference* _tmp1375_; + _tmp1368_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1369_ = _tmp1368_; + _tmp1370_ = vala_property_prototype_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1369_, VALA_TYPE_PROPERTY, ValaProperty)); + _tmp1371_ = _tmp1370_; + vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1371_); + _vala_code_node_unref0 (_tmp1371_); + _tmp1372_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp1373_ = _tmp1372_; + _tmp1374_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp1375_ = _tmp1374_; + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp1373_, _tmp1375_); } else { - ValaInvalidType* _tmp1361_; - ValaInvalidType* _tmp1362_; + ValaInvalidType* _tmp1376_; + ValaInvalidType* _tmp1377_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp1361_ = vala_invalid_type_new (); - _tmp1362_ = _tmp1361_; - vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1362_); - _vala_code_node_unref0 (_tmp1362_); + _tmp1376_ = vala_invalid_type_new (); + _tmp1377_ = _tmp1376_; + vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1377_); + _vala_code_node_unref0 (_tmp1377_); } } } - _tmp1363_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp1364_ = _tmp1363_; - if (_tmp1364_ != NULL) { - ValaDataType* _tmp1365_; - ValaDataType* _tmp1366_; - ValaDataType* _tmp1367_; - ValaDataType* _tmp1368_; - gboolean _tmp1369_; - gboolean _tmp1370_; - _tmp1365_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp1366_ = _tmp1365_; - _tmp1367_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp1368_ = _tmp1367_; - _tmp1369_ = vala_data_type_get_value_owned (_tmp1368_); - _tmp1370_ = _tmp1369_; - vala_data_type_set_value_owned (_tmp1366_, _tmp1370_); + _tmp1378_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp1379_ = _tmp1378_; + if (_tmp1379_ != NULL) { + ValaDataType* _tmp1380_; + ValaDataType* _tmp1381_; + ValaDataType* _tmp1382_; + ValaDataType* _tmp1383_; + gboolean _tmp1384_; + gboolean _tmp1385_; + _tmp1380_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp1381_ = _tmp1380_; + _tmp1382_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp1383_ = _tmp1382_; + _tmp1384_ = vala_data_type_get_value_owned (_tmp1383_); + _tmp1385_ = _tmp1384_; + vala_data_type_set_value_owned (_tmp1381_, _tmp1385_); } } else { - gboolean _tmp1371_ = FALSE; - gboolean _tmp1392_ = FALSE; - gboolean _tmp1393_ = FALSE; - gboolean _tmp1394_ = FALSE; - gboolean _tmp1395_ = FALSE; - gboolean _tmp1436_ = FALSE; - gboolean _tmp1437_ = FALSE; - gboolean _tmp1438_ = FALSE; - gboolean _tmp1439_ = FALSE; - gboolean _tmp1440_ = FALSE; - gboolean _tmp1441_; - gboolean _tmp1442_; + gboolean _tmp1386_ = FALSE; + gboolean _tmp1407_ = FALSE; + gboolean _tmp1408_ = FALSE; + gboolean _tmp1409_ = FALSE; + gboolean _tmp1410_ = FALSE; + gboolean _tmp1451_ = FALSE; + gboolean _tmp1452_ = FALSE; + gboolean _tmp1453_ = FALSE; + gboolean _tmp1454_ = FALSE; + gboolean _tmp1455_ = FALSE; + gboolean _tmp1456_; + gboolean _tmp1457_; ValaMethod* m = NULL; - ValaSymbol* _tmp1467_; - ValaSymbol* _tmp1468_; + ValaSymbol* _tmp1482_; + ValaSymbol* _tmp1483_; ValaMemberAccess* inner_ma = NULL; - ValaExpression* _tmp1469_; - ValaExpression* _tmp1470_; - gboolean _tmp1471_ = FALSE; - gboolean _tmp1472_ = FALSE; - gboolean _tmp1473_ = FALSE; - gboolean _tmp1474_ = FALSE; - gboolean _tmp1475_ = FALSE; - ValaMethod* _tmp1476_; - ValaSemanticAnalyzer* _tmp1514_; - ValaSemanticAnalyzer* _tmp1515_; - ValaSymbol* _tmp1516_; - ValaSymbol* _tmp1517_; - gboolean _tmp1518_; - gboolean _tmp1519_; - ValaDataType* _tmp1520_; - ValaDataType* _tmp1521_; - gboolean _tmp1522_ = FALSE; - ValaExpression* _tmp1523_; - ValaExpression* _tmp1524_; + ValaExpression* _tmp1484_; + ValaExpression* _tmp1485_; + gboolean _tmp1486_ = FALSE; + gboolean _tmp1487_ = FALSE; + gboolean _tmp1488_ = FALSE; + gboolean _tmp1489_ = FALSE; + gboolean _tmp1490_ = FALSE; + ValaMethod* _tmp1491_; + ValaSemanticAnalyzer* _tmp1535_; + ValaSemanticAnalyzer* _tmp1536_; ValaSymbol* _tmp1537_; ValaSymbol* _tmp1538_; - gboolean _tmp1612_ = FALSE; - gboolean _tmp1613_ = FALSE; - ValaExpression* _tmp1614_; - ValaExpression* _tmp1615_; + gboolean _tmp1539_; + gboolean _tmp1540_; + ValaDataType* _tmp1541_; + ValaDataType* _tmp1542_; + gboolean _tmp1543_ = FALSE; + ValaExpression* _tmp1544_; + ValaExpression* _tmp1545_; + ValaSymbol* _tmp1558_; + ValaSymbol* _tmp1559_; + gboolean _tmp1633_ = FALSE; + gboolean _tmp1634_ = FALSE; + ValaExpression* _tmp1635_; + ValaExpression* _tmp1636_; if (instance) { - ValaExpression* _tmp1372_; - ValaExpression* _tmp1373_; - _tmp1372_ = vala_member_access_get_inner (self); - _tmp1373_ = _tmp1372_; - _tmp1371_ = _tmp1373_ == NULL; + ValaExpression* _tmp1387_; + ValaExpression* _tmp1388_; + _tmp1387_ = vala_member_access_get_inner (self); + _tmp1388_ = _tmp1387_; + _tmp1386_ = _tmp1388_ == NULL; } else { - _tmp1371_ = FALSE; + _tmp1386_ = FALSE; } - if (_tmp1371_) { - ValaSourceReference* _tmp1374_; - ValaSourceReference* _tmp1375_; - ValaMemberAccess* _tmp1376_; - ValaMemberAccess* _tmp1377_; - ValaExpression* _tmp1378_; - ValaExpression* _tmp1379_; - ValaParameter* _tmp1380_; - ValaDataType* _tmp1381_; - ValaDataType* _tmp1382_; - ValaDataType* _tmp1383_; - ValaDataType* _tmp1384_; - ValaExpression* _tmp1385_; - ValaExpression* _tmp1386_; - ValaDataType* _tmp1387_; - ValaDataType* _tmp1388_; - ValaExpression* _tmp1389_; - ValaExpression* _tmp1390_; - ValaParameter* _tmp1391_; - _tmp1374_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1375_ = _tmp1374_; - _tmp1376_ = vala_member_access_new (NULL, "this", _tmp1375_); - _tmp1377_ = _tmp1376_; - vala_member_access_set_inner (self, (ValaExpression*) _tmp1377_); - _vala_code_node_unref0 (_tmp1377_); - _tmp1378_ = vala_member_access_get_inner (self); - _tmp1379_ = _tmp1378_; - _tmp1380_ = this_parameter; - _tmp1381_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1380_); - _tmp1382_ = _tmp1381_; - _tmp1383_ = vala_data_type_copy (_tmp1382_); - _tmp1384_ = _tmp1383_; - vala_expression_set_value_type (_tmp1379_, _tmp1384_); - _vala_code_node_unref0 (_tmp1384_); - _tmp1385_ = vala_member_access_get_inner (self); - _tmp1386_ = _tmp1385_; - _tmp1387_ = vala_expression_get_value_type (_tmp1386_); - _tmp1388_ = _tmp1387_; - vala_data_type_set_value_owned (_tmp1388_, FALSE); - _tmp1389_ = vala_member_access_get_inner (self); + if (_tmp1386_) { + ValaSourceReference* _tmp1389_; + ValaSourceReference* _tmp1390_; + ValaMemberAccess* _tmp1391_; + ValaMemberAccess* _tmp1392_; + ValaExpression* _tmp1393_; + ValaExpression* _tmp1394_; + ValaParameter* _tmp1395_; + ValaDataType* _tmp1396_; + ValaDataType* _tmp1397_; + ValaDataType* _tmp1398_; + ValaDataType* _tmp1399_; + ValaExpression* _tmp1400_; + ValaExpression* _tmp1401_; + ValaDataType* _tmp1402_; + ValaDataType* _tmp1403_; + ValaExpression* _tmp1404_; + ValaExpression* _tmp1405_; + ValaParameter* _tmp1406_; + _tmp1389_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp1390_ = _tmp1389_; - _tmp1391_ = this_parameter; - vala_expression_set_symbol_reference (_tmp1390_, (ValaSymbol*) _tmp1391_); + _tmp1391_ = vala_member_access_new (NULL, "this", _tmp1390_); + _tmp1392_ = _tmp1391_; + vala_member_access_set_inner (self, (ValaExpression*) _tmp1392_); + _vala_code_node_unref0 (_tmp1392_); + _tmp1393_ = vala_member_access_get_inner (self); + _tmp1394_ = _tmp1393_; + _tmp1395_ = this_parameter; + _tmp1396_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1395_); + _tmp1397_ = _tmp1396_; + _tmp1398_ = vala_data_type_copy (_tmp1397_); + _tmp1399_ = _tmp1398_; + vala_expression_set_value_type (_tmp1394_, _tmp1399_); + _vala_code_node_unref0 (_tmp1399_); + _tmp1400_ = vala_member_access_get_inner (self); + _tmp1401_ = _tmp1400_; + _tmp1402_ = vala_expression_get_value_type (_tmp1401_); + _tmp1403_ = _tmp1402_; + vala_data_type_set_value_owned (_tmp1403_, FALSE); + _tmp1404_ = vala_member_access_get_inner (self); + _tmp1405_ = _tmp1404_; + _tmp1406_ = this_parameter; + vala_expression_set_symbol_reference (_tmp1405_, (ValaSymbol*) _tmp1406_); } else { vala_member_access_check_lvalue_access (self); } if (!instance) { - _tmp1395_ = !klass; + _tmp1410_ = !klass; } else { - _tmp1395_ = FALSE; + _tmp1410_ = FALSE; } - if (_tmp1395_) { - ValaSymbol* _tmp1396_; - ValaSymbol* _tmp1397_; - _tmp1396_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1397_ = _tmp1396_; - _tmp1394_ = !VALA_IS_CREATION_METHOD (_tmp1397_); + if (_tmp1410_) { + ValaSymbol* _tmp1411_; + ValaSymbol* _tmp1412_; + _tmp1411_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1412_ = _tmp1411_; + _tmp1409_ = !VALA_IS_CREATION_METHOD (_tmp1412_); } else { - _tmp1394_ = FALSE; + _tmp1409_ = FALSE; } - if (_tmp1394_) { - _tmp1393_ = may_access_instance_members; + if (_tmp1409_) { + _tmp1408_ = may_access_instance_members; } else { - _tmp1393_ = FALSE; + _tmp1408_ = FALSE; } - if (_tmp1393_) { - ValaExpression* _tmp1398_; - ValaExpression* _tmp1399_; - _tmp1398_ = vala_member_access_get_inner (self); - _tmp1399_ = _tmp1398_; - _tmp1392_ = _tmp1399_ != NULL; + if (_tmp1408_) { + ValaExpression* _tmp1413_; + ValaExpression* _tmp1414_; + _tmp1413_ = vala_member_access_get_inner (self); + _tmp1414_ = _tmp1413_; + _tmp1407_ = _tmp1414_ != NULL; } else { - _tmp1392_ = FALSE; + _tmp1407_ = FALSE; } - if (_tmp1392_) { - ValaExpression* _tmp1400_; - ValaExpression* _tmp1401_; - ValaSymbol* _tmp1402_; - ValaSymbol* _tmp1403_; - _tmp1400_ = vala_member_access_get_inner (self); - _tmp1401_ = _tmp1400_; - _tmp1402_ = vala_expression_get_symbol_reference (_tmp1401_); - _tmp1403_ = _tmp1402_; - if (VALA_IS_METHOD (_tmp1403_)) { + if (_tmp1407_) { + ValaExpression* _tmp1415_; + ValaExpression* _tmp1416_; + ValaSymbol* _tmp1417_; + ValaSymbol* _tmp1418_; + _tmp1415_ = vala_member_access_get_inner (self); + _tmp1416_ = _tmp1415_; + _tmp1417_ = vala_expression_get_symbol_reference (_tmp1416_); + _tmp1418_ = _tmp1417_; + if (VALA_IS_METHOD (_tmp1418_)) { } else { - ValaSourceReference* _tmp1404_; - ValaSourceReference* _tmp1405_; - ValaSymbol* _tmp1406_; - ValaSymbol* _tmp1407_; - gchar* _tmp1408_; - gchar* _tmp1409_; + ValaSourceReference* _tmp1419_; + ValaSourceReference* _tmp1420_; + ValaSymbol* _tmp1421_; + ValaSymbol* _tmp1422_; + gchar* _tmp1423_; + gchar* _tmp1424_; ValaSymbol* inner_sym = NULL; - ValaSymbol* _tmp1410_; - ValaSymbol* _tmp1411_; - ValaSymbol* _tmp1412_; - ValaSymbol* _tmp1413_; + ValaSymbol* _tmp1425_; + ValaSymbol* _tmp1426_; + ValaSymbol* _tmp1427_; + ValaSymbol* _tmp1428_; ValaMemberAccess* inner_ma = NULL; - ValaMemberAccess* _tmp1433_; - ValaExpression* _tmp1434_; - ValaExpression* _tmp1435_; - _tmp1404_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1405_ = _tmp1404_; - _tmp1406_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1407_ = _tmp1406_; - _tmp1408_ = vala_symbol_get_full_name (_tmp1407_); - _tmp1409_ = _tmp1408_; - vala_report_warning (_tmp1405_, "Access to static member `%s' with an instance reference", _tmp1409_); - _g_free0 (_tmp1409_); - _tmp1410_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1411_ = _tmp1410_; - _tmp1412_ = vala_symbol_get_parent_symbol (_tmp1411_); - _tmp1413_ = _tmp1412_; - inner_sym = _tmp1413_; + ValaMemberAccess* _tmp1448_; + ValaExpression* _tmp1449_; + ValaExpression* _tmp1450_; + _tmp1419_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp1420_ = _tmp1419_; + _tmp1421_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1422_ = _tmp1421_; + _tmp1423_ = vala_symbol_get_full_name (_tmp1422_); + _tmp1424_ = _tmp1423_; + vala_report_warning (_tmp1420_, "Access to static member `%s' with an instance reference", _tmp1424_); + _g_free0 (_tmp1424_); + _tmp1425_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1426_ = _tmp1425_; + _tmp1427_ = vala_symbol_get_parent_symbol (_tmp1426_); + _tmp1428_ = _tmp1427_; + inner_sym = _tmp1428_; inner_ma = self; while (TRUE) { - gboolean _tmp1414_ = FALSE; - ValaSymbol* _tmp1415_; - ValaMemberAccess* _tmp1419_; - ValaSymbol* _tmp1420_; - const gchar* _tmp1421_; - const gchar* _tmp1422_; - ValaSourceReference* _tmp1423_; - ValaSourceReference* _tmp1424_; - ValaMemberAccess* _tmp1425_; - ValaMemberAccess* _tmp1426_; - ValaMemberAccess* _tmp1427_; - ValaExpression* _tmp1428_; - ValaExpression* _tmp1429_; + gboolean _tmp1429_ = FALSE; ValaSymbol* _tmp1430_; - ValaSymbol* _tmp1431_; - ValaSymbol* _tmp1432_; - _tmp1415_ = inner_sym; - if (_tmp1415_ != NULL) { - ValaSymbol* _tmp1416_; - const gchar* _tmp1417_; - const gchar* _tmp1418_; - _tmp1416_ = inner_sym; - _tmp1417_ = vala_symbol_get_name (_tmp1416_); - _tmp1418_ = _tmp1417_; - _tmp1414_ = _tmp1418_ != NULL; + ValaMemberAccess* _tmp1434_; + ValaSymbol* _tmp1435_; + const gchar* _tmp1436_; + const gchar* _tmp1437_; + ValaSourceReference* _tmp1438_; + ValaSourceReference* _tmp1439_; + ValaMemberAccess* _tmp1440_; + ValaMemberAccess* _tmp1441_; + ValaMemberAccess* _tmp1442_; + ValaExpression* _tmp1443_; + ValaExpression* _tmp1444_; + ValaSymbol* _tmp1445_; + ValaSymbol* _tmp1446_; + ValaSymbol* _tmp1447_; + _tmp1430_ = inner_sym; + if (_tmp1430_ != NULL) { + ValaSymbol* _tmp1431_; + const gchar* _tmp1432_; + const gchar* _tmp1433_; + _tmp1431_ = inner_sym; + _tmp1432_ = vala_symbol_get_name (_tmp1431_); + _tmp1433_ = _tmp1432_; + _tmp1429_ = _tmp1433_ != NULL; } else { - _tmp1414_ = FALSE; + _tmp1429_ = FALSE; } - if (!_tmp1414_) { + if (!_tmp1429_) { break; } - _tmp1419_ = inner_ma; - _tmp1420_ = inner_sym; - _tmp1421_ = vala_symbol_get_name (_tmp1420_); - _tmp1422_ = _tmp1421_; - _tmp1423_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1424_ = _tmp1423_; - _tmp1425_ = vala_member_access_new (NULL, _tmp1422_, _tmp1424_); - _tmp1426_ = _tmp1425_; - vala_member_access_set_inner (_tmp1419_, (ValaExpression*) _tmp1426_); - _vala_code_node_unref0 (_tmp1426_); - _tmp1427_ = inner_ma; - _tmp1428_ = vala_member_access_get_inner (_tmp1427_); - _tmp1429_ = _tmp1428_; - inner_ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp1429_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess); - _tmp1430_ = inner_sym; - _tmp1431_ = vala_symbol_get_parent_symbol (_tmp1430_); - _tmp1432_ = _tmp1431_; - inner_sym = _tmp1432_; - } - _tmp1433_ = inner_ma; - vala_member_access_set_qualified (_tmp1433_, TRUE); - _tmp1434_ = vala_member_access_get_inner (self); - _tmp1435_ = _tmp1434_; - vala_code_node_check ((ValaCodeNode*) _tmp1435_, context); - } - } - _tmp1441_ = vala_code_context_get_experimental_non_null (context); - _tmp1442_ = _tmp1441_; - if (_tmp1442_) { - _tmp1440_ = instance; + _tmp1434_ = inner_ma; + _tmp1435_ = inner_sym; + _tmp1436_ = vala_symbol_get_name (_tmp1435_); + _tmp1437_ = _tmp1436_; + _tmp1438_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp1439_ = _tmp1438_; + _tmp1440_ = vala_member_access_new (NULL, _tmp1437_, _tmp1439_); + _tmp1441_ = _tmp1440_; + vala_member_access_set_inner (_tmp1434_, (ValaExpression*) _tmp1441_); + _vala_code_node_unref0 (_tmp1441_); + _tmp1442_ = inner_ma; + _tmp1443_ = vala_member_access_get_inner (_tmp1442_); + _tmp1444_ = _tmp1443_; + inner_ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp1444_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess); + _tmp1445_ = inner_sym; + _tmp1446_ = vala_symbol_get_parent_symbol (_tmp1445_); + _tmp1447_ = _tmp1446_; + inner_sym = _tmp1447_; + } + _tmp1448_ = inner_ma; + vala_member_access_set_qualified (_tmp1448_, TRUE); + _tmp1449_ = vala_member_access_get_inner (self); + _tmp1450_ = _tmp1449_; + vala_code_node_check ((ValaCodeNode*) _tmp1450_, context); + } + } + _tmp1456_ = vala_code_context_get_experimental_non_null (context); + _tmp1457_ = _tmp1456_; + if (_tmp1457_) { + _tmp1455_ = instance; } else { - _tmp1440_ = FALSE; + _tmp1455_ = FALSE; } - if (_tmp1440_) { - ValaExpression* _tmp1443_; - ValaExpression* _tmp1444_; - ValaDataType* _tmp1445_; - ValaDataType* _tmp1446_; - gboolean _tmp1447_; - gboolean _tmp1448_; - _tmp1443_ = vala_member_access_get_inner (self); - _tmp1444_ = _tmp1443_; - _tmp1445_ = vala_expression_get_value_type (_tmp1444_); - _tmp1446_ = _tmp1445_; - _tmp1447_ = vala_data_type_get_nullable (_tmp1446_); - _tmp1448_ = _tmp1447_; - _tmp1439_ = _tmp1448_; - } else { - _tmp1439_ = FALSE; - } - if (_tmp1439_) { - ValaExpression* _tmp1449_; - ValaExpression* _tmp1450_; - ValaDataType* _tmp1451_; - ValaDataType* _tmp1452_; - _tmp1449_ = vala_member_access_get_inner (self); - _tmp1450_ = _tmp1449_; - _tmp1451_ = vala_expression_get_value_type (_tmp1450_); - _tmp1452_ = _tmp1451_; - _tmp1438_ = !VALA_IS_POINTER_TYPE (_tmp1452_); - } else { - _tmp1438_ = FALSE; - } - if (_tmp1438_) { - ValaExpression* _tmp1453_; - ValaExpression* _tmp1454_; - ValaDataType* _tmp1455_; - ValaDataType* _tmp1456_; - _tmp1453_ = vala_member_access_get_inner (self); - _tmp1454_ = _tmp1453_; - _tmp1455_ = vala_expression_get_value_type (_tmp1454_); - _tmp1456_ = _tmp1455_; - _tmp1437_ = !VALA_IS_GENERIC_TYPE (_tmp1456_); - } else { - _tmp1437_ = FALSE; - } - if (_tmp1437_) { - ValaExpression* _tmp1457_; + if (_tmp1455_) { ValaExpression* _tmp1458_; - ValaDataType* _tmp1459_; + ValaExpression* _tmp1459_; ValaDataType* _tmp1460_; - _tmp1457_ = vala_member_access_get_inner (self); - _tmp1458_ = _tmp1457_; - _tmp1459_ = vala_expression_get_value_type (_tmp1458_); - _tmp1460_ = _tmp1459_; - _tmp1436_ = !VALA_IS_ARRAY_TYPE (_tmp1460_); + ValaDataType* _tmp1461_; + gboolean _tmp1462_; + gboolean _tmp1463_; + _tmp1458_ = vala_member_access_get_inner (self); + _tmp1459_ = _tmp1458_; + _tmp1460_ = vala_expression_get_value_type (_tmp1459_); + _tmp1461_ = _tmp1460_; + _tmp1462_ = vala_data_type_get_nullable (_tmp1461_); + _tmp1463_ = _tmp1462_; + _tmp1454_ = _tmp1463_; } else { - _tmp1436_ = FALSE; + _tmp1454_ = FALSE; } - if (_tmp1436_) { - ValaSourceReference* _tmp1461_; - ValaSourceReference* _tmp1462_; - ValaSymbol* _tmp1463_; - ValaSymbol* _tmp1464_; - gchar* _tmp1465_; - gchar* _tmp1466_; - _tmp1461_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp1462_ = _tmp1461_; - _tmp1463_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1464_ = _tmp1463_; - _tmp1465_ = vala_symbol_get_full_name (_tmp1464_); - _tmp1466_ = _tmp1465_; - vala_report_error (_tmp1462_, "Access to instance member `%s' from nullable reference denied", _tmp1466_); - _g_free0 (_tmp1466_); - } - _tmp1467_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1468_ = _tmp1467_; - m = VALA_IS_METHOD (_tmp1468_) ? ((ValaMethod*) _tmp1468_) : NULL; - _tmp1469_ = vala_member_access_get_inner (self); - _tmp1470_ = _tmp1469_; - inner_ma = VALA_IS_MEMBER_ACCESS (_tmp1470_) ? ((ValaMemberAccess*) _tmp1470_) : NULL; - _tmp1476_ = m; - if (_tmp1476_ != NULL) { - ValaMethod* _tmp1477_; - ValaMemberBinding _tmp1478_; - ValaMemberBinding _tmp1479_; - _tmp1477_ = m; - _tmp1478_ = vala_method_get_binding (_tmp1477_); - _tmp1479_ = _tmp1478_; - _tmp1475_ = _tmp1479_ == VALA_MEMBER_BINDING_STATIC; - } else { - _tmp1475_ = FALSE; - } - if (_tmp1475_) { - ValaMethod* _tmp1480_; - ValaSymbol* _tmp1481_; - ValaSymbol* _tmp1482_; - _tmp1480_ = m; - _tmp1481_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1480_); - _tmp1482_ = _tmp1481_; - _tmp1474_ = VALA_IS_OBJECT_TYPE_SYMBOL (_tmp1482_); + if (_tmp1454_) { + ValaExpression* _tmp1464_; + ValaExpression* _tmp1465_; + ValaDataType* _tmp1466_; + ValaDataType* _tmp1467_; + _tmp1464_ = vala_member_access_get_inner (self); + _tmp1465_ = _tmp1464_; + _tmp1466_ = vala_expression_get_value_type (_tmp1465_); + _tmp1467_ = _tmp1466_; + _tmp1453_ = !VALA_IS_POINTER_TYPE (_tmp1467_); } else { - _tmp1474_ = FALSE; + _tmp1453_ = FALSE; } - if (_tmp1474_) { - ValaExpression* _tmp1483_; - ValaExpression* _tmp1484_; - _tmp1483_ = vala_member_access_get_inner (self); - _tmp1484_ = _tmp1483_; - _tmp1473_ = _tmp1484_ != NULL; + if (_tmp1453_) { + ValaExpression* _tmp1468_; + ValaExpression* _tmp1469_; + ValaDataType* _tmp1470_; + ValaDataType* _tmp1471_; + _tmp1468_ = vala_member_access_get_inner (self); + _tmp1469_ = _tmp1468_; + _tmp1470_ = vala_expression_get_value_type (_tmp1469_); + _tmp1471_ = _tmp1470_; + _tmp1452_ = !VALA_IS_GENERIC_TYPE (_tmp1471_); } else { - _tmp1473_ = FALSE; + _tmp1452_ = FALSE; } - if (_tmp1473_) { - ValaExpression* _tmp1485_; - ValaExpression* _tmp1486_; - ValaDataType* _tmp1487_; - ValaDataType* _tmp1488_; - _tmp1485_ = vala_member_access_get_inner (self); - _tmp1486_ = _tmp1485_; - _tmp1487_ = vala_expression_get_value_type (_tmp1486_); - _tmp1488_ = _tmp1487_; - _tmp1472_ = _tmp1488_ == NULL; + if (_tmp1452_) { + ValaExpression* _tmp1472_; + ValaExpression* _tmp1473_; + ValaDataType* _tmp1474_; + ValaDataType* _tmp1475_; + _tmp1472_ = vala_member_access_get_inner (self); + _tmp1473_ = _tmp1472_; + _tmp1474_ = vala_expression_get_value_type (_tmp1473_); + _tmp1475_ = _tmp1474_; + _tmp1451_ = !VALA_IS_ARRAY_TYPE (_tmp1475_); } else { - _tmp1472_ = FALSE; + _tmp1451_ = FALSE; } - if (_tmp1472_) { - ValaMemberAccess* _tmp1489_; - ValaList* _tmp1490_; - gint _tmp1491_; - gint _tmp1492_; - _tmp1489_ = inner_ma; - _tmp1490_ = _tmp1489_->priv->type_argument_list; - _tmp1491_ = vala_collection_get_size ((ValaCollection*) _tmp1490_); - _tmp1492_ = _tmp1491_; - _tmp1471_ = _tmp1492_ > 0; + if (_tmp1451_) { + ValaSourceReference* _tmp1476_; + ValaSourceReference* _tmp1477_; + ValaSymbol* _tmp1478_; + ValaSymbol* _tmp1479_; + gchar* _tmp1480_; + gchar* _tmp1481_; + _tmp1476_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp1477_ = _tmp1476_; + _tmp1478_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1479_ = _tmp1478_; + _tmp1480_ = vala_symbol_get_full_name (_tmp1479_); + _tmp1481_ = _tmp1480_; + vala_report_error (_tmp1477_, "Access to instance member `%s' from nullable reference denied", _tmp1481_); + _g_free0 (_tmp1481_); + } + _tmp1482_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1483_ = _tmp1482_; + m = VALA_IS_METHOD (_tmp1483_) ? ((ValaMethod*) _tmp1483_) : NULL; + _tmp1484_ = vala_member_access_get_inner (self); + _tmp1485_ = _tmp1484_; + inner_ma = VALA_IS_MEMBER_ACCESS (_tmp1485_) ? ((ValaMemberAccess*) _tmp1485_) : NULL; + _tmp1491_ = m; + if (_tmp1491_ != NULL) { + ValaMethod* _tmp1492_; + ValaMemberBinding _tmp1493_; + ValaMemberBinding _tmp1494_; + _tmp1492_ = m; + _tmp1493_ = vala_method_get_binding (_tmp1492_); + _tmp1494_ = _tmp1493_; + _tmp1490_ = _tmp1494_ == VALA_MEMBER_BINDING_STATIC; } else { - _tmp1471_ = FALSE; + _tmp1490_ = FALSE; } - if (_tmp1471_) { - ValaExpression* _tmp1493_; - ValaExpression* _tmp1494_; + if (_tmp1490_) { ValaMethod* _tmp1495_; ValaSymbol* _tmp1496_; ValaSymbol* _tmp1497_; - ValaObjectType* _tmp1498_; - ValaObjectType* _tmp1499_; - _tmp1493_ = vala_member_access_get_inner (self); - _tmp1494_ = _tmp1493_; _tmp1495_ = m; _tmp1496_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1495_); _tmp1497_ = _tmp1496_; - _tmp1498_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1497_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol)); + _tmp1489_ = VALA_IS_OBJECT_TYPE_SYMBOL (_tmp1497_); + } else { + _tmp1489_ = FALSE; + } + if (_tmp1489_) { + ValaExpression* _tmp1498_; + ValaExpression* _tmp1499_; + _tmp1498_ = vala_member_access_get_inner (self); _tmp1499_ = _tmp1498_; - vala_expression_set_value_type (_tmp1494_, (ValaDataType*) _tmp1499_); - _vala_code_node_unref0 (_tmp1499_); + _tmp1488_ = _tmp1499_ != NULL; + } else { + _tmp1488_ = FALSE; + } + if (_tmp1488_) { + ValaExpression* _tmp1500_; + ValaExpression* _tmp1501_; + ValaDataType* _tmp1502_; + ValaDataType* _tmp1503_; + _tmp1500_ = vala_member_access_get_inner (self); + _tmp1501_ = _tmp1500_; + _tmp1502_ = vala_expression_get_value_type (_tmp1501_); + _tmp1503_ = _tmp1502_; + _tmp1487_ = _tmp1503_ == NULL; + } else { + _tmp1487_ = FALSE; + } + if (_tmp1487_) { + ValaMemberAccess* _tmp1504_; + ValaList* _tmp1505_; + gint _tmp1506_; + gint _tmp1507_; + _tmp1504_ = inner_ma; + _tmp1505_ = _tmp1504_->priv->type_argument_list; + _tmp1506_ = vala_collection_get_size ((ValaCollection*) _tmp1505_); + _tmp1507_ = _tmp1506_; + _tmp1486_ = _tmp1507_ > 0; + } else { + _tmp1486_ = FALSE; + } + if (_tmp1486_) { + ValaExpression* _tmp1508_; + ValaExpression* _tmp1509_; + ValaMethod* _tmp1510_; + ValaSymbol* _tmp1511_; + ValaSymbol* _tmp1512_; + ValaObjectType* _tmp1513_; + ValaObjectType* _tmp1514_; + ValaExpression* _tmp1515_; + ValaExpression* _tmp1516_; + ValaDataType* _tmp1517_; + ValaDataType* _tmp1518_; + ValaSourceReference* _tmp1519_; + ValaSourceReference* _tmp1520_; + _tmp1508_ = vala_member_access_get_inner (self); + _tmp1509_ = _tmp1508_; + _tmp1510_ = m; + _tmp1511_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1510_); + _tmp1512_ = _tmp1511_; + _tmp1513_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1512_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol)); + _tmp1514_ = _tmp1513_; + vala_expression_set_value_type (_tmp1509_, (ValaDataType*) _tmp1514_); + _vala_code_node_unref0 (_tmp1514_); + _tmp1515_ = vala_member_access_get_inner (self); + _tmp1516_ = _tmp1515_; + _tmp1517_ = vala_expression_get_value_type (_tmp1516_); + _tmp1518_ = _tmp1517_; + _tmp1519_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp1520_ = _tmp1519_; + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp1518_, _tmp1520_); { ValaList* _type_argument_list = NULL; - ValaMemberAccess* _tmp1500_; - ValaList* _tmp1501_; + ValaMemberAccess* _tmp1521_; + ValaList* _tmp1522_; gint _type_argument_size = 0; - ValaList* _tmp1502_; - gint _tmp1503_; - gint _tmp1504_; + ValaList* _tmp1523_; + gint _tmp1524_; + gint _tmp1525_; gint _type_argument_index = 0; - _tmp1500_ = inner_ma; - _tmp1501_ = _tmp1500_->priv->type_argument_list; - _type_argument_list = _tmp1501_; - _tmp1502_ = _type_argument_list; - _tmp1503_ = vala_collection_get_size ((ValaCollection*) _tmp1502_); - _tmp1504_ = _tmp1503_; - _type_argument_size = _tmp1504_; + _tmp1521_ = inner_ma; + _tmp1522_ = _tmp1521_->priv->type_argument_list; + _type_argument_list = _tmp1522_; + _tmp1523_ = _type_argument_list; + _tmp1524_ = vala_collection_get_size ((ValaCollection*) _tmp1523_); + _tmp1525_ = _tmp1524_; + _type_argument_size = _tmp1525_; _type_argument_index = -1; while (TRUE) { - gint _tmp1505_; - gint _tmp1506_; + gint _tmp1526_; + gint _tmp1527_; ValaDataType* type_argument = NULL; - ValaList* _tmp1507_; - gpointer _tmp1508_; - ValaExpression* _tmp1509_; - ValaExpression* _tmp1510_; - ValaDataType* _tmp1511_; - ValaDataType* _tmp1512_; - ValaDataType* _tmp1513_; + ValaList* _tmp1528_; + gpointer _tmp1529_; + ValaExpression* _tmp1530_; + ValaExpression* _tmp1531_; + ValaDataType* _tmp1532_; + ValaDataType* _tmp1533_; + ValaDataType* _tmp1534_; _type_argument_index = _type_argument_index + 1; - _tmp1505_ = _type_argument_index; - _tmp1506_ = _type_argument_size; - if (!(_tmp1505_ < _tmp1506_)) { + _tmp1526_ = _type_argument_index; + _tmp1527_ = _type_argument_size; + if (!(_tmp1526_ < _tmp1527_)) { break; } - _tmp1507_ = _type_argument_list; - _tmp1508_ = vala_list_get (_tmp1507_, _type_argument_index); - type_argument = (ValaDataType*) _tmp1508_; - _tmp1509_ = vala_member_access_get_inner (self); - _tmp1510_ = _tmp1509_; - _tmp1511_ = vala_expression_get_value_type (_tmp1510_); - _tmp1512_ = _tmp1511_; - _tmp1513_ = type_argument; - vala_data_type_add_type_argument (_tmp1512_, _tmp1513_); + _tmp1528_ = _type_argument_list; + _tmp1529_ = vala_list_get (_tmp1528_, _type_argument_index); + type_argument = (ValaDataType*) _tmp1529_; + _tmp1530_ = vala_member_access_get_inner (self); + _tmp1531_ = _tmp1530_; + _tmp1532_ = vala_expression_get_value_type (_tmp1531_); + _tmp1533_ = _tmp1532_; + _tmp1534_ = type_argument; + vala_data_type_add_type_argument (_tmp1533_, _tmp1534_); _vala_code_node_unref0 (type_argument); } } } - _tmp1514_ = vala_code_context_get_analyzer (context); - _tmp1515_ = _tmp1514_; - _tmp1516_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1517_ = _tmp1516_; - _tmp1518_ = vala_expression_get_lvalue ((ValaExpression*) self); - _tmp1519_ = _tmp1518_; - _tmp1520_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp1515_, _tmp1517_, _tmp1519_); - _tmp1521_ = _tmp1520_; - vala_expression_set_formal_value_type ((ValaExpression*) self, _tmp1521_); - _vala_code_node_unref0 (_tmp1521_); - _tmp1523_ = vala_member_access_get_inner (self); - _tmp1524_ = _tmp1523_; - if (_tmp1524_ != NULL) { - ValaDataType* _tmp1525_; - ValaDataType* _tmp1526_; - _tmp1525_ = vala_expression_get_formal_value_type ((ValaExpression*) self); - _tmp1526_ = _tmp1525_; - _tmp1522_ = _tmp1526_ != NULL; + _tmp1535_ = vala_code_context_get_analyzer (context); + _tmp1536_ = _tmp1535_; + _tmp1537_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1538_ = _tmp1537_; + _tmp1539_ = vala_expression_get_lvalue ((ValaExpression*) self); + _tmp1540_ = _tmp1539_; + _tmp1541_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp1536_, _tmp1538_, _tmp1540_); + _tmp1542_ = _tmp1541_; + vala_expression_set_formal_value_type ((ValaExpression*) self, _tmp1542_); + _vala_code_node_unref0 (_tmp1542_); + _tmp1544_ = vala_member_access_get_inner (self); + _tmp1545_ = _tmp1544_; + if (_tmp1545_ != NULL) { + ValaDataType* _tmp1546_; + ValaDataType* _tmp1547_; + _tmp1546_ = vala_expression_get_formal_value_type ((ValaExpression*) self); + _tmp1547_ = _tmp1546_; + _tmp1543_ = _tmp1547_ != NULL; } else { - _tmp1522_ = FALSE; + _tmp1543_ = FALSE; } - if (_tmp1522_) { - ValaDataType* _tmp1527_; - ValaDataType* _tmp1528_; - ValaExpression* _tmp1529_; - ValaExpression* _tmp1530_; - ValaDataType* _tmp1531_; - ValaDataType* _tmp1532_; - ValaDataType* _tmp1533_; - ValaDataType* _tmp1534_; - _tmp1527_ = vala_expression_get_formal_value_type ((ValaExpression*) self); - _tmp1528_ = _tmp1527_; - _tmp1529_ = vala_member_access_get_inner (self); - _tmp1530_ = _tmp1529_; - _tmp1531_ = vala_expression_get_value_type (_tmp1530_); - _tmp1532_ = _tmp1531_; - _tmp1533_ = vala_data_type_get_actual_type (_tmp1528_, _tmp1532_, NULL, (ValaCodeNode*) self); - _tmp1534_ = _tmp1533_; - vala_expression_set_value_type ((ValaExpression*) self, _tmp1534_); - _vala_code_node_unref0 (_tmp1534_); + if (_tmp1543_) { + ValaDataType* _tmp1548_; + ValaDataType* _tmp1549_; + ValaExpression* _tmp1550_; + ValaExpression* _tmp1551_; + ValaDataType* _tmp1552_; + ValaDataType* _tmp1553_; + ValaDataType* _tmp1554_; + ValaDataType* _tmp1555_; + _tmp1548_ = vala_expression_get_formal_value_type ((ValaExpression*) self); + _tmp1549_ = _tmp1548_; + _tmp1550_ = vala_member_access_get_inner (self); + _tmp1551_ = _tmp1550_; + _tmp1552_ = vala_expression_get_value_type (_tmp1551_); + _tmp1553_ = _tmp1552_; + _tmp1554_ = vala_data_type_get_actual_type (_tmp1549_, _tmp1553_, NULL, (ValaCodeNode*) self); + _tmp1555_ = _tmp1554_; + vala_expression_set_value_type ((ValaExpression*) self, _tmp1555_); + _vala_code_node_unref0 (_tmp1555_); } else { - ValaDataType* _tmp1535_; - ValaDataType* _tmp1536_; - _tmp1535_ = vala_expression_get_formal_value_type ((ValaExpression*) self); - _tmp1536_ = _tmp1535_; - vala_expression_set_value_type ((ValaExpression*) self, _tmp1536_); - } - _tmp1537_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1538_ = _tmp1537_; - if (VALA_IS_METHOD (_tmp1538_)) { + ValaDataType* _tmp1556_; + ValaDataType* _tmp1557_; + _tmp1556_ = vala_expression_get_formal_value_type ((ValaExpression*) self); + _tmp1557_ = _tmp1556_; + vala_expression_set_value_type ((ValaExpression*) self, _tmp1557_); + } + _tmp1558_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1559_ = _tmp1558_; + if (VALA_IS_METHOD (_tmp1559_)) { ValaMethod* method = NULL; - ValaSymbol* _tmp1539_; - ValaSymbol* _tmp1540_; - ValaDataType* _tmp1541_; - ValaDataType* _tmp1542_; - gboolean _tmp1549_ = FALSE; - _tmp1539_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1540_ = _tmp1539_; - method = G_TYPE_CHECK_INSTANCE_CAST (_tmp1540_, VALA_TYPE_METHOD, ValaMethod); - _tmp1541_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp1542_ = _tmp1541_; - if (_tmp1542_ != NULL) { - ValaDataType* _tmp1543_; - ValaDataType* _tmp1544_; - ValaDataType* _tmp1545_; - ValaDataType* _tmp1546_; - gboolean _tmp1547_; - gboolean _tmp1548_; - _tmp1543_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp1544_ = _tmp1543_; - _tmp1545_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp1546_ = _tmp1545_; - _tmp1547_ = vala_data_type_get_value_owned (_tmp1546_); - _tmp1548_ = _tmp1547_; - vala_data_type_set_value_owned (_tmp1544_, _tmp1548_); - } - if (instance) { - ValaMethod* _tmp1550_; - ValaSymbol* _tmp1551_; - ValaSymbol* _tmp1552_; - _tmp1550_ = method; - _tmp1551_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1550_); - _tmp1552_ = _tmp1551_; - _tmp1549_ = VALA_IS_TYPESYMBOL (_tmp1552_); - } else { - _tmp1549_ = FALSE; - } - if (_tmp1549_) { - ValaExpression* _tmp1553_; - ValaExpression* _tmp1554_; - ValaMethod* _tmp1555_; - ValaSymbol* _tmp1556_; - ValaSymbol* _tmp1557_; - ValaDataType* _tmp1558_; - ValaDataType* _tmp1559_; - ValaExpression* _tmp1560_; - ValaExpression* _tmp1561_; - ValaDataType* _tmp1562_; - ValaDataType* _tmp1563_; - ValaMethod* _tmp1564_; - ValaParameter* _tmp1565_; - ValaParameter* _tmp1566_; + ValaSymbol* _tmp1560_; + ValaSymbol* _tmp1561_; + ValaDataType* _tmp1562_; + ValaDataType* _tmp1563_; + gboolean _tmp1570_ = FALSE; + _tmp1560_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1561_ = _tmp1560_; + method = G_TYPE_CHECK_INSTANCE_CAST (_tmp1561_, VALA_TYPE_METHOD, ValaMethod); + _tmp1562_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp1563_ = _tmp1562_; + if (_tmp1563_ != NULL) { + ValaDataType* _tmp1564_; + ValaDataType* _tmp1565_; + ValaDataType* _tmp1566_; ValaDataType* _tmp1567_; - ValaDataType* _tmp1568_; + gboolean _tmp1568_; gboolean _tmp1569_; - gboolean _tmp1570_; - _tmp1553_ = vala_member_access_get_inner (self); - _tmp1554_ = _tmp1553_; - _tmp1555_ = method; - _tmp1556_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1555_); - _tmp1557_ = _tmp1556_; - _tmp1558_ = vala_semantic_analyzer_get_data_type_for_symbol (_tmp1557_); - _tmp1559_ = _tmp1558_; - vala_expression_set_target_type (_tmp1554_, _tmp1559_); - _vala_code_node_unref0 (_tmp1559_); - _tmp1560_ = vala_member_access_get_inner (self); - _tmp1561_ = _tmp1560_; - _tmp1562_ = vala_expression_get_target_type (_tmp1561_); - _tmp1563_ = _tmp1562_; - _tmp1564_ = method; - _tmp1565_ = vala_method_get_this_parameter (_tmp1564_); - _tmp1566_ = _tmp1565_; - _tmp1567_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1566_); - _tmp1568_ = _tmp1567_; - _tmp1569_ = vala_data_type_get_value_owned (_tmp1568_); - _tmp1570_ = _tmp1569_; - vala_data_type_set_value_owned (_tmp1563_, _tmp1570_); + _tmp1564_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp1565_ = _tmp1564_; + _tmp1566_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp1567_ = _tmp1566_; + _tmp1568_ = vala_data_type_get_value_owned (_tmp1567_); + _tmp1569_ = _tmp1568_; + vala_data_type_set_value_owned (_tmp1565_, _tmp1569_); } - } else { - gboolean _tmp1571_ = FALSE; - gboolean _tmp1572_ = FALSE; - ValaSymbol* _tmp1573_; - ValaSymbol* _tmp1574_; - _tmp1573_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1574_ = _tmp1573_; - if (VALA_IS_PROPERTY (_tmp1574_)) { - _tmp1572_ = instance; + if (instance) { + ValaMethod* _tmp1571_; + ValaSymbol* _tmp1572_; + ValaSymbol* _tmp1573_; + _tmp1571_ = method; + _tmp1572_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1571_); + _tmp1573_ = _tmp1572_; + _tmp1570_ = VALA_IS_TYPESYMBOL (_tmp1573_); } else { - _tmp1572_ = FALSE; + _tmp1570_ = FALSE; } - if (_tmp1572_) { - ValaSymbol* _tmp1575_; - ValaSymbol* _tmp1576_; + if (_tmp1570_) { + ValaExpression* _tmp1574_; + ValaExpression* _tmp1575_; + ValaMethod* _tmp1576_; ValaSymbol* _tmp1577_; ValaSymbol* _tmp1578_; - _tmp1575_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1576_ = _tmp1575_; - _tmp1577_ = vala_symbol_get_parent_symbol (_tmp1576_); + ValaDataType* _tmp1579_; + ValaDataType* _tmp1580_; + ValaExpression* _tmp1581_; + ValaExpression* _tmp1582_; + ValaDataType* _tmp1583_; + ValaDataType* _tmp1584_; + ValaMethod* _tmp1585_; + ValaParameter* _tmp1586_; + ValaParameter* _tmp1587_; + ValaDataType* _tmp1588_; + ValaDataType* _tmp1589_; + gboolean _tmp1590_; + gboolean _tmp1591_; + _tmp1574_ = vala_member_access_get_inner (self); + _tmp1575_ = _tmp1574_; + _tmp1576_ = method; + _tmp1577_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1576_); _tmp1578_ = _tmp1577_; - _tmp1571_ = _tmp1578_ != NULL; - } else { - _tmp1571_ = FALSE; - } - if (_tmp1571_) { - ValaExpression* _tmp1579_; - ValaExpression* _tmp1580_; - ValaSymbol* _tmp1581_; - ValaSymbol* _tmp1582_; - ValaSymbol* _tmp1583_; - ValaSymbol* _tmp1584_; - ValaDataType* _tmp1585_; - ValaDataType* _tmp1586_; - _tmp1579_ = vala_member_access_get_inner (self); + _tmp1579_ = vala_semantic_analyzer_get_data_type_for_symbol (_tmp1578_); _tmp1580_ = _tmp1579_; - _tmp1581_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + vala_expression_set_target_type (_tmp1575_, _tmp1580_); + _vala_code_node_unref0 (_tmp1580_); + _tmp1581_ = vala_member_access_get_inner (self); _tmp1582_ = _tmp1581_; - _tmp1583_ = vala_symbol_get_parent_symbol (_tmp1582_); + _tmp1583_ = vala_expression_get_target_type (_tmp1582_); _tmp1584_ = _tmp1583_; - _tmp1585_ = vala_semantic_analyzer_get_data_type_for_symbol (_tmp1584_); - _tmp1586_ = _tmp1585_; - vala_expression_set_target_type (_tmp1580_, _tmp1586_); - _vala_code_node_unref0 (_tmp1586_); - } else { - gboolean _tmp1587_ = FALSE; - gboolean _tmp1588_ = FALSE; - gboolean _tmp1589_ = FALSE; - ValaSymbol* _tmp1590_; - ValaSymbol* _tmp1591_; - _tmp1590_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1585_ = method; + _tmp1586_ = vala_method_get_this_parameter (_tmp1585_); + _tmp1587_ = _tmp1586_; + _tmp1588_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1587_); + _tmp1589_ = _tmp1588_; + _tmp1590_ = vala_data_type_get_value_owned (_tmp1589_); _tmp1591_ = _tmp1590_; - if (VALA_IS_FIELD (_tmp1591_)) { - _tmp1589_ = TRUE; + vala_data_type_set_value_owned (_tmp1584_, _tmp1591_); + } + } else { + gboolean _tmp1592_ = FALSE; + gboolean _tmp1593_ = FALSE; + ValaSymbol* _tmp1594_; + ValaSymbol* _tmp1595_; + _tmp1594_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1595_ = _tmp1594_; + if (VALA_IS_PROPERTY (_tmp1595_)) { + _tmp1593_ = instance; + } else { + _tmp1593_ = FALSE; + } + if (_tmp1593_) { + ValaSymbol* _tmp1596_; + ValaSymbol* _tmp1597_; + ValaSymbol* _tmp1598_; + ValaSymbol* _tmp1599_; + _tmp1596_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1597_ = _tmp1596_; + _tmp1598_ = vala_symbol_get_parent_symbol (_tmp1597_); + _tmp1599_ = _tmp1598_; + _tmp1592_ = _tmp1599_ != NULL; + } else { + _tmp1592_ = FALSE; + } + if (_tmp1592_) { + ValaExpression* _tmp1600_; + ValaExpression* _tmp1601_; + ValaSymbol* _tmp1602_; + ValaSymbol* _tmp1603_; + ValaSymbol* _tmp1604_; + ValaSymbol* _tmp1605_; + ValaDataType* _tmp1606_; + ValaDataType* _tmp1607_; + _tmp1600_ = vala_member_access_get_inner (self); + _tmp1601_ = _tmp1600_; + _tmp1602_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1603_ = _tmp1602_; + _tmp1604_ = vala_symbol_get_parent_symbol (_tmp1603_); + _tmp1605_ = _tmp1604_; + _tmp1606_ = vala_semantic_analyzer_get_data_type_for_symbol (_tmp1605_); + _tmp1607_ = _tmp1606_; + vala_expression_set_target_type (_tmp1601_, _tmp1607_); + _vala_code_node_unref0 (_tmp1607_); + } else { + gboolean _tmp1608_ = FALSE; + gboolean _tmp1609_ = FALSE; + gboolean _tmp1610_ = FALSE; + ValaSymbol* _tmp1611_; + ValaSymbol* _tmp1612_; + _tmp1611_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1612_ = _tmp1611_; + if (VALA_IS_FIELD (_tmp1612_)) { + _tmp1610_ = TRUE; } else { - ValaSymbol* _tmp1592_; - ValaSymbol* _tmp1593_; - _tmp1592_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1593_ = _tmp1592_; - _tmp1589_ = VALA_IS_SIGNAL (_tmp1593_); + ValaSymbol* _tmp1613_; + ValaSymbol* _tmp1614_; + _tmp1613_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1614_ = _tmp1613_; + _tmp1610_ = VALA_IS_SIGNAL (_tmp1614_); } - if (_tmp1589_) { - _tmp1588_ = instance; + if (_tmp1610_) { + _tmp1609_ = instance; } else { - _tmp1588_ = FALSE; + _tmp1609_ = FALSE; } - if (_tmp1588_) { - ValaSymbol* _tmp1594_; - ValaSymbol* _tmp1595_; - ValaSymbol* _tmp1596_; - ValaSymbol* _tmp1597_; - _tmp1594_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1595_ = _tmp1594_; - _tmp1596_ = vala_symbol_get_parent_symbol (_tmp1595_); - _tmp1597_ = _tmp1596_; - _tmp1587_ = _tmp1597_ != NULL; + if (_tmp1609_) { + ValaSymbol* _tmp1615_; + ValaSymbol* _tmp1616_; + ValaSymbol* _tmp1617_; + ValaSymbol* _tmp1618_; + _tmp1615_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1616_ = _tmp1615_; + _tmp1617_ = vala_symbol_get_parent_symbol (_tmp1616_); + _tmp1618_ = _tmp1617_; + _tmp1608_ = _tmp1618_ != NULL; } else { - _tmp1587_ = FALSE; + _tmp1608_ = FALSE; } - if (_tmp1587_) { + if (_tmp1608_) { ValaDataType* parent_type = NULL; - ValaSymbol* _tmp1598_; - ValaSymbol* _tmp1599_; - ValaSymbol* _tmp1600_; - ValaSymbol* _tmp1601_; - ValaDataType* _tmp1602_; - ValaExpression* _tmp1603_; - ValaExpression* _tmp1604_; - ValaDataType* _tmp1605_; - ValaExpression* _tmp1606_; - ValaExpression* _tmp1607_; - ValaDataType* _tmp1608_; - ValaDataType* _tmp1609_; - ValaDataType* _tmp1610_; - ValaDataType* _tmp1611_; - _tmp1598_ = vala_expression_get_symbol_reference ((ValaExpression*) self); - _tmp1599_ = _tmp1598_; - _tmp1600_ = vala_symbol_get_parent_symbol (_tmp1599_); - _tmp1601_ = _tmp1600_; - _tmp1602_ = vala_semantic_analyzer_get_data_type_for_symbol (_tmp1601_); - parent_type = _tmp1602_; - _tmp1603_ = vala_member_access_get_inner (self); - _tmp1604_ = _tmp1603_; - _tmp1605_ = parent_type; - _tmp1606_ = vala_member_access_get_inner (self); - _tmp1607_ = _tmp1606_; - _tmp1608_ = vala_expression_get_value_type (_tmp1607_); - _tmp1609_ = _tmp1608_; - _tmp1610_ = vala_data_type_get_actual_type (_tmp1605_, _tmp1609_, NULL, (ValaCodeNode*) self); - _tmp1611_ = _tmp1610_; - vala_expression_set_target_type (_tmp1604_, _tmp1611_); - _vala_code_node_unref0 (_tmp1611_); + ValaSymbol* _tmp1619_; + ValaSymbol* _tmp1620_; + ValaSymbol* _tmp1621_; + ValaSymbol* _tmp1622_; + ValaDataType* _tmp1623_; + ValaExpression* _tmp1624_; + ValaExpression* _tmp1625_; + ValaDataType* _tmp1626_; + ValaExpression* _tmp1627_; + ValaExpression* _tmp1628_; + ValaDataType* _tmp1629_; + ValaDataType* _tmp1630_; + ValaDataType* _tmp1631_; + ValaDataType* _tmp1632_; + _tmp1619_ = vala_expression_get_symbol_reference ((ValaExpression*) self); + _tmp1620_ = _tmp1619_; + _tmp1621_ = vala_symbol_get_parent_symbol (_tmp1620_); + _tmp1622_ = _tmp1621_; + _tmp1623_ = vala_semantic_analyzer_get_data_type_for_symbol (_tmp1622_); + parent_type = _tmp1623_; + _tmp1624_ = vala_member_access_get_inner (self); + _tmp1625_ = _tmp1624_; + _tmp1626_ = parent_type; + _tmp1627_ = vala_member_access_get_inner (self); + _tmp1628_ = _tmp1627_; + _tmp1629_ = vala_expression_get_value_type (_tmp1628_); + _tmp1630_ = _tmp1629_; + _tmp1631_ = vala_data_type_get_actual_type (_tmp1626_, _tmp1630_, NULL, (ValaCodeNode*) self); + _tmp1632_ = _tmp1631_; + vala_expression_set_target_type (_tmp1625_, _tmp1632_); + _vala_code_node_unref0 (_tmp1632_); _vala_code_node_unref0 (parent_type); } } } - _tmp1614_ = vala_member_access_get_inner (self); - _tmp1615_ = _tmp1614_; - if (_tmp1615_ == NULL) { - ValaDataType* _tmp1616_; - ValaDataType* _tmp1617_; - _tmp1616_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp1617_ = _tmp1616_; - _tmp1613_ = _tmp1617_ != NULL; + _tmp1635_ = vala_member_access_get_inner (self); + _tmp1636_ = _tmp1635_; + if (_tmp1636_ == NULL) { + ValaDataType* _tmp1637_; + ValaDataType* _tmp1638_; + _tmp1637_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp1638_ = _tmp1637_; + _tmp1634_ = _tmp1638_ != NULL; } else { - _tmp1613_ = FALSE; + _tmp1634_ = FALSE; } - if (_tmp1613_) { - ValaProfile _tmp1618_; - ValaProfile _tmp1619_; - _tmp1618_ = vala_code_context_get_profile (context); - _tmp1619_ = _tmp1618_; - _tmp1612_ = _tmp1619_ == VALA_PROFILE_GOBJECT; + if (_tmp1634_) { + ValaProfile _tmp1639_; + ValaProfile _tmp1640_; + _tmp1639_ = vala_code_context_get_profile (context); + _tmp1640_ = _tmp1639_; + _tmp1633_ = _tmp1640_ == VALA_PROFILE_GOBJECT; } else { - _tmp1612_ = FALSE; + _tmp1633_ = FALSE; } - if (_tmp1612_) { + if (_tmp1633_) { vala_member_access_check_narrowed_value_type (self); } } - _tmp1620_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp1621_ = _tmp1620_; - if (_tmp1621_ != NULL) { - ValaDataType* _tmp1622_; - ValaDataType* _tmp1623_; - _tmp1622_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp1623_ = _tmp1622_; - vala_code_node_check ((ValaCodeNode*) _tmp1623_, context); + _tmp1641_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp1642_ = _tmp1641_; + if (_tmp1642_ != NULL) { + ValaDataType* _tmp1643_; + ValaDataType* _tmp1644_; + _tmp1643_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp1644_ = _tmp1643_; + vala_code_node_check ((ValaCodeNode*) _tmp1644_, context); } - _tmp1624_ = self->priv->_tainted_access; - if (!_tmp1624_) { + _tmp1645_ = self->priv->_tainted_access; + if (!_tmp1645_) { vala_member_access_set_tainted_access (self, vala_member_access_is_tainted (self)); } - _tmp1625_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp1626_ = _tmp1625_; - result = !_tmp1626_; + _tmp1646_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp1647_ = _tmp1646_; + result = !_tmp1647_; _vala_iterable_unref0 (visited_types); return result; } diff -Nru vala-0.52.6/vala/valamemberaccess.vala vala-0.52.7/vala/valamemberaccess.vala --- vala-0.52.6/vala/valamemberaccess.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vala/valamemberaccess.vala 2021-10-30 08:19:54.000000000 +0000 @@ -448,7 +448,7 @@ } var m = new DynamicMethod (inner.value_type, member_name, ret_type, source_reference); m.invocation = invoc; - var err = new ErrorType (null, null); + var err = new ErrorType (null, null, m.source_reference); err.dynamic_error = true; m.add_error_type (err); m.access = SymbolAccessibility.PUBLIC; @@ -937,10 +937,13 @@ // required when using instance methods as delegates in constants // TODO replace by MethodPrototype value_type = context.analyzer.get_value_type_for_symbol (symbol_reference, lvalue); + value_type.source_reference = source_reference; } else if (symbol_reference is Field) { value_type = new FieldPrototype ((Field) symbol_reference); + value_type.source_reference = source_reference; } else if (symbol_reference is Property) { value_type = new PropertyPrototype ((Property) symbol_reference); + value_type.source_reference = source_reference; } else { error = true; value_type = new InvalidType (); @@ -991,6 +994,7 @@ inner != null && inner.value_type == null && inner_ma.type_argument_list.size > 0) { // support static methods in generic classes inner.value_type = new ObjectType ((ObjectTypeSymbol) m.parent_symbol); + inner.value_type.source_reference = source_reference; foreach (var type_argument in inner_ma.type_argument_list) { inner.value_type.add_type_argument (type_argument); diff -Nru vala-0.52.6/vala/valamethod.c vala-0.52.7/vala/valamethod.c --- vala-0.52.6/vala/valamethod.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valamethod.c 2021-10-30 08:24:06.000000000 +0000 @@ -2748,60 +2748,59 @@ ValaAttribute* _tmp171_; ValaAttribute* _tmp172_; ValaAttribute* _tmp173_; - ValaDataType* _tmp180_; - ValaDataType* _tmp181_; - gboolean _tmp184_ = FALSE; - gboolean _tmp185_ = FALSE; - gboolean _tmp186_ = FALSE; - ValaList* _tmp187_; - gint _tmp188_; - gint _tmp189_; - gboolean _tmp203_ = FALSE; - ValaAttribute* _tmp204_; + gboolean _tmp180_ = FALSE; + gboolean _tmp181_ = FALSE; + gboolean _tmp182_ = FALSE; + ValaList* _tmp183_; + gint _tmp184_; + gint _tmp185_; + gboolean _tmp199_ = FALSE; + ValaAttribute* _tmp200_; gboolean optional_param = FALSE; gboolean params_array_param = FALSE; - gboolean _tmp348_; - ValaList* _tmp362_; - ValaLocalVariable* _tmp382_; - ValaLocalVariable* _tmp383_; - ValaList* _tmp386_; - ValaList* _tmp396_; - ValaBlock* _tmp406_; - ValaBlock* _tmp407_; - ValaSemanticAnalyzer* _tmp410_; - ValaSemanticAnalyzer* _tmp411_; - ValaStruct* _tmp412_; - ValaStruct* _tmp413_; - gboolean _tmp463_ = FALSE; - gboolean _tmp464_ = FALSE; - ValaDataType* _tmp465_; - ValaDataType* _tmp466_; - ValaSemanticAnalyzer* _tmp507_; - ValaSemanticAnalyzer* _tmp508_; - ValaSourceFile* _tmp509_; - ValaSemanticAnalyzer* _tmp510_; - ValaSemanticAnalyzer* _tmp511_; - ValaSymbol* _tmp512_; - gboolean _tmp513_ = FALSE; - gboolean _tmp514_ = FALSE; - gboolean _tmp515_ = FALSE; - gboolean _tmp516_; - gboolean _tmp517_; - ValaSemanticAnalyzer* _tmp531_; - ValaSemanticAnalyzer* _tmp532_; - ValaDataType* _tmp533_; - ValaDataType* _tmp534_; - gboolean _tmp583_ = FALSE; - ValaBlock* _tmp584_; - ValaBlock* _tmp585_; - gboolean _tmp626_ = FALSE; - gboolean _tmp627_ = FALSE; - gboolean _tmp628_ = FALSE; - gboolean _tmp629_ = FALSE; - gboolean _tmp630_ = FALSE; - ValaAttribute* _tmp687_; - gboolean _tmp688_; - gboolean _tmp689_; + gboolean ellipsis_param = FALSE; + gboolean _tmp350_; + ValaList* _tmp364_; + ValaLocalVariable* _tmp391_; + ValaLocalVariable* _tmp392_; + ValaList* _tmp395_; + ValaList* _tmp405_; + ValaBlock* _tmp415_; + ValaBlock* _tmp416_; + ValaSemanticAnalyzer* _tmp419_; + ValaSemanticAnalyzer* _tmp420_; + ValaStruct* _tmp421_; + ValaStruct* _tmp422_; + gboolean _tmp472_ = FALSE; + gboolean _tmp473_ = FALSE; + ValaDataType* _tmp474_; + ValaDataType* _tmp475_; + ValaSemanticAnalyzer* _tmp516_; + ValaSemanticAnalyzer* _tmp517_; + ValaSourceFile* _tmp518_; + ValaSemanticAnalyzer* _tmp519_; + ValaSemanticAnalyzer* _tmp520_; + ValaSymbol* _tmp521_; + gboolean _tmp522_ = FALSE; + gboolean _tmp523_ = FALSE; + gboolean _tmp524_ = FALSE; + gboolean _tmp525_; + gboolean _tmp526_; + ValaSemanticAnalyzer* _tmp540_; + ValaSemanticAnalyzer* _tmp541_; + ValaDataType* _tmp542_; + ValaDataType* _tmp543_; + gboolean _tmp592_ = FALSE; + ValaBlock* _tmp593_; + ValaBlock* _tmp594_; + gboolean _tmp635_ = FALSE; + gboolean _tmp636_ = FALSE; + gboolean _tmp637_ = FALSE; + gboolean _tmp638_ = FALSE; + gboolean _tmp639_ = FALSE; + ValaAttribute* _tmp696_; + gboolean _tmp697_; + gboolean _tmp698_; gboolean result = FALSE; self = (ValaMethod*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -3328,257 +3327,249 @@ _tmp179_ = _tmp178_; vala_code_context_set_module_init_method (_tmp179_, self); } - _tmp180_ = vala_callable_get_return_type ((ValaCallable*) self); - _tmp181_ = _tmp180_; - if (_tmp181_ != NULL) { - ValaDataType* _tmp182_; - ValaDataType* _tmp183_; - _tmp182_ = vala_callable_get_return_type ((ValaCallable*) self); - _tmp183_ = _tmp182_; - vala_code_node_check ((ValaCodeNode*) _tmp183_, context); - } - _tmp187_ = self->priv->parameters; - _tmp188_ = vala_collection_get_size ((ValaCollection*) _tmp187_); - _tmp189_ = _tmp188_; - if (_tmp189_ == 1) { - ValaList* _tmp190_; - gpointer _tmp191_; - ValaParameter* _tmp192_; - gboolean _tmp193_; - gboolean _tmp194_; - _tmp190_ = self->priv->parameters; - _tmp191_ = vala_list_get (_tmp190_, 0); - _tmp192_ = (ValaParameter*) _tmp191_; - _tmp193_ = vala_parameter_get_ellipsis (_tmp192_); - _tmp194_ = _tmp193_; - _tmp186_ = _tmp194_; - _vala_code_node_unref0 (_tmp192_); - } else { - _tmp186_ = FALSE; - } - if (_tmp186_) { - ValaBlock* _tmp195_; - ValaBlock* _tmp196_; - _tmp195_ = vala_subroutine_get_body ((ValaSubroutine*) self); - _tmp196_ = _tmp195_; - _tmp185_ = _tmp196_ != NULL; - } else { - _tmp185_ = FALSE; - } - if (_tmp185_) { - ValaMemberBinding _tmp197_; - _tmp197_ = self->priv->_binding; - _tmp184_ = _tmp197_ != VALA_MEMBER_BINDING_INSTANCE; - } else { - _tmp184_ = FALSE; - } - if (_tmp184_) { - ValaList* _tmp198_; - gpointer _tmp199_; - ValaParameter* _tmp200_; - ValaSourceReference* _tmp201_; - ValaSourceReference* _tmp202_; + _tmp183_ = self->priv->parameters; + _tmp184_ = vala_collection_get_size ((ValaCollection*) _tmp183_); + _tmp185_ = _tmp184_; + if (_tmp185_ == 1) { + ValaList* _tmp186_; + gpointer _tmp187_; + ValaParameter* _tmp188_; + gboolean _tmp189_; + gboolean _tmp190_; + _tmp186_ = self->priv->parameters; + _tmp187_ = vala_list_get (_tmp186_, 0); + _tmp188_ = (ValaParameter*) _tmp187_; + _tmp189_ = vala_parameter_get_ellipsis (_tmp188_); + _tmp190_ = _tmp189_; + _tmp182_ = _tmp190_; + _vala_code_node_unref0 (_tmp188_); + } else { + _tmp182_ = FALSE; + } + if (_tmp182_) { + ValaBlock* _tmp191_; + ValaBlock* _tmp192_; + _tmp191_ = vala_subroutine_get_body ((ValaSubroutine*) self); + _tmp192_ = _tmp191_; + _tmp181_ = _tmp192_ != NULL; + } else { + _tmp181_ = FALSE; + } + if (_tmp181_) { + ValaMemberBinding _tmp193_; + _tmp193_ = self->priv->_binding; + _tmp180_ = _tmp193_ != VALA_MEMBER_BINDING_INSTANCE; + } else { + _tmp180_ = FALSE; + } + if (_tmp180_) { + ValaList* _tmp194_; + gpointer _tmp195_; + ValaParameter* _tmp196_; + ValaSourceReference* _tmp197_; + ValaSourceReference* _tmp198_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp198_ = self->priv->parameters; - _tmp199_ = vala_list_get (_tmp198_, 0); - _tmp200_ = (ValaParameter*) _tmp199_; - _tmp201_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp200_); - _tmp202_ = _tmp201_; - vala_report_error (_tmp202_, "Named parameter required before `...'"); - _vala_code_node_unref0 (_tmp200_); - } - _tmp204_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "Print"); - if (_tmp204_ != NULL) { - gboolean _tmp205_ = FALSE; - ValaList* _tmp206_; - gint _tmp207_; - gint _tmp208_; - _tmp206_ = self->priv->parameters; - _tmp207_ = vala_collection_get_size ((ValaCollection*) _tmp206_); - _tmp208_ = _tmp207_; - if (_tmp208_ != 1) { - _tmp205_ = TRUE; + _tmp194_ = self->priv->parameters; + _tmp195_ = vala_list_get (_tmp194_, 0); + _tmp196_ = (ValaParameter*) _tmp195_; + _tmp197_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp196_); + _tmp198_ = _tmp197_; + vala_report_error (_tmp198_, "Named parameter required before `...'"); + _vala_code_node_unref0 (_tmp196_); + } + _tmp200_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "Print"); + if (_tmp200_ != NULL) { + gboolean _tmp201_ = FALSE; + ValaList* _tmp202_; + gint _tmp203_; + gint _tmp204_; + _tmp202_ = self->priv->parameters; + _tmp203_ = vala_collection_get_size ((ValaCollection*) _tmp202_); + _tmp204_ = _tmp203_; + if (_tmp204_ != 1) { + _tmp201_ = TRUE; } else { - ValaList* _tmp209_; - gpointer _tmp210_; - ValaParameter* _tmp211_; - ValaDataType* _tmp212_; - ValaDataType* _tmp213_; - ValaTypeSymbol* _tmp214_; + ValaList* _tmp205_; + gpointer _tmp206_; + ValaParameter* _tmp207_; + ValaDataType* _tmp208_; + ValaDataType* _tmp209_; + ValaTypeSymbol* _tmp210_; + ValaTypeSymbol* _tmp211_; + ValaSemanticAnalyzer* _tmp212_; + ValaSemanticAnalyzer* _tmp213_; + ValaDataType* _tmp214_; ValaTypeSymbol* _tmp215_; - ValaSemanticAnalyzer* _tmp216_; - ValaSemanticAnalyzer* _tmp217_; - ValaDataType* _tmp218_; - ValaTypeSymbol* _tmp219_; - ValaTypeSymbol* _tmp220_; - _tmp209_ = self->priv->parameters; - _tmp210_ = vala_list_get (_tmp209_, 0); - _tmp211_ = (ValaParameter*) _tmp210_; - _tmp212_ = vala_variable_get_variable_type ((ValaVariable*) _tmp211_); + ValaTypeSymbol* _tmp216_; + _tmp205_ = self->priv->parameters; + _tmp206_ = vala_list_get (_tmp205_, 0); + _tmp207_ = (ValaParameter*) _tmp206_; + _tmp208_ = vala_variable_get_variable_type ((ValaVariable*) _tmp207_); + _tmp209_ = _tmp208_; + _tmp210_ = vala_data_type_get_type_symbol (_tmp209_); + _tmp211_ = _tmp210_; + _tmp212_ = vala_code_context_get_analyzer (context); _tmp213_ = _tmp212_; - _tmp214_ = vala_data_type_get_type_symbol (_tmp213_); - _tmp215_ = _tmp214_; - _tmp216_ = vala_code_context_get_analyzer (context); - _tmp217_ = _tmp216_; - _tmp218_ = _tmp217_->string_type; - _tmp219_ = vala_data_type_get_type_symbol (_tmp218_); - _tmp220_ = _tmp219_; - _tmp205_ = _tmp215_ != _tmp220_; - _vala_code_node_unref0 (_tmp211_); - } - _tmp203_ = _tmp205_; - } else { - _tmp203_ = FALSE; - } - if (_tmp203_) { - ValaSourceReference* _tmp221_; - ValaSourceReference* _tmp222_; + _tmp214_ = _tmp213_->string_type; + _tmp215_ = vala_data_type_get_type_symbol (_tmp214_); + _tmp216_ = _tmp215_; + _tmp201_ = _tmp211_ != _tmp216_; + _vala_code_node_unref0 (_tmp207_); + } + _tmp199_ = _tmp201_; + } else { + _tmp199_ = FALSE; + } + if (_tmp199_) { + ValaSourceReference* _tmp217_; + ValaSourceReference* _tmp218_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp221_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp222_ = _tmp221_; - vala_report_error (_tmp222_, "[Print] methods must have exactly one parameter of type `string'"); + _tmp217_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp218_ = _tmp217_; + vala_report_error (_tmp218_, "[Print] methods must have exactly one parameter of type `string'"); } optional_param = FALSE; params_array_param = FALSE; + ellipsis_param = FALSE; { ValaList* _param_list = NULL; - ValaList* _tmp223_; + ValaList* _tmp219_; gint _param_size = 0; - ValaList* _tmp224_; - gint _tmp225_; - gint _tmp226_; + ValaList* _tmp220_; + gint _tmp221_; + gint _tmp222_; gint _param_index = 0; - _tmp223_ = self->priv->parameters; - _param_list = _tmp223_; - _tmp224_ = _param_list; - _tmp225_ = vala_collection_get_size ((ValaCollection*) _tmp224_); - _tmp226_ = _tmp225_; - _param_size = _tmp226_; + _tmp219_ = self->priv->parameters; + _param_list = _tmp219_; + _tmp220_ = _param_list; + _tmp221_ = vala_collection_get_size ((ValaCollection*) _tmp220_); + _tmp222_ = _tmp221_; + _param_size = _tmp222_; _param_index = -1; while (TRUE) { - gint _tmp227_; - gint _tmp228_; + gint _tmp223_; + gint _tmp224_; ValaParameter* param = NULL; - ValaList* _tmp229_; - gpointer _tmp230_; - ValaParameter* _tmp231_; - gboolean _tmp232_ = FALSE; - gboolean _tmp233_; - gboolean _tmp240_ = FALSE; - gboolean _tmp241_ = FALSE; - gboolean _tmp242_; - gboolean _tmp243_; - gboolean _tmp266_; - gboolean _tmp267_ = FALSE; - gboolean _tmp268_ = FALSE; - gboolean _tmp287_ = FALSE; - ValaParameter* _tmp288_; - gboolean _tmp289_; - gboolean _tmp290_; + ValaList* _tmp225_; + gpointer _tmp226_; + ValaParameter* _tmp227_; + gboolean _tmp228_ = FALSE; + gboolean _tmp229_; + gboolean _tmp236_ = FALSE; + gboolean _tmp237_ = FALSE; + gboolean _tmp238_; + gboolean _tmp239_; + gboolean _tmp262_; + gboolean _tmp263_ = FALSE; + gboolean _tmp264_ = FALSE; + gboolean _tmp289_ = FALSE; + ValaParameter* _tmp290_; + gboolean _tmp291_; + gboolean _tmp292_; _param_index = _param_index + 1; - _tmp227_ = _param_index; - _tmp228_ = _param_size; - if (!(_tmp227_ < _tmp228_)) { + _tmp223_ = _param_index; + _tmp224_ = _param_size; + if (!(_tmp223_ < _tmp224_)) { break; } - _tmp229_ = _param_list; - _tmp230_ = vala_list_get (_tmp229_, _param_index); - param = (ValaParameter*) _tmp230_; - _tmp231_ = param; - if (!vala_code_node_check ((ValaCodeNode*) _tmp231_, context)) { + _tmp225_ = _param_list; + _tmp226_ = vala_list_get (_tmp225_, _param_index); + param = (ValaParameter*) _tmp226_; + _tmp227_ = param; + if (!vala_code_node_check ((ValaCodeNode*) _tmp227_, context)) { vala_code_node_set_error ((ValaCodeNode*) self, TRUE); _vala_code_node_unref0 (param); continue; } - _tmp233_ = self->priv->_coroutine; - if (_tmp233_) { - ValaParameter* _tmp234_; - ValaParameterDirection _tmp235_; - ValaParameterDirection _tmp236_; - _tmp234_ = param; - _tmp235_ = vala_parameter_get_direction (_tmp234_); - _tmp236_ = _tmp235_; - _tmp232_ = _tmp236_ == VALA_PARAMETER_DIRECTION_REF; + _tmp229_ = self->priv->_coroutine; + if (_tmp229_) { + ValaParameter* _tmp230_; + ValaParameterDirection _tmp231_; + ValaParameterDirection _tmp232_; + _tmp230_ = param; + _tmp231_ = vala_parameter_get_direction (_tmp230_); + _tmp232_ = _tmp231_; + _tmp228_ = _tmp232_ == VALA_PARAMETER_DIRECTION_REF; } else { - _tmp232_ = FALSE; + _tmp228_ = FALSE; } - if (_tmp232_) { - ValaParameter* _tmp237_; - ValaSourceReference* _tmp238_; - ValaSourceReference* _tmp239_; + if (_tmp228_) { + ValaParameter* _tmp233_; + ValaSourceReference* _tmp234_; + ValaSourceReference* _tmp235_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp237_ = param; - _tmp238_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp237_); - _tmp239_ = _tmp238_; - vala_report_error (_tmp239_, "Reference parameters are not supported for async methods"); - } - _tmp242_ = vala_symbol_get_external_package ((ValaSymbol*) self); - _tmp243_ = _tmp242_; - if (!_tmp243_) { - gboolean _tmp244_; - _tmp244_ = self->priv->_coroutine; - _tmp241_ = _tmp244_; + _tmp233_ = param; + _tmp234_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp233_); + _tmp235_ = _tmp234_; + vala_report_error (_tmp235_, "Reference parameters are not supported for async methods"); + } + _tmp238_ = vala_symbol_get_external_package ((ValaSymbol*) self); + _tmp239_ = _tmp238_; + if (!_tmp239_) { + gboolean _tmp240_; + _tmp240_ = self->priv->_coroutine; + _tmp237_ = _tmp240_; } else { - _tmp241_ = FALSE; + _tmp237_ = FALSE; } - if (_tmp241_) { - gboolean _tmp245_ = FALSE; - gboolean _tmp246_ = FALSE; - ValaParameter* _tmp247_; - gboolean _tmp248_; - gboolean _tmp249_; - _tmp247_ = param; - _tmp248_ = vala_parameter_get_ellipsis (_tmp247_); - _tmp249_ = _tmp248_; - if (_tmp249_) { - _tmp246_ = TRUE; + if (_tmp237_) { + gboolean _tmp241_ = FALSE; + gboolean _tmp242_ = FALSE; + ValaParameter* _tmp243_; + gboolean _tmp244_; + gboolean _tmp245_; + _tmp243_ = param; + _tmp244_ = vala_parameter_get_ellipsis (_tmp243_); + _tmp245_ = _tmp244_; + if (_tmp245_) { + _tmp242_ = TRUE; } else { - ValaParameter* _tmp250_; - gboolean _tmp251_; - gboolean _tmp252_; - _tmp250_ = param; - _tmp251_ = vala_parameter_get_params_array (_tmp250_); - _tmp252_ = _tmp251_; - _tmp246_ = _tmp252_; + ValaParameter* _tmp246_; + gboolean _tmp247_; + gboolean _tmp248_; + _tmp246_ = param; + _tmp247_ = vala_parameter_get_params_array (_tmp246_); + _tmp248_ = _tmp247_; + _tmp242_ = _tmp248_; } - if (_tmp246_) { - _tmp245_ = TRUE; + if (_tmp242_) { + _tmp241_ = TRUE; } else { - ValaParameter* _tmp253_; - ValaDataType* _tmp254_; - ValaDataType* _tmp255_; - ValaTypeSymbol* _tmp256_; + ValaParameter* _tmp249_; + ValaDataType* _tmp250_; + ValaDataType* _tmp251_; + ValaTypeSymbol* _tmp252_; + ValaTypeSymbol* _tmp253_; + ValaSemanticAnalyzer* _tmp254_; + ValaSemanticAnalyzer* _tmp255_; + ValaDataType* _tmp256_; ValaTypeSymbol* _tmp257_; - ValaSemanticAnalyzer* _tmp258_; - ValaSemanticAnalyzer* _tmp259_; - ValaDataType* _tmp260_; - ValaTypeSymbol* _tmp261_; - ValaTypeSymbol* _tmp262_; - _tmp253_ = param; - _tmp254_ = vala_variable_get_variable_type ((ValaVariable*) _tmp253_); + ValaTypeSymbol* _tmp258_; + _tmp249_ = param; + _tmp250_ = vala_variable_get_variable_type ((ValaVariable*) _tmp249_); + _tmp251_ = _tmp250_; + _tmp252_ = vala_data_type_get_type_symbol (_tmp251_); + _tmp253_ = _tmp252_; + _tmp254_ = vala_code_context_get_analyzer (context); _tmp255_ = _tmp254_; - _tmp256_ = vala_data_type_get_type_symbol (_tmp255_); - _tmp257_ = _tmp256_; - _tmp258_ = vala_code_context_get_analyzer (context); - _tmp259_ = _tmp258_; - _tmp260_ = _tmp259_->va_list_type; - _tmp261_ = vala_data_type_get_type_symbol (_tmp260_); - _tmp262_ = _tmp261_; - _tmp245_ = _tmp257_ == _tmp262_; + _tmp256_ = _tmp255_->va_list_type; + _tmp257_ = vala_data_type_get_type_symbol (_tmp256_); + _tmp258_ = _tmp257_; + _tmp241_ = _tmp253_ == _tmp258_; } - _tmp240_ = _tmp245_; + _tmp236_ = _tmp241_; } else { - _tmp240_ = FALSE; + _tmp236_ = FALSE; } - if (_tmp240_) { - ValaParameter* _tmp263_; - ValaSourceReference* _tmp264_; - ValaSourceReference* _tmp265_; + if (_tmp236_) { + ValaParameter* _tmp259_; + ValaSourceReference* _tmp260_; + ValaSourceReference* _tmp261_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp263_ = param; - _tmp264_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp263_); - _tmp265_ = _tmp264_; - vala_report_error (_tmp265_, "Variadic parameters are not supported for async methods"); + _tmp259_ = param; + _tmp260_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp259_); + _tmp261_ = _tmp260_; + vala_report_error (_tmp261_, "Variadic parameters are not supported for async methods"); result = FALSE; _vala_code_node_unref0 (param); _vala_code_node_unref0 (init_attr); @@ -3586,278 +3577,297 @@ _vala_source_file_unref0 (old_source_file); return result; } - _tmp266_ = self->priv->_coroutine; - if (_tmp266_) { + _tmp262_ = self->priv->_coroutine; + if (_tmp262_) { _vala_code_node_unref0 (param); continue; } if (optional_param) { - ValaParameter* _tmp269_; - ValaExpression* _tmp270_; - ValaExpression* _tmp271_; - _tmp269_ = param; - _tmp270_ = vala_variable_get_initializer ((ValaVariable*) _tmp269_); - _tmp271_ = _tmp270_; - _tmp268_ = _tmp271_ == NULL; + ValaParameter* _tmp265_; + ValaExpression* _tmp266_; + ValaExpression* _tmp267_; + _tmp265_ = param; + _tmp266_ = vala_variable_get_initializer ((ValaVariable*) _tmp265_); + _tmp267_ = _tmp266_; + _tmp264_ = _tmp267_ == NULL; } else { - _tmp268_ = FALSE; + _tmp264_ = FALSE; } - if (_tmp268_) { - ValaParameter* _tmp272_; - gboolean _tmp273_; - gboolean _tmp274_; - _tmp272_ = param; - _tmp273_ = vala_parameter_get_ellipsis (_tmp272_); - _tmp274_ = _tmp273_; - _tmp267_ = !_tmp274_; + if (_tmp264_) { + ValaParameter* _tmp268_; + gboolean _tmp269_; + gboolean _tmp270_; + _tmp268_ = param; + _tmp269_ = vala_parameter_get_ellipsis (_tmp268_); + _tmp270_ = _tmp269_; + _tmp263_ = !_tmp270_; } else { - _tmp267_ = FALSE; + _tmp263_ = FALSE; } - if (_tmp267_) { - ValaParameter* _tmp275_; - ValaSourceReference* _tmp276_; - ValaSourceReference* _tmp277_; - _tmp275_ = param; - _tmp276_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp275_); - _tmp277_ = _tmp276_; - vala_report_warning (_tmp277_, "parameter without default follows parameter with default"); + if (_tmp263_) { + ValaParameter* _tmp271_; + ValaSourceReference* _tmp272_; + ValaSourceReference* _tmp273_; + _tmp271_ = param; + _tmp272_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp271_); + _tmp273_ = _tmp272_; + vala_report_warning (_tmp273_, "parameter without default follows parameter with default"); } else { - ValaParameter* _tmp278_; - ValaExpression* _tmp279_; - ValaExpression* _tmp280_; - _tmp278_ = param; - _tmp279_ = vala_variable_get_initializer ((ValaVariable*) _tmp278_); - _tmp280_ = _tmp279_; - if (_tmp280_ != NULL) { + ValaParameter* _tmp274_; + ValaExpression* _tmp275_; + ValaExpression* _tmp276_; + _tmp274_ = param; + _tmp275_ = vala_variable_get_initializer ((ValaVariable*) _tmp274_); + _tmp276_ = _tmp275_; + if (_tmp276_ != NULL) { optional_param = TRUE; } } if (params_array_param) { - ValaParameter* _tmp281_; - ValaSourceReference* _tmp282_; - ValaSourceReference* _tmp283_; - _tmp281_ = param; - _tmp282_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp281_); - _tmp283_ = _tmp282_; - vala_report_error (_tmp283_, "parameter follows params-array parameter"); + ValaParameter* _tmp277_; + ValaSourceReference* _tmp278_; + ValaSourceReference* _tmp279_; + _tmp277_ = param; + _tmp278_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp277_); + _tmp279_ = _tmp278_; + vala_report_error (_tmp279_, "parameter follows params-array parameter"); } else { - ValaParameter* _tmp284_; - gboolean _tmp285_; - gboolean _tmp286_; - _tmp284_ = param; - _tmp285_ = vala_parameter_get_params_array (_tmp284_); - _tmp286_ = _tmp285_; - if (_tmp286_) { + ValaParameter* _tmp280_; + gboolean _tmp281_; + gboolean _tmp282_; + _tmp280_ = param; + _tmp281_ = vala_parameter_get_params_array (_tmp280_); + _tmp282_ = _tmp281_; + if (_tmp282_) { params_array_param = TRUE; } } - _tmp288_ = param; - _tmp289_ = vala_parameter_get_params_array (_tmp288_); - _tmp290_ = _tmp289_; - if (_tmp290_) { - ValaBlock* _tmp291_; - ValaBlock* _tmp292_; - _tmp291_ = vala_subroutine_get_body ((ValaSubroutine*) self); - _tmp292_ = _tmp291_; - _tmp287_ = _tmp292_ != NULL; + if (ellipsis_param) { + ValaParameter* _tmp283_; + ValaSourceReference* _tmp284_; + ValaSourceReference* _tmp285_; + _tmp283_ = param; + _tmp284_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp283_); + _tmp285_ = _tmp284_; + vala_report_error (_tmp285_, "parameter follows ellipsis parameter"); } else { - _tmp287_ = FALSE; + ValaParameter* _tmp286_; + gboolean _tmp287_; + gboolean _tmp288_; + _tmp286_ = param; + _tmp287_ = vala_parameter_get_ellipsis (_tmp286_); + _tmp288_ = _tmp287_; + if (_tmp288_) { + ellipsis_param = TRUE; + } + } + _tmp290_ = param; + _tmp291_ = vala_parameter_get_params_array (_tmp290_); + _tmp292_ = _tmp291_; + if (_tmp292_) { + ValaBlock* _tmp293_; + ValaBlock* _tmp294_; + _tmp293_ = vala_subroutine_get_body ((ValaSubroutine*) self); + _tmp294_ = _tmp293_; + _tmp289_ = _tmp294_ != NULL; + } else { + _tmp289_ = FALSE; } - if (_tmp287_) { - ValaLocalVariable* _tmp293_; - gboolean _tmp297_; - gboolean _tmp298_; + if (_tmp289_) { + ValaLocalVariable* _tmp295_; + gboolean _tmp299_; + gboolean _tmp300_; ValaArrayType* type = NULL; - ValaParameter* _tmp302_; - ValaDataType* _tmp303_; - ValaDataType* _tmp304_; + ValaParameter* _tmp304_; ValaDataType* _tmp305_; - ValaArrayType* _tmp306_; + ValaDataType* _tmp306_; ValaDataType* _tmp307_; - ValaDataType* _tmp308_; - ValaArrayType* _tmp309_; - gboolean _tmp310_; - gboolean _tmp311_; - ValaArrayType* _tmp312_; - gboolean _tmp313_ = FALSE; + ValaArrayType* _tmp308_; + ValaDataType* _tmp309_; + ValaDataType* _tmp310_; + ValaArrayType* _tmp311_; + gboolean _tmp312_; + gboolean _tmp313_; ValaArrayType* _tmp314_; - ValaDataType* _tmp315_; - ValaDataType* _tmp316_; - ValaArrayType* _tmp325_; - ValaExpression* _tmp326_; - ValaExpression* _tmp327_; - ValaArrayType* _tmp331_; - ValaParameter* _tmp332_; - const gchar* _tmp333_; - const gchar* _tmp334_; - ValaParameter* _tmp335_; - ValaSourceReference* _tmp336_; - ValaSourceReference* _tmp337_; - ValaLocalVariable* _tmp338_; - ValaLocalVariable* _tmp339_; - ValaBlock* _tmp340_; - ValaBlock* _tmp341_; - ValaLocalVariable* _tmp342_; - ValaParameter* _tmp343_; - ValaSourceReference* _tmp344_; - ValaSourceReference* _tmp345_; - ValaDeclarationStatement* _tmp346_; - ValaDeclarationStatement* _tmp347_; - _tmp293_ = self->priv->_params_array_var; - if (_tmp293_ != NULL) { - ValaParameter* _tmp294_; - ValaSourceReference* _tmp295_; - ValaSourceReference* _tmp296_; + gboolean _tmp315_ = FALSE; + ValaArrayType* _tmp316_; + ValaDataType* _tmp317_; + ValaDataType* _tmp318_; + ValaArrayType* _tmp327_; + ValaExpression* _tmp328_; + ValaExpression* _tmp329_; + ValaArrayType* _tmp333_; + ValaParameter* _tmp334_; + const gchar* _tmp335_; + const gchar* _tmp336_; + ValaParameter* _tmp337_; + ValaSourceReference* _tmp338_; + ValaSourceReference* _tmp339_; + ValaLocalVariable* _tmp340_; + ValaLocalVariable* _tmp341_; + ValaBlock* _tmp342_; + ValaBlock* _tmp343_; + ValaLocalVariable* _tmp344_; + ValaParameter* _tmp345_; + ValaSourceReference* _tmp346_; + ValaSourceReference* _tmp347_; + ValaDeclarationStatement* _tmp348_; + ValaDeclarationStatement* _tmp349_; + _tmp295_ = self->priv->_params_array_var; + if (_tmp295_ != NULL) { + ValaParameter* _tmp296_; + ValaSourceReference* _tmp297_; + ValaSourceReference* _tmp298_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp294_ = param; - _tmp295_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp294_); - _tmp296_ = _tmp295_; - vala_report_error (_tmp296_, "Only one params-array parameter is allowed"); + _tmp296_ = param; + _tmp297_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp296_); + _tmp298_ = _tmp297_; + vala_report_error (_tmp298_, "Only one params-array parameter is allowed"); _vala_code_node_unref0 (param); continue; } - _tmp297_ = vala_code_context_get_experimental (context); - _tmp298_ = _tmp297_; - if (!_tmp298_) { - ValaParameter* _tmp299_; - ValaSourceReference* _tmp300_; - ValaSourceReference* _tmp301_; - _tmp299_ = param; - _tmp300_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp299_); - _tmp301_ = _tmp300_; - vala_report_warning (_tmp301_, "Support of params-arrays is experimental"); - } - _tmp302_ = param; - _tmp303_ = vala_variable_get_variable_type ((ValaVariable*) _tmp302_); - _tmp304_ = _tmp303_; - _tmp305_ = vala_data_type_copy (_tmp304_); - type = G_TYPE_CHECK_INSTANCE_CAST (_tmp305_, VALA_TYPE_ARRAY_TYPE, ValaArrayType); - _tmp306_ = type; - _tmp307_ = vala_array_type_get_element_type (_tmp306_); - _tmp308_ = _tmp307_; - _tmp309_ = type; - _tmp310_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp309_); - _tmp311_ = _tmp310_; - vala_data_type_set_value_owned (_tmp308_, _tmp311_); - _tmp312_ = type; - vala_data_type_set_value_owned ((ValaDataType*) _tmp312_, TRUE); + _tmp299_ = vala_code_context_get_experimental (context); + _tmp300_ = _tmp299_; + if (!_tmp300_) { + ValaParameter* _tmp301_; + ValaSourceReference* _tmp302_; + ValaSourceReference* _tmp303_; + _tmp301_ = param; + _tmp302_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp301_); + _tmp303_ = _tmp302_; + vala_report_warning (_tmp303_, "Support of params-arrays is experimental"); + } + _tmp304_ = param; + _tmp305_ = vala_variable_get_variable_type ((ValaVariable*) _tmp304_); + _tmp306_ = _tmp305_; + _tmp307_ = vala_data_type_copy (_tmp306_); + type = G_TYPE_CHECK_INSTANCE_CAST (_tmp307_, VALA_TYPE_ARRAY_TYPE, ValaArrayType); + _tmp308_ = type; + _tmp309_ = vala_array_type_get_element_type (_tmp308_); + _tmp310_ = _tmp309_; + _tmp311_ = type; + _tmp312_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp311_); + _tmp313_ = _tmp312_; + vala_data_type_set_value_owned (_tmp310_, _tmp313_); _tmp314_ = type; - _tmp315_ = vala_array_type_get_element_type (_tmp314_); - _tmp316_ = _tmp315_; - if (vala_data_type_is_real_struct_type (_tmp316_)) { - ValaArrayType* _tmp317_; - ValaDataType* _tmp318_; - ValaDataType* _tmp319_; - gboolean _tmp320_; - gboolean _tmp321_; - _tmp317_ = type; - _tmp318_ = vala_array_type_get_element_type (_tmp317_); - _tmp319_ = _tmp318_; - _tmp320_ = vala_data_type_get_nullable (_tmp319_); + vala_data_type_set_value_owned ((ValaDataType*) _tmp314_, TRUE); + _tmp316_ = type; + _tmp317_ = vala_array_type_get_element_type (_tmp316_); + _tmp318_ = _tmp317_; + if (vala_data_type_is_real_struct_type (_tmp318_)) { + ValaArrayType* _tmp319_; + ValaDataType* _tmp320_; + ValaDataType* _tmp321_; + gboolean _tmp322_; + gboolean _tmp323_; + _tmp319_ = type; + _tmp320_ = vala_array_type_get_element_type (_tmp319_); _tmp321_ = _tmp320_; - _tmp313_ = !_tmp321_; + _tmp322_ = vala_data_type_get_nullable (_tmp321_); + _tmp323_ = _tmp322_; + _tmp315_ = !_tmp323_; } else { - _tmp313_ = FALSE; + _tmp315_ = FALSE; } - if (_tmp313_) { - ValaParameter* _tmp322_; - ValaSourceReference* _tmp323_; - ValaSourceReference* _tmp324_; + if (_tmp315_) { + ValaParameter* _tmp324_; + ValaSourceReference* _tmp325_; + ValaSourceReference* _tmp326_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp322_ = param; - _tmp323_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp322_); - _tmp324_ = _tmp323_; - vala_report_error (_tmp324_, "Only nullable struct elements are supported in params-array"); - } - _tmp325_ = type; - _tmp326_ = vala_array_type_get_length (_tmp325_); - _tmp327_ = _tmp326_; - if (_tmp327_ != NULL) { - ValaParameter* _tmp328_; - ValaSourceReference* _tmp329_; - ValaSourceReference* _tmp330_; + _tmp324_ = param; + _tmp325_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp324_); + _tmp326_ = _tmp325_; + vala_report_error (_tmp326_, "Only nullable struct elements are supported in params-array"); + } + _tmp327_ = type; + _tmp328_ = vala_array_type_get_length (_tmp327_); + _tmp329_ = _tmp328_; + if (_tmp329_ != NULL) { + ValaParameter* _tmp330_; + ValaSourceReference* _tmp331_; + ValaSourceReference* _tmp332_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp328_ = param; - _tmp329_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp328_); - _tmp330_ = _tmp329_; - vala_report_error (_tmp330_, "Passing length to params-array is not supported yet"); - } - _tmp331_ = type; - _tmp332_ = param; - _tmp333_ = vala_symbol_get_name ((ValaSymbol*) _tmp332_); - _tmp334_ = _tmp333_; - _tmp335_ = param; - _tmp336_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp335_); - _tmp337_ = _tmp336_; - _tmp338_ = vala_local_variable_new ((ValaDataType*) _tmp331_, _tmp334_, NULL, _tmp337_); + _tmp330_ = param; + _tmp331_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp330_); + _tmp332_ = _tmp331_; + vala_report_error (_tmp332_, "Passing length to params-array is not supported yet"); + } + _tmp333_ = type; + _tmp334_ = param; + _tmp335_ = vala_symbol_get_name ((ValaSymbol*) _tmp334_); + _tmp336_ = _tmp335_; + _tmp337_ = param; + _tmp338_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp337_); _tmp339_ = _tmp338_; - vala_method_set_params_array_var (self, _tmp339_); - _vala_code_node_unref0 (_tmp339_); - _tmp340_ = vala_subroutine_get_body ((ValaSubroutine*) self); + _tmp340_ = vala_local_variable_new ((ValaDataType*) _tmp333_, _tmp336_, NULL, _tmp339_); _tmp341_ = _tmp340_; - _tmp342_ = self->priv->_params_array_var; - _tmp343_ = param; - _tmp344_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp343_); - _tmp345_ = _tmp344_; - _tmp346_ = vala_declaration_statement_new ((ValaSymbol*) _tmp342_, _tmp345_); + vala_method_set_params_array_var (self, _tmp341_); + _vala_code_node_unref0 (_tmp341_); + _tmp342_ = vala_subroutine_get_body ((ValaSubroutine*) self); + _tmp343_ = _tmp342_; + _tmp344_ = self->priv->_params_array_var; + _tmp345_ = param; + _tmp346_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp345_); _tmp347_ = _tmp346_; - vala_block_insert_statement (_tmp341_, 0, (ValaStatement*) _tmp347_); - _vala_code_node_unref0 (_tmp347_); + _tmp348_ = vala_declaration_statement_new ((ValaSymbol*) _tmp344_, _tmp347_); + _tmp349_ = _tmp348_; + vala_block_insert_statement (_tmp343_, 0, (ValaStatement*) _tmp349_); + _vala_code_node_unref0 (_tmp349_); _vala_code_node_unref0 (type); } _vala_code_node_unref0 (param); } } - _tmp348_ = self->priv->_coroutine; - if (_tmp348_) { + _tmp350_ = self->priv->_coroutine; + if (_tmp350_) { gboolean requires_pointer = FALSE; requires_pointer = FALSE; { gint i = 0; - ValaList* _tmp349_; - gint _tmp350_; - gint _tmp351_; - _tmp349_ = self->priv->parameters; - _tmp350_ = vala_collection_get_size ((ValaCollection*) _tmp349_); - _tmp351_ = _tmp350_; - i = _tmp351_ - 1; + ValaList* _tmp351_; + gint _tmp352_; + gint _tmp353_; + _tmp351_ = self->priv->parameters; + _tmp352_ = vala_collection_get_size ((ValaCollection*) _tmp351_); + _tmp353_ = _tmp352_; + i = _tmp353_ - 1; { - gboolean _tmp352_ = FALSE; - _tmp352_ = TRUE; + gboolean _tmp354_ = FALSE; + _tmp354_ = TRUE; while (TRUE) { ValaParameter* param = NULL; - ValaList* _tmp354_; - gpointer _tmp355_; - ValaParameter* _tmp356_; - ValaParameterDirection _tmp357_; - ValaParameterDirection _tmp358_; - if (!_tmp352_) { - gint _tmp353_; - _tmp353_ = i; - i = _tmp353_ - 1; + ValaList* _tmp356_; + gpointer _tmp357_; + ValaParameter* _tmp358_; + ValaParameterDirection _tmp359_; + ValaParameterDirection _tmp360_; + if (!_tmp354_) { + gint _tmp355_; + _tmp355_ = i; + i = _tmp355_ - 1; } - _tmp352_ = FALSE; + _tmp354_ = FALSE; if (!(i >= 0)) { break; } - _tmp354_ = self->priv->parameters; - _tmp355_ = vala_list_get (_tmp354_, i); - param = (ValaParameter*) _tmp355_; - _tmp356_ = param; - _tmp357_ = vala_parameter_get_direction (_tmp356_); - _tmp358_ = _tmp357_; - if (_tmp358_ == VALA_PARAMETER_DIRECTION_IN) { + _tmp356_ = self->priv->parameters; + _tmp357_ = vala_list_get (_tmp356_, i); + param = (ValaParameter*) _tmp357_; + _tmp358_ = param; + _tmp359_ = vala_parameter_get_direction (_tmp358_); + _tmp360_ = _tmp359_; + if (_tmp360_ == VALA_PARAMETER_DIRECTION_IN) { requires_pointer = TRUE; } else { if (requires_pointer) { - ValaParameter* _tmp359_; - ValaSourceReference* _tmp360_; - ValaSourceReference* _tmp361_; + ValaParameter* _tmp361_; + ValaSourceReference* _tmp362_; + ValaSourceReference* _tmp363_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp359_ = param; - _tmp360_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp359_); - _tmp361_ = _tmp360_; - vala_report_error (_tmp361_, "Synchronous out-parameters are not supported in async methods"); + _tmp361_ = param; + _tmp362_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp361_); + _tmp363_ = _tmp362_; + vala_report_error (_tmp363_, "Synchronous out-parameters are not supported in async methods"); } } _vala_code_node_unref0 (param); @@ -3865,66 +3875,85 @@ } } } - _tmp362_ = self->error_types; - if (_tmp362_ != NULL) { + _tmp364_ = self->error_types; + if (_tmp364_ != NULL) { { ValaList* _error_type_list = NULL; - ValaList* _tmp363_; + ValaList* _tmp365_; gint _error_type_size = 0; - ValaList* _tmp364_; - gint _tmp365_; - gint _tmp366_; + ValaList* _tmp366_; + gint _tmp367_; + gint _tmp368_; gint _error_type_index = 0; - _tmp363_ = self->error_types; - _error_type_list = _tmp363_; - _tmp364_ = _error_type_list; - _tmp365_ = vala_collection_get_size ((ValaCollection*) _tmp364_); - _tmp366_ = _tmp365_; - _error_type_size = _tmp366_; + _tmp365_ = self->error_types; + _error_type_list = _tmp365_; + _tmp366_ = _error_type_list; + _tmp367_ = vala_collection_get_size ((ValaCollection*) _tmp366_); + _tmp368_ = _tmp367_; + _error_type_size = _tmp368_; _error_type_index = -1; while (TRUE) { - gint _tmp367_; - gint _tmp368_; + gint _tmp369_; + gint _tmp370_; ValaDataType* error_type = NULL; - ValaList* _tmp369_; - gpointer _tmp370_; - ValaDataType* _tmp371_; - ValaSemanticAnalyzer* _tmp372_; - ValaSemanticAnalyzer* _tmp373_; - ValaDataType* _tmp374_; + ValaList* _tmp371_; + gpointer _tmp372_; + ValaDataType* _tmp373_; + ValaDataType* _tmp380_; + ValaSemanticAnalyzer* _tmp381_; + ValaSemanticAnalyzer* _tmp382_; + ValaDataType* _tmp383_; _error_type_index = _error_type_index + 1; - _tmp367_ = _error_type_index; - _tmp368_ = _error_type_size; - if (!(_tmp367_ < _tmp368_)) { + _tmp369_ = _error_type_index; + _tmp370_ = _error_type_size; + if (!(_tmp369_ < _tmp370_)) { break; } - _tmp369_ = _error_type_list; - _tmp370_ = vala_list_get (_tmp369_, _error_type_index); - error_type = (ValaDataType*) _tmp370_; - _tmp371_ = error_type; - vala_code_node_check ((ValaCodeNode*) _tmp371_, context); - _tmp372_ = vala_code_context_get_analyzer (context); - _tmp373_ = _tmp372_; - _tmp374_ = error_type; - if (!vala_semantic_analyzer_is_type_accessible (_tmp373_, (ValaSymbol*) self, _tmp374_)) { + _tmp371_ = _error_type_list; + _tmp372_ = vala_list_get (_tmp371_, _error_type_index); + error_type = (ValaDataType*) _tmp372_; + _tmp373_ = error_type; + if (!VALA_IS_ERROR_TYPE (_tmp373_)) { + ValaDataType* _tmp374_; ValaSourceReference* _tmp375_; ValaSourceReference* _tmp376_; ValaDataType* _tmp377_; gchar* _tmp378_; gchar* _tmp379_; - gchar* _tmp380_; - gchar* _tmp381_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp375_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp374_ = error_type; + _tmp375_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp374_); _tmp376_ = _tmp375_; _tmp377_ = error_type; _tmp378_ = vala_code_node_to_string ((ValaCodeNode*) _tmp377_); _tmp379_ = _tmp378_; - _tmp380_ = vala_symbol_get_full_name ((ValaSymbol*) self); - _tmp381_ = _tmp380_; - vala_report_error (_tmp376_, "error type `%s' is less accessible than method `%s'", _tmp379_, _tmp381_); - _g_free0 (_tmp381_); + vala_report_error (_tmp376_, "`%s' is not an error type", _tmp379_); _g_free0 (_tmp379_); + } + _tmp380_ = error_type; + vala_code_node_check ((ValaCodeNode*) _tmp380_, context); + _tmp381_ = vala_code_context_get_analyzer (context); + _tmp382_ = _tmp381_; + _tmp383_ = error_type; + if (!vala_semantic_analyzer_is_type_accessible (_tmp382_, (ValaSymbol*) self, _tmp383_)) { + ValaSourceReference* _tmp384_; + ValaSourceReference* _tmp385_; + ValaDataType* _tmp386_; + gchar* _tmp387_; + gchar* _tmp388_; + gchar* _tmp389_; + gchar* _tmp390_; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp384_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp385_ = _tmp384_; + _tmp386_ = error_type; + _tmp387_ = vala_code_node_to_string ((ValaCodeNode*) _tmp386_); + _tmp388_ = _tmp387_; + _tmp389_ = vala_symbol_get_full_name ((ValaSymbol*) self); + _tmp390_ = _tmp389_; + vala_report_error (_tmp385_, "error type `%s' is less accessible than method `%s'", _tmp388_, _tmp390_); + _g_free0 (_tmp390_); + _g_free0 (_tmp388_); result = FALSE; _vala_code_node_unref0 (error_type); _vala_code_node_unref0 (init_attr); @@ -3936,138 +3965,138 @@ } } } - _tmp382_ = vala_subroutine_get_result_var ((ValaSubroutine*) self); - _tmp383_ = _tmp382_; - if (_tmp383_ != NULL) { - ValaLocalVariable* _tmp384_; - ValaLocalVariable* _tmp385_; - _tmp384_ = vala_subroutine_get_result_var ((ValaSubroutine*) self); - _tmp385_ = _tmp384_; - vala_code_node_check ((ValaCodeNode*) _tmp385_, context); + _tmp391_ = vala_subroutine_get_result_var ((ValaSubroutine*) self); + _tmp392_ = _tmp391_; + if (_tmp392_ != NULL) { + ValaLocalVariable* _tmp393_; + ValaLocalVariable* _tmp394_; + _tmp393_ = vala_subroutine_get_result_var ((ValaSubroutine*) self); + _tmp394_ = _tmp393_; + vala_code_node_check ((ValaCodeNode*) _tmp394_, context); } - _tmp386_ = self->priv->preconditions; - if (_tmp386_ != NULL) { + _tmp395_ = self->priv->preconditions; + if (_tmp395_ != NULL) { { ValaList* _precondition_list = NULL; - ValaList* _tmp387_; + ValaList* _tmp396_; gint _precondition_size = 0; - ValaList* _tmp388_; - gint _tmp389_; - gint _tmp390_; + ValaList* _tmp397_; + gint _tmp398_; + gint _tmp399_; gint _precondition_index = 0; - _tmp387_ = self->priv->preconditions; - _precondition_list = _tmp387_; - _tmp388_ = _precondition_list; - _tmp389_ = vala_collection_get_size ((ValaCollection*) _tmp388_); - _tmp390_ = _tmp389_; - _precondition_size = _tmp390_; + _tmp396_ = self->priv->preconditions; + _precondition_list = _tmp396_; + _tmp397_ = _precondition_list; + _tmp398_ = vala_collection_get_size ((ValaCollection*) _tmp397_); + _tmp399_ = _tmp398_; + _precondition_size = _tmp399_; _precondition_index = -1; while (TRUE) { - gint _tmp391_; - gint _tmp392_; + gint _tmp400_; + gint _tmp401_; ValaExpression* precondition = NULL; - ValaList* _tmp393_; - gpointer _tmp394_; - ValaExpression* _tmp395_; + ValaList* _tmp402_; + gpointer _tmp403_; + ValaExpression* _tmp404_; _precondition_index = _precondition_index + 1; - _tmp391_ = _precondition_index; - _tmp392_ = _precondition_size; - if (!(_tmp391_ < _tmp392_)) { + _tmp400_ = _precondition_index; + _tmp401_ = _precondition_size; + if (!(_tmp400_ < _tmp401_)) { break; } - _tmp393_ = _precondition_list; - _tmp394_ = vala_list_get (_tmp393_, _precondition_index); - precondition = (ValaExpression*) _tmp394_; - _tmp395_ = precondition; - vala_code_node_check ((ValaCodeNode*) _tmp395_, context); + _tmp402_ = _precondition_list; + _tmp403_ = vala_list_get (_tmp402_, _precondition_index); + precondition = (ValaExpression*) _tmp403_; + _tmp404_ = precondition; + vala_code_node_check ((ValaCodeNode*) _tmp404_, context); _vala_code_node_unref0 (precondition); } } } - _tmp396_ = self->priv->postconditions; - if (_tmp396_ != NULL) { + _tmp405_ = self->priv->postconditions; + if (_tmp405_ != NULL) { { ValaList* _postcondition_list = NULL; - ValaList* _tmp397_; + ValaList* _tmp406_; gint _postcondition_size = 0; - ValaList* _tmp398_; - gint _tmp399_; - gint _tmp400_; + ValaList* _tmp407_; + gint _tmp408_; + gint _tmp409_; gint _postcondition_index = 0; - _tmp397_ = self->priv->postconditions; - _postcondition_list = _tmp397_; - _tmp398_ = _postcondition_list; - _tmp399_ = vala_collection_get_size ((ValaCollection*) _tmp398_); - _tmp400_ = _tmp399_; - _postcondition_size = _tmp400_; + _tmp406_ = self->priv->postconditions; + _postcondition_list = _tmp406_; + _tmp407_ = _postcondition_list; + _tmp408_ = vala_collection_get_size ((ValaCollection*) _tmp407_); + _tmp409_ = _tmp408_; + _postcondition_size = _tmp409_; _postcondition_index = -1; while (TRUE) { - gint _tmp401_; - gint _tmp402_; + gint _tmp410_; + gint _tmp411_; ValaExpression* postcondition = NULL; - ValaList* _tmp403_; - gpointer _tmp404_; - ValaExpression* _tmp405_; + ValaList* _tmp412_; + gpointer _tmp413_; + ValaExpression* _tmp414_; _postcondition_index = _postcondition_index + 1; - _tmp401_ = _postcondition_index; - _tmp402_ = _postcondition_size; - if (!(_tmp401_ < _tmp402_)) { + _tmp410_ = _postcondition_index; + _tmp411_ = _postcondition_size; + if (!(_tmp410_ < _tmp411_)) { break; } - _tmp403_ = _postcondition_list; - _tmp404_ = vala_list_get (_tmp403_, _postcondition_index); - postcondition = (ValaExpression*) _tmp404_; - _tmp405_ = postcondition; - vala_code_node_check ((ValaCodeNode*) _tmp405_, context); + _tmp412_ = _postcondition_list; + _tmp413_ = vala_list_get (_tmp412_, _postcondition_index); + postcondition = (ValaExpression*) _tmp413_; + _tmp414_ = postcondition; + vala_code_node_check ((ValaCodeNode*) _tmp414_, context); _vala_code_node_unref0 (postcondition); } } } - _tmp406_ = vala_subroutine_get_body ((ValaSubroutine*) self); - _tmp407_ = _tmp406_; - if (_tmp407_ != NULL) { - ValaBlock* _tmp408_; - ValaBlock* _tmp409_; - _tmp408_ = vala_subroutine_get_body ((ValaSubroutine*) self); - _tmp409_ = _tmp408_; - vala_code_node_check ((ValaCodeNode*) _tmp409_, context); - } - _tmp410_ = vala_code_context_get_analyzer (context); - _tmp411_ = _tmp410_; - _tmp412_ = vala_semantic_analyzer_get_current_struct (_tmp411_); - _tmp413_ = _tmp412_; - if (_tmp413_ != NULL) { - gboolean _tmp414_ = FALSE; - gboolean _tmp415_ = FALSE; - gboolean _tmp416_; - _tmp416_ = self->priv->_is_abstract; - if (_tmp416_) { - _tmp415_ = TRUE; + _tmp415_ = vala_subroutine_get_body ((ValaSubroutine*) self); + _tmp416_ = _tmp415_; + if (_tmp416_ != NULL) { + ValaBlock* _tmp417_; + ValaBlock* _tmp418_; + _tmp417_ = vala_subroutine_get_body ((ValaSubroutine*) self); + _tmp418_ = _tmp417_; + vala_code_node_check ((ValaCodeNode*) _tmp418_, context); + } + _tmp419_ = vala_code_context_get_analyzer (context); + _tmp420_ = _tmp419_; + _tmp421_ = vala_semantic_analyzer_get_current_struct (_tmp420_); + _tmp422_ = _tmp421_; + if (_tmp422_ != NULL) { + gboolean _tmp423_ = FALSE; + gboolean _tmp424_ = FALSE; + gboolean _tmp425_; + _tmp425_ = self->priv->_is_abstract; + if (_tmp425_) { + _tmp424_ = TRUE; } else { - gboolean _tmp417_; - _tmp417_ = self->priv->_is_virtual; - _tmp415_ = _tmp417_; + gboolean _tmp426_; + _tmp426_ = self->priv->_is_virtual; + _tmp424_ = _tmp426_; } - if (_tmp415_) { - _tmp414_ = TRUE; + if (_tmp424_) { + _tmp423_ = TRUE; } else { - gboolean _tmp418_; - _tmp418_ = self->priv->_overrides; - _tmp414_ = _tmp418_; - } - if (_tmp414_) { - ValaSourceReference* _tmp419_; - ValaSourceReference* _tmp420_; - gchar* _tmp421_; - gchar* _tmp422_; + gboolean _tmp427_; + _tmp427_ = self->priv->_overrides; + _tmp423_ = _tmp427_; + } + if (_tmp423_) { + ValaSourceReference* _tmp428_; + ValaSourceReference* _tmp429_; + gchar* _tmp430_; + gchar* _tmp431_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp419_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp420_ = _tmp419_; - _tmp421_ = vala_symbol_get_full_name ((ValaSymbol*) self); - _tmp422_ = _tmp421_; - vala_report_error (_tmp420_, "A struct member `%s' cannot be marked as override, virtual, or abstrac" \ -"t", _tmp422_); - _g_free0 (_tmp422_); + _tmp428_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp429_ = _tmp428_; + _tmp430_ = vala_symbol_get_full_name ((ValaSymbol*) self); + _tmp431_ = _tmp430_; + vala_report_error (_tmp429_, "A struct member `%s' cannot be marked as override, virtual, or abstrac" \ +"t", _tmp431_); + _g_free0 (_tmp431_); result = FALSE; _vala_code_node_unref0 (init_attr); _vala_code_node_unref0 (old_symbol); @@ -4075,131 +4104,131 @@ return result; } } else { - gboolean _tmp423_ = FALSE; - gboolean _tmp424_ = FALSE; - gboolean _tmp425_ = FALSE; - gboolean _tmp426_; - _tmp426_ = self->priv->_overrides; - if (_tmp426_) { - ValaMethod* _tmp427_; - ValaMethod* _tmp428_; - _tmp427_ = vala_method_get_base_method (self); - _tmp428_ = _tmp427_; - _tmp425_ = _tmp428_ == NULL; + gboolean _tmp432_ = FALSE; + gboolean _tmp433_ = FALSE; + gboolean _tmp434_ = FALSE; + gboolean _tmp435_; + _tmp435_ = self->priv->_overrides; + if (_tmp435_) { + ValaMethod* _tmp436_; + ValaMethod* _tmp437_; + _tmp436_ = vala_method_get_base_method (self); + _tmp437_ = _tmp436_; + _tmp434_ = _tmp437_ == NULL; } else { - _tmp425_ = FALSE; + _tmp434_ = FALSE; } - if (_tmp425_) { - ValaMethod* _tmp429_; - ValaMethod* _tmp430_; - _tmp429_ = vala_method_get_base_interface_method (self); - _tmp430_ = _tmp429_; - _tmp424_ = _tmp430_ != NULL; + if (_tmp434_) { + ValaMethod* _tmp438_; + ValaMethod* _tmp439_; + _tmp438_ = vala_method_get_base_interface_method (self); + _tmp439_ = _tmp438_; + _tmp433_ = _tmp439_ != NULL; } else { - _tmp424_ = FALSE; + _tmp433_ = FALSE; } - if (_tmp424_) { - ValaMethod* _tmp431_; - ValaMethod* _tmp432_; - gboolean _tmp433_; - _tmp431_ = vala_method_get_base_interface_method (self); - _tmp432_ = _tmp431_; - _tmp433_ = _tmp432_->priv->_is_abstract; - _tmp423_ = _tmp433_; + if (_tmp433_) { + ValaMethod* _tmp440_; + ValaMethod* _tmp441_; + gboolean _tmp442_; + _tmp440_ = vala_method_get_base_interface_method (self); + _tmp441_ = _tmp440_; + _tmp442_ = _tmp441_->priv->_is_abstract; + _tmp432_ = _tmp442_; } else { - _tmp423_ = FALSE; + _tmp432_ = FALSE; } - if (_tmp423_) { - ValaSourceReference* _tmp434_; - ValaSourceReference* _tmp435_; - ValaMethod* _tmp436_; - ValaMethod* _tmp437_; - gchar* _tmp438_; - gchar* _tmp439_; - _tmp434_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp435_ = _tmp434_; - _tmp436_ = vala_method_get_base_interface_method (self); - _tmp437_ = _tmp436_; - _tmp438_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp437_); - _tmp439_ = _tmp438_; - vala_report_warning (_tmp435_, "`override' not required to implement `abstract' interface method `%s'", _tmp439_); - _g_free0 (_tmp439_); + if (_tmp432_) { + ValaSourceReference* _tmp443_; + ValaSourceReference* _tmp444_; + ValaMethod* _tmp445_; + ValaMethod* _tmp446_; + gchar* _tmp447_; + gchar* _tmp448_; + _tmp443_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp444_ = _tmp443_; + _tmp445_ = vala_method_get_base_interface_method (self); + _tmp446_ = _tmp445_; + _tmp447_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp446_); + _tmp448_ = _tmp447_; + vala_report_warning (_tmp444_, "`override' not required to implement `abstract' interface method `%s'", _tmp448_); + _g_free0 (_tmp448_); vala_method_set_overrides (self, FALSE); } else { - gboolean _tmp440_ = FALSE; - gboolean _tmp441_ = FALSE; - gboolean _tmp442_; - _tmp442_ = self->priv->_overrides; - if (_tmp442_) { - ValaMethod* _tmp443_; - ValaMethod* _tmp444_; - _tmp443_ = vala_method_get_base_method (self); - _tmp444_ = _tmp443_; - _tmp441_ = _tmp444_ == NULL; + gboolean _tmp449_ = FALSE; + gboolean _tmp450_ = FALSE; + gboolean _tmp451_; + _tmp451_ = self->priv->_overrides; + if (_tmp451_) { + ValaMethod* _tmp452_; + ValaMethod* _tmp453_; + _tmp452_ = vala_method_get_base_method (self); + _tmp453_ = _tmp452_; + _tmp450_ = _tmp453_ == NULL; } else { - _tmp441_ = FALSE; + _tmp450_ = FALSE; } - if (_tmp441_) { - ValaMethod* _tmp445_; - ValaMethod* _tmp446_; - _tmp445_ = vala_method_get_base_interface_method (self); - _tmp446_ = _tmp445_; - _tmp440_ = _tmp446_ == NULL; + if (_tmp450_) { + ValaMethod* _tmp454_; + ValaMethod* _tmp455_; + _tmp454_ = vala_method_get_base_interface_method (self); + _tmp455_ = _tmp454_; + _tmp449_ = _tmp455_ == NULL; } else { - _tmp440_ = FALSE; + _tmp449_ = FALSE; } - if (_tmp440_) { - ValaSourceReference* _tmp447_; - ValaSourceReference* _tmp448_; - gchar* _tmp449_; - gchar* _tmp450_; - _tmp447_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp448_ = _tmp447_; - _tmp449_ = vala_symbol_get_full_name ((ValaSymbol*) self); - _tmp450_ = _tmp449_; - vala_report_error (_tmp448_, "`%s': no suitable method found to override", _tmp450_); - _g_free0 (_tmp450_); + if (_tmp449_) { + ValaSourceReference* _tmp456_; + ValaSourceReference* _tmp457_; + gchar* _tmp458_; + gchar* _tmp459_; + _tmp456_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp457_ = _tmp456_; + _tmp458_ = vala_symbol_get_full_name ((ValaSymbol*) self); + _tmp459_ = _tmp458_; + vala_report_error (_tmp457_, "`%s': no suitable method found to override", _tmp459_); + _g_free0 (_tmp459_); } else { - gboolean _tmp451_ = FALSE; - gboolean _tmp452_ = FALSE; - gboolean _tmp453_ = FALSE; - gboolean _tmp454_; - _tmp454_ = self->priv->_is_abstract; - if (_tmp454_) { - _tmp453_ = TRUE; + gboolean _tmp460_ = FALSE; + gboolean _tmp461_ = FALSE; + gboolean _tmp462_ = FALSE; + gboolean _tmp463_; + _tmp463_ = self->priv->_is_abstract; + if (_tmp463_) { + _tmp462_ = TRUE; } else { - gboolean _tmp455_; - _tmp455_ = self->priv->_is_virtual; - _tmp453_ = _tmp455_; + gboolean _tmp464_; + _tmp464_ = self->priv->_is_virtual; + _tmp462_ = _tmp464_; } - if (_tmp453_) { - _tmp452_ = TRUE; + if (_tmp462_) { + _tmp461_ = TRUE; } else { - gboolean _tmp456_; - _tmp456_ = self->priv->_overrides; - _tmp452_ = _tmp456_; - } - if (_tmp452_) { - ValaSymbolAccessibility _tmp457_; - ValaSymbolAccessibility _tmp458_; - _tmp457_ = vala_symbol_get_access ((ValaSymbol*) self); - _tmp458_ = _tmp457_; - _tmp451_ = _tmp458_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE; + gboolean _tmp465_; + _tmp465_ = self->priv->_overrides; + _tmp461_ = _tmp465_; + } + if (_tmp461_) { + ValaSymbolAccessibility _tmp466_; + ValaSymbolAccessibility _tmp467_; + _tmp466_ = vala_symbol_get_access ((ValaSymbol*) self); + _tmp467_ = _tmp466_; + _tmp460_ = _tmp467_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE; } else { - _tmp451_ = FALSE; + _tmp460_ = FALSE; } - if (_tmp451_) { - ValaSourceReference* _tmp459_; - ValaSourceReference* _tmp460_; - gchar* _tmp461_; - gchar* _tmp462_; + if (_tmp460_) { + ValaSourceReference* _tmp468_; + ValaSourceReference* _tmp469_; + gchar* _tmp470_; + gchar* _tmp471_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp459_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp460_ = _tmp459_; - _tmp461_ = vala_symbol_get_full_name ((ValaSymbol*) self); - _tmp462_ = _tmp461_; - vala_report_error (_tmp460_, "Private member `%s' cannot be marked as override, virtual, or abstract", _tmp462_); - _g_free0 (_tmp462_); + _tmp468_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp469_ = _tmp468_; + _tmp470_ = vala_symbol_get_full_name ((ValaSymbol*) self); + _tmp471_ = _tmp470_; + vala_report_error (_tmp469_, "Private member `%s' cannot be marked as override, virtual, or abstract", _tmp471_); + _g_free0 (_tmp471_); result = FALSE; _vala_code_node_unref0 (init_attr); _vala_code_node_unref0 (old_symbol); @@ -4209,128 +4238,128 @@ } } } - _tmp465_ = vala_method_get_base_interface_type (self); - _tmp466_ = _tmp465_; - if (_tmp466_ != NULL) { - ValaMethod* _tmp467_; - ValaMethod* _tmp468_; - _tmp467_ = vala_method_get_base_interface_method (self); - _tmp468_ = _tmp467_; - _tmp464_ = _tmp468_ != NULL; - } else { - _tmp464_ = FALSE; - } - if (_tmp464_) { - ValaSymbol* _tmp469_; - ValaSymbol* _tmp470_; - _tmp469_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp470_ = _tmp469_; - _tmp463_ = VALA_IS_CLASS (_tmp470_); + _tmp474_ = vala_method_get_base_interface_type (self); + _tmp475_ = _tmp474_; + if (_tmp475_ != NULL) { + ValaMethod* _tmp476_; + ValaMethod* _tmp477_; + _tmp476_ = vala_method_get_base_interface_method (self); + _tmp477_ = _tmp476_; + _tmp473_ = _tmp477_ != NULL; + } else { + _tmp473_ = FALSE; + } + if (_tmp473_) { + ValaSymbol* _tmp478_; + ValaSymbol* _tmp479_; + _tmp478_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp479_ = _tmp478_; + _tmp472_ = VALA_IS_CLASS (_tmp479_); } else { - _tmp463_ = FALSE; + _tmp472_ = FALSE; } - if (_tmp463_) { + if (_tmp472_) { ValaClass* cl = NULL; - ValaSymbol* _tmp471_; - ValaSymbol* _tmp472_; - _tmp471_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp472_ = _tmp471_; - cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp472_, VALA_TYPE_CLASS, ValaClass); + ValaSymbol* _tmp480_; + ValaSymbol* _tmp481_; + _tmp480_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp481_ = _tmp480_; + cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp481_, VALA_TYPE_CLASS, ValaClass); { ValaList* _m_list = NULL; - ValaClass* _tmp473_; - ValaList* _tmp474_; + ValaClass* _tmp482_; + ValaList* _tmp483_; gint _m_size = 0; - ValaList* _tmp475_; - gint _tmp476_; - gint _tmp477_; + ValaList* _tmp484_; + gint _tmp485_; + gint _tmp486_; gint _m_index = 0; - _tmp473_ = cl; - _tmp474_ = vala_object_type_symbol_get_methods ((ValaObjectTypeSymbol*) _tmp473_); - _m_list = _tmp474_; - _tmp475_ = _m_list; - _tmp476_ = vala_collection_get_size ((ValaCollection*) _tmp475_); - _tmp477_ = _tmp476_; - _m_size = _tmp477_; + _tmp482_ = cl; + _tmp483_ = vala_object_type_symbol_get_methods ((ValaObjectTypeSymbol*) _tmp482_); + _m_list = _tmp483_; + _tmp484_ = _m_list; + _tmp485_ = vala_collection_get_size ((ValaCollection*) _tmp484_); + _tmp486_ = _tmp485_; + _m_size = _tmp486_; _m_index = -1; while (TRUE) { - gint _tmp478_; - gint _tmp479_; + gint _tmp487_; + gint _tmp488_; ValaMethod* m = NULL; - ValaList* _tmp480_; - gpointer _tmp481_; - gboolean _tmp482_ = FALSE; - ValaMethod* _tmp483_; + ValaList* _tmp489_; + gpointer _tmp490_; + gboolean _tmp491_ = FALSE; + ValaMethod* _tmp492_; _m_index = _m_index + 1; - _tmp478_ = _m_index; - _tmp479_ = _m_size; - if (!(_tmp478_ < _tmp479_)) { + _tmp487_ = _m_index; + _tmp488_ = _m_size; + if (!(_tmp487_ < _tmp488_)) { break; } - _tmp480_ = _m_list; - _tmp481_ = vala_list_get (_tmp480_, _m_index); - m = (ValaMethod*) _tmp481_; - _tmp483_ = m; - if (_tmp483_ != self) { - ValaMethod* _tmp484_; - ValaMethod* _tmp485_; - ValaMethod* _tmp486_; - ValaMethod* _tmp487_; - ValaMethod* _tmp488_; - _tmp484_ = m; - _tmp485_ = vala_method_get_base_interface_method (_tmp484_); - _tmp486_ = _tmp485_; - _tmp487_ = vala_method_get_base_interface_method (self); - _tmp488_ = _tmp487_; - _tmp482_ = _tmp486_ == _tmp488_; - } else { - _tmp482_ = FALSE; - } - if (_tmp482_) { - ValaMethod* _tmp489_; - ValaMethod* _tmp490_; - ValaSourceReference* _tmp491_; - ValaSourceReference* _tmp492_; - ValaClass* _tmp493_; - gchar* _tmp494_; - gchar* _tmp495_; + _tmp489_ = _m_list; + _tmp490_ = vala_list_get (_tmp489_, _m_index); + m = (ValaMethod*) _tmp490_; + _tmp492_ = m; + if (_tmp492_ != self) { + ValaMethod* _tmp493_; + ValaMethod* _tmp494_; + ValaMethod* _tmp495_; ValaMethod* _tmp496_; ValaMethod* _tmp497_; - gchar* _tmp498_; - gchar* _tmp499_; - ValaMethod* _tmp500_; - ValaSourceReference* _tmp501_; - ValaSourceReference* _tmp502_; - ValaMethod* _tmp503_; - ValaMethod* _tmp504_; - gchar* _tmp505_; - gchar* _tmp506_; - _tmp489_ = m; - vala_code_node_set_checked ((ValaCodeNode*) _tmp489_, TRUE); - _tmp490_ = m; - vala_code_node_set_error ((ValaCodeNode*) _tmp490_, TRUE); - vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp491_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp492_ = _tmp491_; - _tmp493_ = cl; - _tmp494_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp493_); + _tmp493_ = m; + _tmp494_ = vala_method_get_base_interface_method (_tmp493_); _tmp495_ = _tmp494_; _tmp496_ = vala_method_get_base_interface_method (self); _tmp497_ = _tmp496_; - _tmp498_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp497_); - _tmp499_ = _tmp498_; - vala_report_error (_tmp492_, "`%s' already contains an implementation for `%s'", _tmp495_, _tmp499_); - _g_free0 (_tmp499_); - _g_free0 (_tmp495_); - _tmp500_ = m; - _tmp501_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp500_); - _tmp502_ = _tmp501_; - _tmp503_ = vala_method_get_base_interface_method (self); + _tmp491_ = _tmp495_ == _tmp497_; + } else { + _tmp491_ = FALSE; + } + if (_tmp491_) { + ValaMethod* _tmp498_; + ValaMethod* _tmp499_; + ValaSourceReference* _tmp500_; + ValaSourceReference* _tmp501_; + ValaClass* _tmp502_; + gchar* _tmp503_; + gchar* _tmp504_; + ValaMethod* _tmp505_; + ValaMethod* _tmp506_; + gchar* _tmp507_; + gchar* _tmp508_; + ValaMethod* _tmp509_; + ValaSourceReference* _tmp510_; + ValaSourceReference* _tmp511_; + ValaMethod* _tmp512_; + ValaMethod* _tmp513_; + gchar* _tmp514_; + gchar* _tmp515_; + _tmp498_ = m; + vala_code_node_set_checked ((ValaCodeNode*) _tmp498_, TRUE); + _tmp499_ = m; + vala_code_node_set_error ((ValaCodeNode*) _tmp499_, TRUE); + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp500_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp501_ = _tmp500_; + _tmp502_ = cl; + _tmp503_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp502_); _tmp504_ = _tmp503_; - _tmp505_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp504_); + _tmp505_ = vala_method_get_base_interface_method (self); _tmp506_ = _tmp505_; - vala_report_notice (_tmp502_, "previous implementation of `%s' was here", _tmp506_); - _g_free0 (_tmp506_); + _tmp507_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp506_); + _tmp508_ = _tmp507_; + vala_report_error (_tmp501_, "`%s' already contains an implementation for `%s'", _tmp504_, _tmp508_); + _g_free0 (_tmp508_); + _g_free0 (_tmp504_); + _tmp509_ = m; + _tmp510_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp509_); + _tmp511_ = _tmp510_; + _tmp512_ = vala_method_get_base_interface_method (self); + _tmp513_ = _tmp512_; + _tmp514_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp513_); + _tmp515_ = _tmp514_; + vala_report_notice (_tmp511_, "previous implementation of `%s' was here", _tmp515_); + _g_free0 (_tmp515_); result = FALSE; _vala_code_node_unref0 (m); _vala_code_node_unref0 (init_attr); @@ -4342,90 +4371,90 @@ } } } - _tmp507_ = vala_code_context_get_analyzer (context); - _tmp508_ = _tmp507_; - _tmp509_ = old_source_file; - vala_semantic_analyzer_set_current_source_file (_tmp508_, _tmp509_); - _tmp510_ = vala_code_context_get_analyzer (context); - _tmp511_ = _tmp510_; - _tmp512_ = old_symbol; - vala_semantic_analyzer_set_current_symbol (_tmp511_, _tmp512_); - _tmp516_ = vala_symbol_get_external_package ((ValaSymbol*) self); + _tmp516_ = vala_code_context_get_analyzer (context); _tmp517_ = _tmp516_; - if (!_tmp517_) { - gboolean _tmp518_; - _tmp518_ = self->priv->_overrides; - _tmp515_ = !_tmp518_; - } else { - _tmp515_ = FALSE; - } - if (_tmp515_) { - gboolean _tmp519_; - gboolean _tmp520_; - _tmp519_ = vala_symbol_get_hides ((ValaSymbol*) self); - _tmp520_ = _tmp519_; - _tmp514_ = !_tmp520_; - } else { - _tmp514_ = FALSE; - } - if (_tmp514_) { - ValaSymbol* _tmp521_; - ValaSymbol* _tmp522_; - _tmp521_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); - _tmp522_ = _tmp521_; - _tmp513_ = _tmp522_ != NULL; - _vala_code_node_unref0 (_tmp522_); - } else { - _tmp513_ = FALSE; - } - if (_tmp513_) { - ValaSourceReference* _tmp523_; - ValaSourceReference* _tmp524_; - gchar* _tmp525_; - gchar* _tmp526_; - ValaSymbol* _tmp527_; - ValaSymbol* _tmp528_; - gchar* _tmp529_; - gchar* _tmp530_; - _tmp523_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp524_ = _tmp523_; - _tmp525_ = vala_symbol_get_full_name ((ValaSymbol*) self); - _tmp526_ = _tmp525_; - _tmp527_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); - _tmp528_ = _tmp527_; - _tmp529_ = vala_symbol_get_full_name (_tmp528_); - _tmp530_ = _tmp529_; - vala_report_warning (_tmp524_, "%s hides inherited method `%s'. Use the `new' keyword if hiding was in" \ -"tentional", _tmp526_, _tmp530_); - _g_free0 (_tmp530_); - _vala_code_node_unref0 (_tmp528_); - _g_free0 (_tmp526_); - } - _tmp531_ = vala_code_context_get_analyzer (context); - _tmp532_ = _tmp531_; - _tmp533_ = vala_callable_get_return_type ((ValaCallable*) self); - _tmp534_ = _tmp533_; - if (!vala_semantic_analyzer_is_type_accessible (_tmp532_, (ValaSymbol*) self, _tmp534_)) { - ValaSourceReference* _tmp535_; - ValaSourceReference* _tmp536_; - ValaDataType* _tmp537_; - ValaDataType* _tmp538_; + _tmp518_ = old_source_file; + vala_semantic_analyzer_set_current_source_file (_tmp517_, _tmp518_); + _tmp519_ = vala_code_context_get_analyzer (context); + _tmp520_ = _tmp519_; + _tmp521_ = old_symbol; + vala_semantic_analyzer_set_current_symbol (_tmp520_, _tmp521_); + _tmp525_ = vala_symbol_get_external_package ((ValaSymbol*) self); + _tmp526_ = _tmp525_; + if (!_tmp526_) { + gboolean _tmp527_; + _tmp527_ = self->priv->_overrides; + _tmp524_ = !_tmp527_; + } else { + _tmp524_ = FALSE; + } + if (_tmp524_) { + gboolean _tmp528_; + gboolean _tmp529_; + _tmp528_ = vala_symbol_get_hides ((ValaSymbol*) self); + _tmp529_ = _tmp528_; + _tmp523_ = !_tmp529_; + } else { + _tmp523_ = FALSE; + } + if (_tmp523_) { + ValaSymbol* _tmp530_; + ValaSymbol* _tmp531_; + _tmp530_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); + _tmp531_ = _tmp530_; + _tmp522_ = _tmp531_ != NULL; + _vala_code_node_unref0 (_tmp531_); + } else { + _tmp522_ = FALSE; + } + if (_tmp522_) { + ValaSourceReference* _tmp532_; + ValaSourceReference* _tmp533_; + gchar* _tmp534_; + gchar* _tmp535_; + ValaSymbol* _tmp536_; + ValaSymbol* _tmp537_; + gchar* _tmp538_; gchar* _tmp539_; - gchar* _tmp540_; - gchar* _tmp541_; - gchar* _tmp542_; + _tmp532_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp533_ = _tmp532_; + _tmp534_ = vala_symbol_get_full_name ((ValaSymbol*) self); + _tmp535_ = _tmp534_; + _tmp536_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); + _tmp537_ = _tmp536_; + _tmp538_ = vala_symbol_get_full_name (_tmp537_); + _tmp539_ = _tmp538_; + vala_report_warning (_tmp533_, "%s hides inherited method `%s'. Use the `new' keyword if hiding was in" \ +"tentional", _tmp535_, _tmp539_); + _g_free0 (_tmp539_); + _vala_code_node_unref0 (_tmp537_); + _g_free0 (_tmp535_); + } + _tmp540_ = vala_code_context_get_analyzer (context); + _tmp541_ = _tmp540_; + _tmp542_ = vala_callable_get_return_type ((ValaCallable*) self); + _tmp543_ = _tmp542_; + if (!vala_semantic_analyzer_is_type_accessible (_tmp541_, (ValaSymbol*) self, _tmp543_)) { + ValaSourceReference* _tmp544_; + ValaSourceReference* _tmp545_; + ValaDataType* _tmp546_; + ValaDataType* _tmp547_; + gchar* _tmp548_; + gchar* _tmp549_; + gchar* _tmp550_; + gchar* _tmp551_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp535_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp536_ = _tmp535_; - _tmp537_ = vala_callable_get_return_type ((ValaCallable*) self); - _tmp538_ = _tmp537_; - _tmp539_ = vala_code_node_to_string ((ValaCodeNode*) _tmp538_); - _tmp540_ = _tmp539_; - _tmp541_ = vala_symbol_get_full_name ((ValaSymbol*) self); - _tmp542_ = _tmp541_; - vala_report_error (_tmp536_, "return type `%s' is less accessible than method `%s'", _tmp540_, _tmp542_); - _g_free0 (_tmp542_); - _g_free0 (_tmp540_); + _tmp544_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp545_ = _tmp544_; + _tmp546_ = vala_callable_get_return_type ((ValaCallable*) self); + _tmp547_ = _tmp546_; + _tmp548_ = vala_code_node_to_string ((ValaCodeNode*) _tmp547_); + _tmp549_ = _tmp548_; + _tmp550_ = vala_symbol_get_full_name ((ValaSymbol*) self); + _tmp551_ = _tmp550_; + vala_report_error (_tmp545_, "return type `%s' is less accessible than method `%s'", _tmp549_, _tmp551_); + _g_free0 (_tmp551_); + _g_free0 (_tmp549_); result = FALSE; _vala_code_node_unref0 (init_attr); _vala_code_node_unref0 (old_symbol); @@ -4434,47 +4463,47 @@ } { ValaList* _precondition_list = NULL; - ValaList* _tmp543_; + ValaList* _tmp552_; gint _precondition_size = 0; - ValaList* _tmp544_; - gint _tmp545_; - gint _tmp546_; + ValaList* _tmp553_; + gint _tmp554_; + gint _tmp555_; gint _precondition_index = 0; - _tmp543_ = vala_method_get_preconditions (self); - _precondition_list = _tmp543_; - _tmp544_ = _precondition_list; - _tmp545_ = vala_collection_get_size ((ValaCollection*) _tmp544_); - _tmp546_ = _tmp545_; - _precondition_size = _tmp546_; + _tmp552_ = vala_method_get_preconditions (self); + _precondition_list = _tmp552_; + _tmp553_ = _precondition_list; + _tmp554_ = vala_collection_get_size ((ValaCollection*) _tmp553_); + _tmp555_ = _tmp554_; + _precondition_size = _tmp555_; _precondition_index = -1; while (TRUE) { - gint _tmp547_; - gint _tmp548_; + gint _tmp556_; + gint _tmp557_; ValaExpression* precondition = NULL; - ValaList* _tmp549_; - gpointer _tmp550_; - ValaExpression* _tmp551_; - gboolean _tmp552_; - gboolean _tmp553_; - ValaExpression* _tmp554_; - ValaDataType* _tmp555_; - ValaDataType* _tmp556_; - ValaSemanticAnalyzer* _tmp557_; - ValaSemanticAnalyzer* _tmp558_; - ValaDataType* _tmp559_; + ValaList* _tmp558_; + gpointer _tmp559_; + ValaExpression* _tmp560_; + gboolean _tmp561_; + gboolean _tmp562_; + ValaExpression* _tmp563_; + ValaDataType* _tmp564_; + ValaDataType* _tmp565_; + ValaSemanticAnalyzer* _tmp566_; + ValaSemanticAnalyzer* _tmp567_; + ValaDataType* _tmp568_; _precondition_index = _precondition_index + 1; - _tmp547_ = _precondition_index; - _tmp548_ = _precondition_size; - if (!(_tmp547_ < _tmp548_)) { + _tmp556_ = _precondition_index; + _tmp557_ = _precondition_size; + if (!(_tmp556_ < _tmp557_)) { break; } - _tmp549_ = _precondition_list; - _tmp550_ = vala_list_get (_tmp549_, _precondition_index); - precondition = (ValaExpression*) _tmp550_; - _tmp551_ = precondition; - _tmp552_ = vala_code_node_get_error ((ValaCodeNode*) _tmp551_); - _tmp553_ = _tmp552_; - if (_tmp553_) { + _tmp558_ = _precondition_list; + _tmp559_ = vala_list_get (_tmp558_, _precondition_index); + precondition = (ValaExpression*) _tmp559_; + _tmp560_ = precondition; + _tmp561_ = vala_code_node_get_error ((ValaCodeNode*) _tmp560_); + _tmp562_ = _tmp561_; + if (_tmp562_) { vala_code_node_set_error ((ValaCodeNode*) self, TRUE); result = FALSE; _vala_code_node_unref0 (precondition); @@ -4483,21 +4512,21 @@ _vala_source_file_unref0 (old_source_file); return result; } - _tmp554_ = precondition; - _tmp555_ = vala_expression_get_value_type (_tmp554_); - _tmp556_ = _tmp555_; - _tmp557_ = vala_code_context_get_analyzer (context); - _tmp558_ = _tmp557_; - _tmp559_ = _tmp558_->bool_type; - if (!vala_data_type_compatible (_tmp556_, _tmp559_)) { - ValaExpression* _tmp560_; - ValaSourceReference* _tmp561_; - ValaSourceReference* _tmp562_; + _tmp563_ = precondition; + _tmp564_ = vala_expression_get_value_type (_tmp563_); + _tmp565_ = _tmp564_; + _tmp566_ = vala_code_context_get_analyzer (context); + _tmp567_ = _tmp566_; + _tmp568_ = _tmp567_->bool_type; + if (!vala_data_type_compatible (_tmp565_, _tmp568_)) { + ValaExpression* _tmp569_; + ValaSourceReference* _tmp570_; + ValaSourceReference* _tmp571_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp560_ = precondition; - _tmp561_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp560_); - _tmp562_ = _tmp561_; - vala_report_error (_tmp562_, "Precondition must be boolean"); + _tmp569_ = precondition; + _tmp570_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp569_); + _tmp571_ = _tmp570_; + vala_report_error (_tmp571_, "Precondition must be boolean"); result = FALSE; _vala_code_node_unref0 (precondition); _vala_code_node_unref0 (init_attr); @@ -4510,47 +4539,47 @@ } { ValaList* _postcondition_list = NULL; - ValaList* _tmp563_; + ValaList* _tmp572_; gint _postcondition_size = 0; - ValaList* _tmp564_; - gint _tmp565_; - gint _tmp566_; + ValaList* _tmp573_; + gint _tmp574_; + gint _tmp575_; gint _postcondition_index = 0; - _tmp563_ = vala_method_get_postconditions (self); - _postcondition_list = _tmp563_; - _tmp564_ = _postcondition_list; - _tmp565_ = vala_collection_get_size ((ValaCollection*) _tmp564_); - _tmp566_ = _tmp565_; - _postcondition_size = _tmp566_; + _tmp572_ = vala_method_get_postconditions (self); + _postcondition_list = _tmp572_; + _tmp573_ = _postcondition_list; + _tmp574_ = vala_collection_get_size ((ValaCollection*) _tmp573_); + _tmp575_ = _tmp574_; + _postcondition_size = _tmp575_; _postcondition_index = -1; while (TRUE) { - gint _tmp567_; - gint _tmp568_; + gint _tmp576_; + gint _tmp577_; ValaExpression* postcondition = NULL; - ValaList* _tmp569_; - gpointer _tmp570_; - ValaExpression* _tmp571_; - gboolean _tmp572_; - gboolean _tmp573_; - ValaExpression* _tmp574_; - ValaDataType* _tmp575_; - ValaDataType* _tmp576_; - ValaSemanticAnalyzer* _tmp577_; - ValaSemanticAnalyzer* _tmp578_; - ValaDataType* _tmp579_; + ValaList* _tmp578_; + gpointer _tmp579_; + ValaExpression* _tmp580_; + gboolean _tmp581_; + gboolean _tmp582_; + ValaExpression* _tmp583_; + ValaDataType* _tmp584_; + ValaDataType* _tmp585_; + ValaSemanticAnalyzer* _tmp586_; + ValaSemanticAnalyzer* _tmp587_; + ValaDataType* _tmp588_; _postcondition_index = _postcondition_index + 1; - _tmp567_ = _postcondition_index; - _tmp568_ = _postcondition_size; - if (!(_tmp567_ < _tmp568_)) { + _tmp576_ = _postcondition_index; + _tmp577_ = _postcondition_size; + if (!(_tmp576_ < _tmp577_)) { break; } - _tmp569_ = _postcondition_list; - _tmp570_ = vala_list_get (_tmp569_, _postcondition_index); - postcondition = (ValaExpression*) _tmp570_; - _tmp571_ = postcondition; - _tmp572_ = vala_code_node_get_error ((ValaCodeNode*) _tmp571_); - _tmp573_ = _tmp572_; - if (_tmp573_) { + _tmp578_ = _postcondition_list; + _tmp579_ = vala_list_get (_tmp578_, _postcondition_index); + postcondition = (ValaExpression*) _tmp579_; + _tmp580_ = postcondition; + _tmp581_ = vala_code_node_get_error ((ValaCodeNode*) _tmp580_); + _tmp582_ = _tmp581_; + if (_tmp582_) { vala_code_node_set_error ((ValaCodeNode*) self, TRUE); result = FALSE; _vala_code_node_unref0 (postcondition); @@ -4559,21 +4588,21 @@ _vala_source_file_unref0 (old_source_file); return result; } - _tmp574_ = postcondition; - _tmp575_ = vala_expression_get_value_type (_tmp574_); - _tmp576_ = _tmp575_; - _tmp577_ = vala_code_context_get_analyzer (context); - _tmp578_ = _tmp577_; - _tmp579_ = _tmp578_->bool_type; - if (!vala_data_type_compatible (_tmp576_, _tmp579_)) { - ValaExpression* _tmp580_; - ValaSourceReference* _tmp581_; - ValaSourceReference* _tmp582_; + _tmp583_ = postcondition; + _tmp584_ = vala_expression_get_value_type (_tmp583_); + _tmp585_ = _tmp584_; + _tmp586_ = vala_code_context_get_analyzer (context); + _tmp587_ = _tmp586_; + _tmp588_ = _tmp587_->bool_type; + if (!vala_data_type_compatible (_tmp585_, _tmp588_)) { + ValaExpression* _tmp589_; + ValaSourceReference* _tmp590_; + ValaSourceReference* _tmp591_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp580_ = postcondition; - _tmp581_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp580_); - _tmp582_ = _tmp581_; - vala_report_error (_tmp582_, "Postcondition must be boolean"); + _tmp589_ = postcondition; + _tmp590_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp589_); + _tmp591_ = _tmp590_; + vala_report_error (_tmp591_, "Postcondition must be boolean"); result = FALSE; _vala_code_node_unref0 (postcondition); _vala_code_node_unref0 (init_attr); @@ -4584,148 +4613,148 @@ _vala_code_node_unref0 (postcondition); } } - _tmp584_ = vala_subroutine_get_body ((ValaSubroutine*) self); - _tmp585_ = _tmp584_; - if (_tmp585_ != NULL) { - ValaBlock* _tmp586_; - ValaBlock* _tmp587_; - gboolean _tmp588_; - gboolean _tmp589_; - _tmp586_ = vala_subroutine_get_body ((ValaSubroutine*) self); - _tmp587_ = _tmp586_; - _tmp588_ = vala_code_node_get_error ((ValaCodeNode*) _tmp587_); - _tmp589_ = _tmp588_; - _tmp583_ = !_tmp589_; + _tmp593_ = vala_subroutine_get_body ((ValaSubroutine*) self); + _tmp594_ = _tmp593_; + if (_tmp594_ != NULL) { + ValaBlock* _tmp595_; + ValaBlock* _tmp596_; + gboolean _tmp597_; + gboolean _tmp598_; + _tmp595_ = vala_subroutine_get_body ((ValaSubroutine*) self); + _tmp596_ = _tmp595_; + _tmp597_ = vala_code_node_get_error ((ValaCodeNode*) _tmp596_); + _tmp598_ = _tmp597_; + _tmp592_ = !_tmp598_; } else { - _tmp583_ = FALSE; + _tmp592_ = FALSE; } - if (_tmp583_) { + if (_tmp592_) { ValaArrayList* body_errors = NULL; - GEqualFunc _tmp590_; - ValaArrayList* _tmp591_; - ValaBlock* _tmp592_; - ValaBlock* _tmp593_; - ValaArrayList* _tmp594_; - _tmp590_ = g_direct_equal; - _tmp591_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp590_); - body_errors = _tmp591_; - _tmp592_ = vala_subroutine_get_body ((ValaSubroutine*) self); - _tmp593_ = _tmp592_; - _tmp594_ = body_errors; - vala_code_node_get_error_types ((ValaCodeNode*) _tmp593_, (ValaCollection*) _tmp594_, NULL); + GEqualFunc _tmp599_; + ValaArrayList* _tmp600_; + ValaBlock* _tmp601_; + ValaBlock* _tmp602_; + ValaArrayList* _tmp603_; + _tmp599_ = g_direct_equal; + _tmp600_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp599_); + body_errors = _tmp600_; + _tmp601_ = vala_subroutine_get_body ((ValaSubroutine*) self); + _tmp602_ = _tmp601_; + _tmp603_ = body_errors; + vala_code_node_get_error_types ((ValaCodeNode*) _tmp602_, (ValaCollection*) _tmp603_, NULL); { ValaArrayList* _body_error_type_list = NULL; - ValaArrayList* _tmp595_; + ValaArrayList* _tmp604_; gint _body_error_type_size = 0; - ValaArrayList* _tmp596_; - gint _tmp597_; - gint _tmp598_; + ValaArrayList* _tmp605_; + gint _tmp606_; + gint _tmp607_; gint _body_error_type_index = 0; - _tmp595_ = body_errors; - _body_error_type_list = _tmp595_; - _tmp596_ = _body_error_type_list; - _tmp597_ = vala_collection_get_size ((ValaCollection*) _tmp596_); - _tmp598_ = _tmp597_; - _body_error_type_size = _tmp598_; + _tmp604_ = body_errors; + _body_error_type_list = _tmp604_; + _tmp605_ = _body_error_type_list; + _tmp606_ = vala_collection_get_size ((ValaCollection*) _tmp605_); + _tmp607_ = _tmp606_; + _body_error_type_size = _tmp607_; _body_error_type_index = -1; while (TRUE) { - gint _tmp599_; - gint _tmp600_; + gint _tmp608_; + gint _tmp609_; ValaDataType* body_error_type = NULL; - ValaArrayList* _tmp601_; - gpointer _tmp602_; + ValaArrayList* _tmp610_; + gpointer _tmp611_; gboolean can_propagate_error = FALSE; - ValaList* _tmp603_; - gboolean _tmp614_ = FALSE; - ValaDataType* _tmp615_; + ValaList* _tmp612_; + gboolean _tmp623_ = FALSE; + ValaDataType* _tmp624_; gboolean is_dynamic_error = FALSE; - gboolean _tmp619_ = FALSE; + gboolean _tmp628_ = FALSE; _body_error_type_index = _body_error_type_index + 1; - _tmp599_ = _body_error_type_index; - _tmp600_ = _body_error_type_size; - if (!(_tmp599_ < _tmp600_)) { + _tmp608_ = _body_error_type_index; + _tmp609_ = _body_error_type_size; + if (!(_tmp608_ < _tmp609_)) { break; } - _tmp601_ = _body_error_type_list; - _tmp602_ = vala_list_get ((ValaList*) _tmp601_, _body_error_type_index); - body_error_type = (ValaDataType*) _tmp602_; + _tmp610_ = _body_error_type_list; + _tmp611_ = vala_list_get ((ValaList*) _tmp610_, _body_error_type_index); + body_error_type = (ValaDataType*) _tmp611_; can_propagate_error = FALSE; - _tmp603_ = self->error_types; - if (_tmp603_ != NULL) { + _tmp612_ = self->error_types; + if (_tmp612_ != NULL) { { ValaList* _method_error_type_list = NULL; - ValaList* _tmp604_; + ValaList* _tmp613_; gint _method_error_type_size = 0; - ValaList* _tmp605_; - gint _tmp606_; - gint _tmp607_; + ValaList* _tmp614_; + gint _tmp615_; + gint _tmp616_; gint _method_error_type_index = 0; - _tmp604_ = self->error_types; - _method_error_type_list = _tmp604_; - _tmp605_ = _method_error_type_list; - _tmp606_ = vala_collection_get_size ((ValaCollection*) _tmp605_); - _tmp607_ = _tmp606_; - _method_error_type_size = _tmp607_; + _tmp613_ = self->error_types; + _method_error_type_list = _tmp613_; + _tmp614_ = _method_error_type_list; + _tmp615_ = vala_collection_get_size ((ValaCollection*) _tmp614_); + _tmp616_ = _tmp615_; + _method_error_type_size = _tmp616_; _method_error_type_index = -1; while (TRUE) { - gint _tmp608_; - gint _tmp609_; + gint _tmp617_; + gint _tmp618_; ValaDataType* method_error_type = NULL; - ValaList* _tmp610_; - gpointer _tmp611_; - ValaDataType* _tmp612_; - ValaDataType* _tmp613_; + ValaList* _tmp619_; + gpointer _tmp620_; + ValaDataType* _tmp621_; + ValaDataType* _tmp622_; _method_error_type_index = _method_error_type_index + 1; - _tmp608_ = _method_error_type_index; - _tmp609_ = _method_error_type_size; - if (!(_tmp608_ < _tmp609_)) { + _tmp617_ = _method_error_type_index; + _tmp618_ = _method_error_type_size; + if (!(_tmp617_ < _tmp618_)) { break; } - _tmp610_ = _method_error_type_list; - _tmp611_ = vala_list_get (_tmp610_, _method_error_type_index); - method_error_type = (ValaDataType*) _tmp611_; - _tmp612_ = body_error_type; - _tmp613_ = method_error_type; - if (vala_data_type_compatible (_tmp612_, _tmp613_)) { + _tmp619_ = _method_error_type_list; + _tmp620_ = vala_list_get (_tmp619_, _method_error_type_index); + method_error_type = (ValaDataType*) _tmp620_; + _tmp621_ = body_error_type; + _tmp622_ = method_error_type; + if (vala_data_type_compatible (_tmp621_, _tmp622_)) { can_propagate_error = TRUE; } _vala_code_node_unref0 (method_error_type); } } } - _tmp615_ = body_error_type; - if (VALA_IS_ERROR_TYPE (_tmp615_)) { - ValaDataType* _tmp616_; - gboolean _tmp617_; - gboolean _tmp618_; - _tmp616_ = body_error_type; - _tmp617_ = vala_error_type_get_dynamic_error (G_TYPE_CHECK_INSTANCE_CAST (_tmp616_, VALA_TYPE_ERROR_TYPE, ValaErrorType)); - _tmp618_ = _tmp617_; - _tmp614_ = _tmp618_; + _tmp624_ = body_error_type; + if (VALA_IS_ERROR_TYPE (_tmp624_)) { + ValaDataType* _tmp625_; + gboolean _tmp626_; + gboolean _tmp627_; + _tmp625_ = body_error_type; + _tmp626_ = vala_error_type_get_dynamic_error (G_TYPE_CHECK_INSTANCE_CAST (_tmp625_, VALA_TYPE_ERROR_TYPE, ValaErrorType)); + _tmp627_ = _tmp626_; + _tmp623_ = _tmp627_; } else { - _tmp614_ = FALSE; + _tmp623_ = FALSE; } - is_dynamic_error = _tmp614_; + is_dynamic_error = _tmp623_; if (!can_propagate_error) { - _tmp619_ = !is_dynamic_error; + _tmp628_ = !is_dynamic_error; } else { - _tmp619_ = FALSE; + _tmp628_ = FALSE; } - if (_tmp619_) { - ValaDataType* _tmp620_; - ValaSourceReference* _tmp621_; - ValaSourceReference* _tmp622_; - ValaDataType* _tmp623_; - gchar* _tmp624_; - gchar* _tmp625_; - _tmp620_ = body_error_type; - _tmp621_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp620_); - _tmp622_ = _tmp621_; - _tmp623_ = body_error_type; - _tmp624_ = vala_code_node_to_string ((ValaCodeNode*) _tmp623_); - _tmp625_ = _tmp624_; - vala_report_warning (_tmp622_, "unhandled error `%s'", _tmp625_); - _g_free0 (_tmp625_); + if (_tmp628_) { + ValaDataType* _tmp629_; + ValaSourceReference* _tmp630_; + ValaSourceReference* _tmp631_; + ValaDataType* _tmp632_; + gchar* _tmp633_; + gchar* _tmp634_; + _tmp629_ = body_error_type; + _tmp630_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp629_); + _tmp631_ = _tmp630_; + _tmp632_ = body_error_type; + _tmp633_ = vala_code_node_to_string ((ValaCodeNode*) _tmp632_); + _tmp634_ = _tmp633_; + vala_report_warning (_tmp631_, "unhandled error `%s'", _tmp634_); + _g_free0 (_tmp634_); } _vala_code_node_unref0 (body_error_type); } @@ -4733,147 +4762,147 @@ _vala_iterable_unref0 (body_errors); } if (!VALA_IS_CREATION_METHOD (self)) { - ValaMemberBinding _tmp631_; - _tmp631_ = self->priv->_binding; - _tmp630_ = _tmp631_ == VALA_MEMBER_BINDING_INSTANCE; - } else { - _tmp630_ = FALSE; - } - if (_tmp630_) { - gboolean _tmp632_; - _tmp632_ = self->priv->_overrides; - _tmp629_ = !_tmp632_; - } else { - _tmp629_ = FALSE; - } - if (_tmp629_) { - ValaSymbolAccessibility _tmp633_; - ValaSymbolAccessibility _tmp634_; - _tmp633_ = vala_symbol_get_access ((ValaSymbol*) self); - _tmp634_ = _tmp633_; - _tmp628_ = _tmp634_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC; - } else { - _tmp628_ = FALSE; - } - if (_tmp628_) { - ValaSymbol* _tmp635_; - ValaSymbol* _tmp636_; - _tmp635_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp636_ = _tmp635_; - _tmp627_ = VALA_IS_OBJECT_TYPE_SYMBOL (_tmp636_); - } else { - _tmp627_ = FALSE; - } - if (_tmp627_) { - ValaSymbol* _tmp637_; - ValaSymbol* _tmp638_; - ValaAttribute* _tmp639_; - _tmp637_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp638_ = _tmp637_; - _tmp639_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp638_, "DBus"); - _tmp626_ = _tmp639_ != NULL; + ValaMemberBinding _tmp640_; + _tmp640_ = self->priv->_binding; + _tmp639_ = _tmp640_ == VALA_MEMBER_BINDING_INSTANCE; + } else { + _tmp639_ = FALSE; + } + if (_tmp639_) { + gboolean _tmp641_; + _tmp641_ = self->priv->_overrides; + _tmp638_ = !_tmp641_; + } else { + _tmp638_ = FALSE; + } + if (_tmp638_) { + ValaSymbolAccessibility _tmp642_; + ValaSymbolAccessibility _tmp643_; + _tmp642_ = vala_symbol_get_access ((ValaSymbol*) self); + _tmp643_ = _tmp642_; + _tmp637_ = _tmp643_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC; + } else { + _tmp637_ = FALSE; + } + if (_tmp637_) { + ValaSymbol* _tmp644_; + ValaSymbol* _tmp645_; + _tmp644_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp645_ = _tmp644_; + _tmp636_ = VALA_IS_OBJECT_TYPE_SYMBOL (_tmp645_); + } else { + _tmp636_ = FALSE; + } + if (_tmp636_) { + ValaSymbol* _tmp646_; + ValaSymbol* _tmp647_; + ValaAttribute* _tmp648_; + _tmp646_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp647_ = _tmp646_; + _tmp648_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp647_, "DBus"); + _tmp635_ = _tmp648_ != NULL; } else { - _tmp626_ = FALSE; + _tmp635_ = FALSE; } - if (_tmp626_) { + if (_tmp635_) { ValaAttribute* dbus_attr = NULL; - ValaAttribute* _tmp640_; - ValaAttribute* _tmp641_; - gboolean _tmp642_ = FALSE; - ValaAttribute* _tmp643_; - _tmp640_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "DBus"); - _tmp641_ = _vala_code_node_ref0 (_tmp640_); - dbus_attr = _tmp641_; - _tmp643_ = dbus_attr; - if (_tmp643_ == NULL) { - _tmp642_ = TRUE; + ValaAttribute* _tmp649_; + ValaAttribute* _tmp650_; + gboolean _tmp651_ = FALSE; + ValaAttribute* _tmp652_; + _tmp649_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "DBus"); + _tmp650_ = _vala_code_node_ref0 (_tmp649_); + dbus_attr = _tmp650_; + _tmp652_ = dbus_attr; + if (_tmp652_ == NULL) { + _tmp651_ = TRUE; } else { - ValaAttribute* _tmp644_; - _tmp644_ = dbus_attr; - _tmp642_ = vala_attribute_get_bool (_tmp644_, "visible", TRUE); + ValaAttribute* _tmp653_; + _tmp653_ = dbus_attr; + _tmp651_ = vala_attribute_get_bool (_tmp653_, "visible", TRUE); } - if (_tmp642_) { + if (_tmp651_) { gboolean throws_gerror = FALSE; gboolean throws_gioerror = FALSE; gboolean throws_gdbuserror = FALSE; ValaArrayList* error_types = NULL; - GEqualFunc _tmp645_; - ValaArrayList* _tmp646_; - ValaArrayList* _tmp647_; - gboolean _tmp665_ = FALSE; + GEqualFunc _tmp654_; + ValaArrayList* _tmp655_; + ValaArrayList* _tmp656_; + gboolean _tmp674_ = FALSE; throws_gerror = FALSE; throws_gioerror = FALSE; throws_gdbuserror = FALSE; - _tmp645_ = g_direct_equal; - _tmp646_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp645_); - error_types = _tmp646_; - _tmp647_ = error_types; - vala_code_node_get_error_types ((ValaCodeNode*) self, (ValaCollection*) _tmp647_, NULL); + _tmp654_ = g_direct_equal; + _tmp655_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp654_); + error_types = _tmp655_; + _tmp656_ = error_types; + vala_code_node_get_error_types ((ValaCodeNode*) self, (ValaCollection*) _tmp656_, NULL); { ValaArrayList* _error_type_list = NULL; - ValaArrayList* _tmp648_; + ValaArrayList* _tmp657_; gint _error_type_size = 0; - ValaArrayList* _tmp649_; - gint _tmp650_; - gint _tmp651_; + ValaArrayList* _tmp658_; + gint _tmp659_; + gint _tmp660_; gint _error_type_index = 0; - _tmp648_ = error_types; - _error_type_list = _tmp648_; - _tmp649_ = _error_type_list; - _tmp650_ = vala_collection_get_size ((ValaCollection*) _tmp649_); - _tmp651_ = _tmp650_; - _error_type_size = _tmp651_; + _tmp657_ = error_types; + _error_type_list = _tmp657_; + _tmp658_ = _error_type_list; + _tmp659_ = vala_collection_get_size ((ValaCollection*) _tmp658_); + _tmp660_ = _tmp659_; + _error_type_size = _tmp660_; _error_type_index = -1; while (TRUE) { - gint _tmp652_; - gint _tmp653_; + gint _tmp661_; + gint _tmp662_; ValaDataType* error_type = NULL; - ValaArrayList* _tmp654_; - gpointer _tmp655_; - ValaDataType* _tmp656_; + ValaArrayList* _tmp663_; + gpointer _tmp664_; + ValaDataType* _tmp665_; ValaErrorDomain* error_domain = NULL; - ValaDataType* _tmp657_; - ValaErrorDomain* _tmp658_; - ValaErrorDomain* _tmp659_; - ValaErrorDomain* _tmp660_; + ValaDataType* _tmp666_; + ValaErrorDomain* _tmp667_; + ValaErrorDomain* _tmp668_; + ValaErrorDomain* _tmp669_; gchar* full_error_domain = NULL; - ValaErrorDomain* _tmp661_; - gchar* _tmp662_; - const gchar* _tmp663_; + ValaErrorDomain* _tmp670_; + gchar* _tmp671_; + const gchar* _tmp672_; _error_type_index = _error_type_index + 1; - _tmp652_ = _error_type_index; - _tmp653_ = _error_type_size; - if (!(_tmp652_ < _tmp653_)) { + _tmp661_ = _error_type_index; + _tmp662_ = _error_type_size; + if (!(_tmp661_ < _tmp662_)) { break; } - _tmp654_ = _error_type_list; - _tmp655_ = vala_list_get ((ValaList*) _tmp654_, _error_type_index); - error_type = (ValaDataType*) _tmp655_; - _tmp656_ = error_type; - if (!VALA_IS_ERROR_TYPE (_tmp656_)) { + _tmp663_ = _error_type_list; + _tmp664_ = vala_list_get ((ValaList*) _tmp663_, _error_type_index); + error_type = (ValaDataType*) _tmp664_; + _tmp665_ = error_type; + if (!VALA_IS_ERROR_TYPE (_tmp665_)) { _vala_code_node_unref0 (error_type); continue; } - _tmp657_ = error_type; - _tmp658_ = vala_error_type_get_error_domain (G_TYPE_CHECK_INSTANCE_CAST (_tmp657_, VALA_TYPE_ERROR_TYPE, ValaErrorType)); - _tmp659_ = _tmp658_; - error_domain = _tmp659_; - _tmp660_ = error_domain; - if (_tmp660_ == NULL) { + _tmp666_ = error_type; + _tmp667_ = vala_error_type_get_error_domain (G_TYPE_CHECK_INSTANCE_CAST (_tmp666_, VALA_TYPE_ERROR_TYPE, ValaErrorType)); + _tmp668_ = _tmp667_; + error_domain = _tmp668_; + _tmp669_ = error_domain; + if (_tmp669_ == NULL) { throws_gerror = TRUE; _vala_code_node_unref0 (error_type); break; } - _tmp661_ = error_domain; - _tmp662_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp661_); - full_error_domain = _tmp662_; - _tmp663_ = full_error_domain; - if (g_strcmp0 (_tmp663_, "GLib.IOError") == 0) { + _tmp670_ = error_domain; + _tmp671_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp670_); + full_error_domain = _tmp671_; + _tmp672_ = full_error_domain; + if (g_strcmp0 (_tmp672_, "GLib.IOError") == 0) { throws_gioerror = TRUE; } else { - const gchar* _tmp664_; - _tmp664_ = full_error_domain; - if (g_strcmp0 (_tmp664_, "GLib.DBusError") == 0) { + const gchar* _tmp673_; + _tmp673_ = full_error_domain; + if (g_strcmp0 (_tmp673_, "GLib.DBusError") == 0) { throws_gdbuserror = TRUE; } } @@ -4882,22 +4911,22 @@ } } if (!throws_gerror) { - gboolean _tmp666_ = FALSE; + gboolean _tmp675_ = FALSE; if (throws_gioerror) { - _tmp666_ = throws_gdbuserror; + _tmp675_ = throws_gdbuserror; } else { - _tmp666_ = FALSE; + _tmp675_ = FALSE; } - _tmp665_ = !_tmp666_; + _tmp674_ = !_tmp675_; } else { - _tmp665_ = FALSE; + _tmp674_ = FALSE; } - if (_tmp665_) { - ValaSourceReference* _tmp667_; - ValaSourceReference* _tmp668_; - _tmp667_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp668_ = _tmp667_; - vala_report_warning (_tmp668_, "DBus methods are recommended to throw at least `GLib.Error' or `GLib.D" \ + if (_tmp674_) { + ValaSourceReference* _tmp676_; + ValaSourceReference* _tmp677_; + _tmp676_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp677_ = _tmp676_; + vala_report_warning (_tmp677_, "DBus methods are recommended to throw at least `GLib.Error' or `GLib.D" \ "BusError, GLib.IOError'"); } _vala_iterable_unref0 (error_types); @@ -4905,30 +4934,30 @@ _vala_code_node_unref0 (dbus_attr); } if (vala_method_is_possible_entry_point (self, context)) { - ValaMethod* _tmp669_; - ValaMethod* _tmp670_; - gboolean _tmp677_; - gboolean _tmp678_; - gboolean _tmp681_; - gboolean _tmp684_; - _tmp669_ = vala_code_context_get_entry_point (context); - _tmp670_ = _tmp669_; - if (_tmp670_ != NULL) { - ValaSourceReference* _tmp671_; - ValaSourceReference* _tmp672_; - ValaMethod* _tmp673_; - ValaMethod* _tmp674_; - gchar* _tmp675_; - gchar* _tmp676_; + ValaMethod* _tmp678_; + ValaMethod* _tmp679_; + gboolean _tmp686_; + gboolean _tmp687_; + gboolean _tmp690_; + gboolean _tmp693_; + _tmp678_ = vala_code_context_get_entry_point (context); + _tmp679_ = _tmp678_; + if (_tmp679_ != NULL) { + ValaSourceReference* _tmp680_; + ValaSourceReference* _tmp681_; + ValaMethod* _tmp682_; + ValaMethod* _tmp683_; + gchar* _tmp684_; + gchar* _tmp685_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp671_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp672_ = _tmp671_; - _tmp673_ = vala_code_context_get_entry_point (context); - _tmp674_ = _tmp673_; - _tmp675_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp674_); - _tmp676_ = _tmp675_; - vala_report_error (_tmp672_, "program already has an entry point `%s'", _tmp676_); - _g_free0 (_tmp676_); + _tmp680_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp681_ = _tmp680_; + _tmp682_ = vala_code_context_get_entry_point (context); + _tmp683_ = _tmp682_; + _tmp684_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp683_); + _tmp685_ = _tmp684_; + vala_report_error (_tmp681_, "program already has an entry point `%s'", _tmp685_); + _g_free0 (_tmp685_); result = FALSE; _vala_code_node_unref0 (init_attr); _vala_code_node_unref0 (old_symbol); @@ -4937,42 +4966,42 @@ } vala_method_set_entry_point (self, TRUE); vala_code_context_set_entry_point (context, self); - _tmp677_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) self); - _tmp678_ = _tmp677_; - if (_tmp678_) { - ValaSourceReference* _tmp679_; - ValaSourceReference* _tmp680_; + _tmp686_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) self); + _tmp687_ = _tmp686_; + if (_tmp687_) { + ValaSourceReference* _tmp688_; + ValaSourceReference* _tmp689_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp679_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp680_ = _tmp679_; - vala_report_error (_tmp680_, "\"main\" method cannot throw errors"); - } - _tmp681_ = self->priv->_is_inline; - if (_tmp681_) { - ValaSourceReference* _tmp682_; - ValaSourceReference* _tmp683_; + _tmp688_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp689_ = _tmp688_; + vala_report_error (_tmp689_, "\"main\" method cannot throw errors"); + } + _tmp690_ = self->priv->_is_inline; + if (_tmp690_) { + ValaSourceReference* _tmp691_; + ValaSourceReference* _tmp692_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp682_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp683_ = _tmp682_; - vala_report_error (_tmp683_, "\"main\" method cannot be inline"); - } - _tmp684_ = self->priv->_coroutine; - if (_tmp684_) { - ValaSourceReference* _tmp685_; - ValaSourceReference* _tmp686_; + _tmp691_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp692_ = _tmp691_; + vala_report_error (_tmp692_, "\"main\" method cannot be inline"); + } + _tmp693_ = self->priv->_coroutine; + if (_tmp693_) { + ValaSourceReference* _tmp694_; + ValaSourceReference* _tmp695_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp685_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp686_ = _tmp685_; - vala_report_error (_tmp686_, "\"main\" method cannot be async"); + _tmp694_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp695_ = _tmp694_; + vala_report_error (_tmp695_, "\"main\" method cannot be async"); } } - _tmp687_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "GtkCallback"); - if (_tmp687_ != NULL) { + _tmp696_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "GtkCallback"); + if (_tmp696_ != NULL) { vala_symbol_set_used ((ValaSymbol*) self, TRUE); } - _tmp688_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp689_ = _tmp688_; - result = !_tmp689_; + _tmp697_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp698_ = _tmp697_; + result = !_tmp698_; _vala_code_node_unref0 (init_attr); _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); @@ -5477,31 +5506,36 @@ ValaDelegateType* _tmp36_; ValaDelegateType* _tmp37_; ValaDelegateType* _tmp38_; - ValaDelegateType* _tmp39_; - ValaDelegateType* _tmp40_; - ValaParameter* callback_param = NULL; + ValaSourceReference* _tmp39_; + ValaSourceReference* _tmp40_; ValaDelegateType* _tmp41_; - ValaParameter* _tmp42_; - ValaParameter* _tmp43_; - ValaSourceReference* _tmp44_; + ValaDelegateType* _tmp42_; + ValaDelegateType* _tmp43_; + ValaParameter* callback_param = NULL; + ValaDelegateType* _tmp44_; ValaSourceReference* _tmp45_; - ValaNullLiteral* _tmp46_; - ValaNullLiteral* _tmp47_; + ValaSourceReference* _tmp46_; + ValaParameter* _tmp47_; ValaParameter* _tmp48_; - ValaExpression* _tmp49_; - ValaExpression* _tmp50_; - ValaDelegateType* _tmp51_; - ValaDataType* _tmp52_; - ValaDataType* _tmp53_; - ValaParameter* _tmp54_; - ValaParameter* _tmp55_; - ValaScope* _tmp56_; - ValaScope* _tmp57_; - ValaParameter* _tmp58_; - ValaList* _tmp59_; + ValaSourceReference* _tmp49_; + ValaSourceReference* _tmp50_; + ValaNullLiteral* _tmp51_; + ValaNullLiteral* _tmp52_; + ValaParameter* _tmp53_; + ValaExpression* _tmp54_; + ValaExpression* _tmp55_; + ValaDelegateType* _tmp56_; + ValaDataType* _tmp57_; + ValaDataType* _tmp58_; + ValaParameter* _tmp59_; ValaParameter* _tmp60_; - ValaParameter* _tmp61_; + ValaScope* _tmp61_; + ValaScope* _tmp62_; + ValaParameter* _tmp63_; ValaList* _tmp64_; + ValaParameter* _tmp65_; + ValaParameter* _tmp66_; + ValaList* _tmp69_; ValaList* result = NULL; g_return_val_if_fail (self != NULL, NULL); _tmp0_ = self->priv->_coroutine; @@ -5599,50 +5633,56 @@ _vala_code_node_unref0 (_tmp35_); callback_type = _tmp37_; _tmp38_ = callback_type; - vala_data_type_set_nullable ((ValaDataType*) _tmp38_, TRUE); - _tmp39_ = callback_type; - vala_data_type_set_value_owned ((ValaDataType*) _tmp39_, TRUE); - _tmp40_ = callback_type; - vala_delegate_type_set_is_called_once (_tmp40_, TRUE); + _tmp39_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp40_ = _tmp39_; + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp38_, _tmp40_); _tmp41_ = callback_type; - _tmp42_ = vala_parameter_new ("_callback_", (ValaDataType*) _tmp41_, NULL); - callback_param = _tmp42_; - _tmp43_ = callback_param; - _tmp44_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp45_ = _tmp44_; - _tmp46_ = vala_null_literal_new (_tmp45_); - _tmp47_ = _tmp46_; - vala_variable_set_initializer ((ValaVariable*) _tmp43_, (ValaExpression*) _tmp47_); - _vala_code_node_unref0 (_tmp47_); + vala_data_type_set_nullable ((ValaDataType*) _tmp41_, TRUE); + _tmp42_ = callback_type; + vala_data_type_set_value_owned ((ValaDataType*) _tmp42_, TRUE); + _tmp43_ = callback_type; + vala_delegate_type_set_is_called_once (_tmp43_, TRUE); + _tmp44_ = callback_type; + _tmp45_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp46_ = _tmp45_; + _tmp47_ = vala_parameter_new ("_callback_", (ValaDataType*) _tmp44_, _tmp46_); + callback_param = _tmp47_; _tmp48_ = callback_param; - _tmp49_ = vala_variable_get_initializer ((ValaVariable*) _tmp48_); + _tmp49_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp50_ = _tmp49_; - _tmp51_ = callback_type; - _tmp52_ = vala_data_type_copy ((ValaDataType*) _tmp51_); - _tmp53_ = _tmp52_; - vala_expression_set_target_type (_tmp50_, _tmp53_); - _vala_code_node_unref0 (_tmp53_); - _tmp54_ = callback_param; - vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp54_, "CCode", "pos", (gdouble) -1, NULL); - _tmp55_ = callback_param; - vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp55_, "CCode", "delegate_target_pos", -0.9, NULL); - _tmp56_ = vala_symbol_get_scope ((ValaSymbol*) self); - _tmp57_ = _tmp56_; - _tmp58_ = callback_param; - vala_scope_add (_tmp57_, NULL, (ValaSymbol*) _tmp58_); - _tmp59_ = self->priv->async_begin_parameters; + _tmp51_ = vala_null_literal_new (_tmp50_); + _tmp52_ = _tmp51_; + vala_variable_set_initializer ((ValaVariable*) _tmp48_, (ValaExpression*) _tmp52_); + _vala_code_node_unref0 (_tmp52_); + _tmp53_ = callback_param; + _tmp54_ = vala_variable_get_initializer ((ValaVariable*) _tmp53_); + _tmp55_ = _tmp54_; + _tmp56_ = callback_type; + _tmp57_ = vala_data_type_copy ((ValaDataType*) _tmp56_); + _tmp58_ = _tmp57_; + vala_expression_set_target_type (_tmp55_, _tmp58_); + _vala_code_node_unref0 (_tmp58_); + _tmp59_ = callback_param; + vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp59_, "CCode", "pos", (gdouble) -1, NULL); _tmp60_ = callback_param; - vala_collection_add ((ValaCollection*) _tmp59_, _tmp60_); - _tmp61_ = ellipsis; - if (_tmp61_ != NULL) { - ValaList* _tmp62_; - ValaParameter* _tmp63_; - _tmp62_ = self->priv->async_begin_parameters; - _tmp63_ = ellipsis; - vala_collection_add ((ValaCollection*) _tmp62_, _tmp63_); - } + vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp60_, "CCode", "delegate_target_pos", -0.9, NULL); + _tmp61_ = vala_symbol_get_scope ((ValaSymbol*) self); + _tmp62_ = _tmp61_; + _tmp63_ = callback_param; + vala_scope_add (_tmp62_, NULL, (ValaSymbol*) _tmp63_); _tmp64_ = self->priv->async_begin_parameters; - result = _tmp64_; + _tmp65_ = callback_param; + vala_collection_add ((ValaCollection*) _tmp64_, _tmp65_); + _tmp66_ = ellipsis; + if (_tmp66_ != NULL) { + ValaList* _tmp67_; + ValaParameter* _tmp68_; + _tmp67_ = self->priv->async_begin_parameters; + _tmp68_ = ellipsis; + vala_collection_add ((ValaCollection*) _tmp67_, _tmp68_); + } + _tmp69_ = self->priv->async_begin_parameters; + result = _tmp69_; _vala_code_node_unref0 (callback_param); _vala_code_node_unref0 (callback_type); _vala_code_node_unref0 (ellipsis); @@ -5676,14 +5716,16 @@ ValaObjectType* _tmp19_; ValaParameter* result_param = NULL; ValaObjectType* _tmp20_; - ValaParameter* _tmp21_; - ValaParameter* _tmp22_; - ValaScope* _tmp23_; - ValaScope* _tmp24_; - ValaParameter* _tmp25_; - ValaList* _tmp26_; + ValaSourceReference* _tmp21_; + ValaSourceReference* _tmp22_; + ValaParameter* _tmp23_; + ValaParameter* _tmp24_; + ValaScope* _tmp25_; + ValaScope* _tmp26_; ValaParameter* _tmp27_; - ValaList* _tmp41_; + ValaList* _tmp28_; + ValaParameter* _tmp29_; + ValaList* _tmp43_; ValaList* result = NULL; g_return_val_if_fail (self != NULL, NULL); _tmp0_ = self->priv->_coroutine; @@ -5719,65 +5761,67 @@ _vala_code_node_unref0 (_tmp17_); result_type = _tmp19_; _tmp20_ = result_type; - _tmp21_ = vala_parameter_new ("_res_", (ValaDataType*) _tmp20_, NULL); - result_param = _tmp21_; - _tmp22_ = result_param; - vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp22_, "CCode", "pos", vala_code_node_get_attribute_double ((ValaCodeNode*) self, "CCode", "async_result_pos", 0.1), NULL); - _tmp23_ = vala_symbol_get_scope ((ValaSymbol*) self); - _tmp24_ = _tmp23_; - _tmp25_ = result_param; - vala_scope_add (_tmp24_, NULL, (ValaSymbol*) _tmp25_); - _tmp26_ = self->priv->async_end_parameters; + _tmp21_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp22_ = _tmp21_; + _tmp23_ = vala_parameter_new ("_res_", (ValaDataType*) _tmp20_, _tmp22_); + result_param = _tmp23_; + _tmp24_ = result_param; + vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp24_, "CCode", "pos", vala_code_node_get_attribute_double ((ValaCodeNode*) self, "CCode", "async_result_pos", 0.1), NULL); + _tmp25_ = vala_symbol_get_scope ((ValaSymbol*) self); + _tmp26_ = _tmp25_; _tmp27_ = result_param; - vala_collection_add ((ValaCollection*) _tmp26_, _tmp27_); + vala_scope_add (_tmp26_, NULL, (ValaSymbol*) _tmp27_); + _tmp28_ = self->priv->async_end_parameters; + _tmp29_ = result_param; + vala_collection_add ((ValaCollection*) _tmp28_, _tmp29_); { ValaList* _param_list = NULL; - ValaList* _tmp28_; + ValaList* _tmp30_; gint _param_size = 0; - ValaList* _tmp29_; - gint _tmp30_; - gint _tmp31_; + ValaList* _tmp31_; + gint _tmp32_; + gint _tmp33_; gint _param_index = 0; - _tmp28_ = self->priv->parameters; - _param_list = _tmp28_; - _tmp29_ = _param_list; - _tmp30_ = vala_collection_get_size ((ValaCollection*) _tmp29_); - _tmp31_ = _tmp30_; - _param_size = _tmp31_; + _tmp30_ = self->priv->parameters; + _param_list = _tmp30_; + _tmp31_ = _param_list; + _tmp32_ = vala_collection_get_size ((ValaCollection*) _tmp31_); + _tmp33_ = _tmp32_; + _param_size = _tmp33_; _param_index = -1; while (TRUE) { - gint _tmp32_; - gint _tmp33_; + gint _tmp34_; + gint _tmp35_; ValaParameter* param = NULL; - ValaList* _tmp34_; - gpointer _tmp35_; - ValaParameter* _tmp36_; - ValaParameterDirection _tmp37_; - ValaParameterDirection _tmp38_; + ValaList* _tmp36_; + gpointer _tmp37_; + ValaParameter* _tmp38_; + ValaParameterDirection _tmp39_; + ValaParameterDirection _tmp40_; _param_index = _param_index + 1; - _tmp32_ = _param_index; - _tmp33_ = _param_size; - if (!(_tmp32_ < _tmp33_)) { + _tmp34_ = _param_index; + _tmp35_ = _param_size; + if (!(_tmp34_ < _tmp35_)) { break; } - _tmp34_ = _param_list; - _tmp35_ = vala_list_get (_tmp34_, _param_index); - param = (ValaParameter*) _tmp35_; - _tmp36_ = param; - _tmp37_ = vala_parameter_get_direction (_tmp36_); - _tmp38_ = _tmp37_; - if (_tmp38_ == VALA_PARAMETER_DIRECTION_OUT) { - ValaList* _tmp39_; - ValaParameter* _tmp40_; - _tmp39_ = self->priv->async_end_parameters; - _tmp40_ = param; - vala_collection_add ((ValaCollection*) _tmp39_, _tmp40_); + _tmp36_ = _param_list; + _tmp37_ = vala_list_get (_tmp36_, _param_index); + param = (ValaParameter*) _tmp37_; + _tmp38_ = param; + _tmp39_ = vala_parameter_get_direction (_tmp38_); + _tmp40_ = _tmp39_; + if (_tmp40_ == VALA_PARAMETER_DIRECTION_OUT) { + ValaList* _tmp41_; + ValaParameter* _tmp42_; + _tmp41_ = self->priv->async_end_parameters; + _tmp42_ = param; + vala_collection_add ((ValaCollection*) _tmp41_, _tmp42_); } _vala_code_node_unref0 (param); } } - _tmp41_ = self->priv->async_end_parameters; - result = _tmp41_; + _tmp43_ = self->priv->async_end_parameters; + result = _tmp43_; _vala_code_node_unref0 (result_param); _vala_code_node_unref0 (result_type); _vala_code_node_unref0 (glib_ns); diff -Nru vala-0.52.6/vala/valamethodcall.c vala-0.52.7/vala/valamethodcall.c --- vala-0.52.6/vala/valamethodcall.c 2021-10-04 09:46:52.000000000 +0000 +++ vala-0.52.7/vala/valamethodcall.c 2021-10-30 08:24:06.000000000 +0000 @@ -683,59 +683,59 @@ gboolean gobject_chainup = FALSE; ValaCreationMethod* base_cm = NULL; gboolean _tmp135_; - gboolean _tmp215_ = FALSE; - ValaExpression* _tmp216_; - ValaExpression* _tmp217_; - gboolean _tmp288_ = FALSE; - gboolean _tmp289_; + gboolean _tmp221_ = FALSE; + ValaExpression* _tmp222_; + ValaExpression* _tmp223_; + gboolean _tmp294_ = FALSE; + gboolean _tmp295_; ValaDataType* ret_type = NULL; - ValaDataType* _tmp304_; - ValaDataType* _tmp305_; - ValaDataType* _tmp306_; - ValaList* params = NULL; - ValaDataType* _tmp307_; - ValaList* _tmp308_; - ValaList* _tmp309_; ValaDataType* _tmp310_; + ValaDataType* _tmp311_; + ValaDataType* _tmp312_; + ValaList* params = NULL; + ValaDataType* _tmp313_; + ValaList* _tmp314_; + ValaList* _tmp315_; + ValaDataType* _tmp316_; ValaExpression* last_arg = NULL; ValaIterator* arg_it = NULL; - ValaList* _tmp366_; - ValaIterator* _tmp367_; - gboolean _tmp417_ = FALSE; - ValaDataType* _tmp418_; - gboolean _tmp439_ = FALSE; - ValaDataType* _tmp440_; + ValaList* _tmp372_; + ValaIterator* _tmp373_; + gboolean _tmp423_ = FALSE; + ValaDataType* _tmp424_; + gboolean _tmp445_ = FALSE; + ValaDataType* _tmp446_; gboolean force_lambda_method_closure = FALSE; - gboolean _tmp520_ = FALSE; - gboolean _tmp521_; - gboolean _tmp522_; - ValaDataType* _tmp542_; - ValaDataType* _tmp553_; - ValaDataType* _tmp554_; - ValaDataType* _tmp555_; - ValaDataType* _tmp556_; - ValaDataType* _tmp557_; - ValaDataType* _tmp558_; - ValaList* _tmp559_; + gboolean _tmp526_ = FALSE; + gboolean _tmp527_; + gboolean _tmp528_; + ValaDataType* _tmp548_; + ValaDataType* _tmp559_; ValaDataType* _tmp560_; ValaDataType* _tmp561_; - gboolean _tmp562_; - gboolean _tmp563_; - ValaDataType* _tmp586_; - ValaSemanticAnalyzer* _tmp825_; - ValaSemanticAnalyzer* _tmp826_; - ValaDataType* _tmp827_; - ValaList* _tmp828_; - ValaList* _tmp829_; - gboolean _tmp856_ = FALSE; - gboolean _tmp857_ = FALSE; - ValaCreationMethod* _tmp858_; - ValaDataType* _tmp886_; - ValaDataType* _tmp887_; - gboolean _tmp888_; - gboolean _tmp889_; - gboolean _tmp950_; - gboolean _tmp951_; + ValaDataType* _tmp562_; + ValaDataType* _tmp563_; + ValaDataType* _tmp564_; + ValaList* _tmp565_; + ValaDataType* _tmp566_; + ValaDataType* _tmp567_; + gboolean _tmp568_; + gboolean _tmp569_; + ValaDataType* _tmp592_; + ValaSemanticAnalyzer* _tmp841_; + ValaSemanticAnalyzer* _tmp842_; + ValaDataType* _tmp843_; + ValaList* _tmp844_; + ValaList* _tmp845_; + gboolean _tmp872_ = FALSE; + gboolean _tmp873_ = FALSE; + ValaCreationMethod* _tmp874_; + ValaDataType* _tmp902_; + ValaDataType* _tmp903_; + gboolean _tmp904_; + gboolean _tmp905_; + gboolean _tmp966_; + gboolean _tmp967_; gboolean result = FALSE; self = (ValaMethodCall*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -1305,7 +1305,13 @@ ValaExpression* _tmp211_; ValaDataType* _tmp212_; ValaDataType* _tmp213_; - ValaDataType* _tmp214_; + ValaSourceReference* _tmp214_; + ValaSourceReference* _tmp215_; + ValaExpression* _tmp216_; + ValaExpression* _tmp217_; + ValaDataType* _tmp218_; + ValaDataType* _tmp219_; + ValaDataType* _tmp220_; _tmp192_ = cm; _tmp193_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp192_); _tmp194_ = _tmp193_; @@ -1350,199 +1356,206 @@ _tmp211_ = _tmp210_; _tmp212_ = vala_expression_get_value_type (_tmp211_); _tmp213_ = _tmp212_; - _tmp214_ = _vala_code_node_ref0 (_tmp213_); + _tmp214_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp215_ = _tmp214_; + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp213_, _tmp215_); + _tmp216_ = vala_method_call_get_call (self); + _tmp217_ = _tmp216_; + _tmp218_ = vala_expression_get_value_type (_tmp217_); + _tmp219_ = _tmp218_; + _tmp220_ = _vala_code_node_ref0 (_tmp219_); _vala_code_node_unref0 (mtype); - mtype = _tmp214_; + mtype = _tmp220_; } } } } - _tmp216_ = vala_method_call_get_call (self); - _tmp217_ = _tmp216_; - if (VALA_IS_MEMBER_ACCESS (_tmp217_)) { - gboolean _tmp218_ = FALSE; - gboolean _tmp219_ = FALSE; - ValaExpression* _tmp220_; - ValaExpression* _tmp221_; - ValaSymbol* _tmp222_; - ValaSymbol* _tmp223_; - _tmp220_ = vala_method_call_get_call (self); - _tmp221_ = _tmp220_; - _tmp222_ = vala_expression_get_symbol_reference (_tmp221_); - _tmp223_ = _tmp222_; - if (VALA_IS_CREATION_METHOD (_tmp223_)) { - ValaExpression* _tmp224_; - ValaExpression* _tmp225_; - ValaSymbol* _tmp226_; - ValaSymbol* _tmp227_; - ValaSymbol* _tmp228_; - ValaSymbol* _tmp229_; - _tmp224_ = vala_method_call_get_call (self); - _tmp225_ = _tmp224_; - _tmp226_ = vala_expression_get_symbol_reference (_tmp225_); - _tmp227_ = _tmp226_; - _tmp228_ = vala_symbol_get_parent_symbol (_tmp227_); - _tmp229_ = _tmp228_; - _tmp219_ = VALA_IS_STRUCT (_tmp229_); - } else { - _tmp219_ = FALSE; - } - if (_tmp219_) { - _tmp218_ = TRUE; - } else { + _tmp222_ = vala_method_call_get_call (self); + _tmp223_ = _tmp222_; + if (VALA_IS_MEMBER_ACCESS (_tmp223_)) { + gboolean _tmp224_ = FALSE; + gboolean _tmp225_ = FALSE; + ValaExpression* _tmp226_; + ValaExpression* _tmp227_; + ValaSymbol* _tmp228_; + ValaSymbol* _tmp229_; + _tmp226_ = vala_method_call_get_call (self); + _tmp227_ = _tmp226_; + _tmp228_ = vala_expression_get_symbol_reference (_tmp227_); + _tmp229_ = _tmp228_; + if (VALA_IS_CREATION_METHOD (_tmp229_)) { ValaExpression* _tmp230_; ValaExpression* _tmp231_; ValaSymbol* _tmp232_; ValaSymbol* _tmp233_; + ValaSymbol* _tmp234_; + ValaSymbol* _tmp235_; _tmp230_ = vala_method_call_get_call (self); _tmp231_ = _tmp230_; _tmp232_ = vala_expression_get_symbol_reference (_tmp231_); _tmp233_ = _tmp232_; - _tmp218_ = VALA_IS_STRUCT (_tmp233_); + _tmp234_ = vala_symbol_get_parent_symbol (_tmp233_); + _tmp235_ = _tmp234_; + _tmp225_ = VALA_IS_STRUCT (_tmp235_); + } else { + _tmp225_ = FALSE; + } + if (_tmp225_) { + _tmp224_ = TRUE; + } else { + ValaExpression* _tmp236_; + ValaExpression* _tmp237_; + ValaSymbol* _tmp238_; + ValaSymbol* _tmp239_; + _tmp236_ = vala_method_call_get_call (self); + _tmp237_ = _tmp236_; + _tmp238_ = vala_expression_get_symbol_reference (_tmp237_); + _tmp239_ = _tmp238_; + _tmp224_ = VALA_IS_STRUCT (_tmp239_); } - _tmp215_ = _tmp218_; + _tmp221_ = _tmp224_; } else { - _tmp215_ = FALSE; + _tmp221_ = FALSE; } - if (_tmp215_) { + if (_tmp221_) { ValaStruct* st = NULL; - ValaExpression* _tmp234_; - ValaExpression* _tmp235_; - ValaSymbol* _tmp236_; - ValaSymbol* _tmp237_; - gboolean _tmp238_ = FALSE; - gboolean _tmp239_ = FALSE; - ValaStruct* _tmp240_; + ValaExpression* _tmp240_; + ValaExpression* _tmp241_; + ValaSymbol* _tmp242_; + ValaSymbol* _tmp243_; + gboolean _tmp244_ = FALSE; + gboolean _tmp245_ = FALSE; + ValaStruct* _tmp246_; ValaObjectCreationExpression* struct_creation_expression = NULL; - ValaExpression* _tmp251_; - ValaExpression* _tmp252_; - ValaSourceReference* _tmp253_; - ValaSourceReference* _tmp254_; - ValaObjectCreationExpression* _tmp255_; - ValaObjectCreationExpression* _tmp256_; - ValaObjectCreationExpression* _tmp267_; - ValaDataType* _tmp268_; - ValaDataType* _tmp269_; - ValaSemanticAnalyzer* _tmp270_; - ValaSemanticAnalyzer* _tmp271_; - ValaList* _tmp272_; - ValaCodeNode* _tmp273_; - ValaCodeNode* _tmp274_; - ValaObjectCreationExpression* _tmp275_; - ValaObjectCreationExpression* _tmp276_; - _tmp234_ = vala_method_call_get_call (self); - _tmp235_ = _tmp234_; - _tmp236_ = vala_expression_get_symbol_reference (_tmp235_); - _tmp237_ = _tmp236_; - st = VALA_IS_STRUCT (_tmp237_) ? ((ValaStruct*) _tmp237_) : NULL; - _tmp240_ = st; - if (_tmp240_ != NULL) { - ValaStruct* _tmp241_; - ValaCreationMethod* _tmp242_; - ValaCreationMethod* _tmp243_; - _tmp241_ = st; - _tmp242_ = vala_struct_get_default_construction_method (_tmp241_); - _tmp243_ = _tmp242_; - _tmp239_ = _tmp243_ == NULL; - } else { - _tmp239_ = FALSE; - } - if (_tmp239_) { - gboolean _tmp244_ = FALSE; - gboolean _tmp245_ = FALSE; - ValaStruct* _tmp246_; - _tmp246_ = st; - if (vala_struct_is_boolean_type (_tmp246_)) { - _tmp245_ = TRUE; + ValaExpression* _tmp257_; + ValaExpression* _tmp258_; + ValaSourceReference* _tmp259_; + ValaSourceReference* _tmp260_; + ValaObjectCreationExpression* _tmp261_; + ValaObjectCreationExpression* _tmp262_; + ValaObjectCreationExpression* _tmp273_; + ValaDataType* _tmp274_; + ValaDataType* _tmp275_; + ValaSemanticAnalyzer* _tmp276_; + ValaSemanticAnalyzer* _tmp277_; + ValaList* _tmp278_; + ValaCodeNode* _tmp279_; + ValaCodeNode* _tmp280_; + ValaObjectCreationExpression* _tmp281_; + ValaObjectCreationExpression* _tmp282_; + _tmp240_ = vala_method_call_get_call (self); + _tmp241_ = _tmp240_; + _tmp242_ = vala_expression_get_symbol_reference (_tmp241_); + _tmp243_ = _tmp242_; + st = VALA_IS_STRUCT (_tmp243_) ? ((ValaStruct*) _tmp243_) : NULL; + _tmp246_ = st; + if (_tmp246_ != NULL) { + ValaStruct* _tmp247_; + ValaCreationMethod* _tmp248_; + ValaCreationMethod* _tmp249_; + _tmp247_ = st; + _tmp248_ = vala_struct_get_default_construction_method (_tmp247_); + _tmp249_ = _tmp248_; + _tmp245_ = _tmp249_ == NULL; + } else { + _tmp245_ = FALSE; + } + if (_tmp245_) { + gboolean _tmp250_ = FALSE; + gboolean _tmp251_ = FALSE; + ValaStruct* _tmp252_; + _tmp252_ = st; + if (vala_struct_is_boolean_type (_tmp252_)) { + _tmp251_ = TRUE; } else { - ValaStruct* _tmp247_; - _tmp247_ = st; - _tmp245_ = vala_struct_is_integer_type (_tmp247_); + ValaStruct* _tmp253_; + _tmp253_ = st; + _tmp251_ = vala_struct_is_integer_type (_tmp253_); } - if (_tmp245_) { - _tmp244_ = TRUE; + if (_tmp251_) { + _tmp250_ = TRUE; } else { - ValaStruct* _tmp248_; - _tmp248_ = st; - _tmp244_ = vala_struct_is_floating_type (_tmp248_); + ValaStruct* _tmp254_; + _tmp254_ = st; + _tmp250_ = vala_struct_is_floating_type (_tmp254_); } - _tmp238_ = _tmp244_; + _tmp244_ = _tmp250_; } else { - _tmp238_ = FALSE; + _tmp244_ = FALSE; } - if (_tmp238_) { - ValaSourceReference* _tmp249_; - ValaSourceReference* _tmp250_; + if (_tmp244_) { + ValaSourceReference* _tmp255_; + ValaSourceReference* _tmp256_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp249_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp250_ = _tmp249_; - vala_report_error (_tmp250_, "invocation not supported in this context"); + _tmp255_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp256_ = _tmp255_; + vala_report_error (_tmp256_, "invocation not supported in this context"); result = FALSE; _vala_code_node_unref0 (mtype); _vala_iterable_unref0 (method_type_args); _vala_code_node_unref0 (target_object_type); return result; } - _tmp251_ = vala_method_call_get_call (self); - _tmp252_ = _tmp251_; - _tmp253_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp254_ = _tmp253_; - _tmp255_ = vala_object_creation_expression_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp252_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess), _tmp254_); - struct_creation_expression = _tmp255_; - _tmp256_ = struct_creation_expression; - vala_object_creation_expression_set_struct_creation (_tmp256_, TRUE); + _tmp257_ = vala_method_call_get_call (self); + _tmp258_ = _tmp257_; + _tmp259_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp260_ = _tmp259_; + _tmp261_ = vala_object_creation_expression_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp258_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess), _tmp260_); + struct_creation_expression = _tmp261_; + _tmp262_ = struct_creation_expression; + vala_object_creation_expression_set_struct_creation (_tmp262_, TRUE); { ValaList* _arg_list = NULL; - ValaList* _tmp257_; + ValaList* _tmp263_; gint _arg_size = 0; - ValaList* _tmp258_; - gint _tmp259_; - gint _tmp260_; + ValaList* _tmp264_; + gint _tmp265_; + gint _tmp266_; gint _arg_index = 0; - _tmp257_ = self->priv->argument_list; - _arg_list = _tmp257_; - _tmp258_ = _arg_list; - _tmp259_ = vala_collection_get_size ((ValaCollection*) _tmp258_); - _tmp260_ = _tmp259_; - _arg_size = _tmp260_; + _tmp263_ = self->priv->argument_list; + _arg_list = _tmp263_; + _tmp264_ = _arg_list; + _tmp265_ = vala_collection_get_size ((ValaCollection*) _tmp264_); + _tmp266_ = _tmp265_; + _arg_size = _tmp266_; _arg_index = -1; while (TRUE) { - gint _tmp261_; - gint _tmp262_; + gint _tmp267_; + gint _tmp268_; ValaExpression* arg = NULL; - ValaList* _tmp263_; - gpointer _tmp264_; - ValaObjectCreationExpression* _tmp265_; - ValaExpression* _tmp266_; + ValaList* _tmp269_; + gpointer _tmp270_; + ValaObjectCreationExpression* _tmp271_; + ValaExpression* _tmp272_; _arg_index = _arg_index + 1; - _tmp261_ = _arg_index; - _tmp262_ = _arg_size; - if (!(_tmp261_ < _tmp262_)) { + _tmp267_ = _arg_index; + _tmp268_ = _arg_size; + if (!(_tmp267_ < _tmp268_)) { break; } - _tmp263_ = _arg_list; - _tmp264_ = vala_list_get (_tmp263_, _arg_index); - arg = (ValaExpression*) _tmp264_; - _tmp265_ = struct_creation_expression; - _tmp266_ = arg; - vala_callable_expression_add_argument ((ValaCallableExpression*) _tmp265_, _tmp266_); + _tmp269_ = _arg_list; + _tmp270_ = vala_list_get (_tmp269_, _arg_index); + arg = (ValaExpression*) _tmp270_; + _tmp271_ = struct_creation_expression; + _tmp272_ = arg; + vala_callable_expression_add_argument ((ValaCallableExpression*) _tmp271_, _tmp272_); _vala_code_node_unref0 (arg); } } - _tmp267_ = struct_creation_expression; - _tmp268_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp269_ = _tmp268_; - vala_expression_set_target_type ((ValaExpression*) _tmp267_, _tmp269_); - _tmp270_ = vala_code_context_get_analyzer (context); - _tmp271_ = _tmp270_; - _tmp272_ = _tmp271_->replaced_nodes; - vala_collection_add ((ValaCollection*) _tmp272_, (ValaCodeNode*) self); - _tmp273_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp274_ = _tmp273_; - _tmp275_ = struct_creation_expression; - vala_code_node_replace_expression (_tmp274_, (ValaExpression*) self, (ValaExpression*) _tmp275_); - _tmp276_ = struct_creation_expression; - vala_code_node_check ((ValaCodeNode*) _tmp276_, context); + _tmp273_ = struct_creation_expression; + _tmp274_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp275_ = _tmp274_; + vala_expression_set_target_type ((ValaExpression*) _tmp273_, _tmp275_); + _tmp276_ = vala_code_context_get_analyzer (context); + _tmp277_ = _tmp276_; + _tmp278_ = _tmp277_->replaced_nodes; + vala_collection_add ((ValaCollection*) _tmp278_, (ValaCodeNode*) self); + _tmp279_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp280_ = _tmp279_; + _tmp281_ = struct_creation_expression; + vala_code_node_replace_expression (_tmp280_, (ValaExpression*) self, (ValaExpression*) _tmp281_); + _tmp282_ = struct_creation_expression; + vala_code_node_check ((ValaCodeNode*) _tmp282_, context); result = TRUE; _vala_code_node_unref0 (struct_creation_expression); _vala_code_node_unref0 (mtype); @@ -1550,39 +1563,39 @@ _vala_code_node_unref0 (target_object_type); return result; } else { - gboolean _tmp277_ = FALSE; - gboolean _tmp278_ = FALSE; - gboolean _tmp279_; - _tmp279_ = self->priv->_is_chainup; - if (!_tmp279_) { - ValaExpression* _tmp280_; - ValaExpression* _tmp281_; - _tmp280_ = vala_method_call_get_call (self); - _tmp281_ = _tmp280_; - _tmp278_ = VALA_IS_MEMBER_ACCESS (_tmp281_); - } else { - _tmp278_ = FALSE; - } - if (_tmp278_) { - ValaExpression* _tmp282_; - ValaExpression* _tmp283_; - ValaSymbol* _tmp284_; - ValaSymbol* _tmp285_; - _tmp282_ = vala_method_call_get_call (self); - _tmp283_ = _tmp282_; - _tmp284_ = vala_expression_get_symbol_reference (_tmp283_); - _tmp285_ = _tmp284_; - _tmp277_ = VALA_IS_CREATION_METHOD (_tmp285_); - } else { - _tmp277_ = FALSE; - } - if (_tmp277_) { - ValaSourceReference* _tmp286_; - ValaSourceReference* _tmp287_; - vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp286_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + gboolean _tmp283_ = FALSE; + gboolean _tmp284_ = FALSE; + gboolean _tmp285_; + _tmp285_ = self->priv->_is_chainup; + if (!_tmp285_) { + ValaExpression* _tmp286_; + ValaExpression* _tmp287_; + _tmp286_ = vala_method_call_get_call (self); _tmp287_ = _tmp286_; - vala_report_error (_tmp287_, "use `new' operator to create new objects"); + _tmp284_ = VALA_IS_MEMBER_ACCESS (_tmp287_); + } else { + _tmp284_ = FALSE; + } + if (_tmp284_) { + ValaExpression* _tmp288_; + ValaExpression* _tmp289_; + ValaSymbol* _tmp290_; + ValaSymbol* _tmp291_; + _tmp288_ = vala_method_call_get_call (self); + _tmp289_ = _tmp288_; + _tmp290_ = vala_expression_get_symbol_reference (_tmp289_); + _tmp291_ = _tmp290_; + _tmp283_ = VALA_IS_CREATION_METHOD (_tmp291_); + } else { + _tmp283_ = FALSE; + } + if (_tmp283_) { + ValaSourceReference* _tmp292_; + ValaSourceReference* _tmp293_; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp292_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp293_ = _tmp292_; + vala_report_error (_tmp293_, "use `new' operator to create new objects"); result = FALSE; _vala_code_node_unref0 (mtype); _vala_iterable_unref0 (method_type_args); @@ -1590,66 +1603,66 @@ return result; } } - _tmp289_ = self->priv->_is_chainup; - if (!_tmp289_) { - ValaDataType* _tmp290_; - _tmp290_ = mtype; - _tmp288_ = VALA_IS_OBJECT_TYPE (_tmp290_); + _tmp295_ = self->priv->_is_chainup; + if (!_tmp295_) { + ValaDataType* _tmp296_; + _tmp296_ = mtype; + _tmp294_ = VALA_IS_OBJECT_TYPE (_tmp296_); } else { - _tmp288_ = FALSE; + _tmp294_ = FALSE; } - if (_tmp288_) { - ValaSourceReference* _tmp291_; - ValaSourceReference* _tmp292_; + if (_tmp294_) { + ValaSourceReference* _tmp297_; + ValaSourceReference* _tmp298_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp291_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp292_ = _tmp291_; - vala_report_error (_tmp292_, "invocation not supported in this context"); + _tmp297_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp298_ = _tmp297_; + vala_report_error (_tmp298_, "invocation not supported in this context"); result = FALSE; _vala_code_node_unref0 (mtype); _vala_iterable_unref0 (method_type_args); _vala_code_node_unref0 (target_object_type); return result; } else { - gboolean _tmp293_ = FALSE; - ValaDataType* _tmp294_; - _tmp294_ = mtype; - if (_tmp294_ != NULL) { - ValaDataType* _tmp295_; - _tmp295_ = mtype; - _tmp293_ = vala_data_type_is_invokable (_tmp295_); - } else { - _tmp293_ = FALSE; - } - if (_tmp293_) { - } else { - ValaExpression* _tmp296_; - ValaExpression* _tmp297_; - ValaSymbol* _tmp298_; - ValaSymbol* _tmp299_; - _tmp296_ = vala_method_call_get_call (self); - _tmp297_ = _tmp296_; - _tmp298_ = vala_expression_get_symbol_reference (_tmp297_); - _tmp299_ = _tmp298_; - if (VALA_IS_CLASS (_tmp299_)) { - ValaSourceReference* _tmp300_; - ValaSourceReference* _tmp301_; + gboolean _tmp299_ = FALSE; + ValaDataType* _tmp300_; + _tmp300_ = mtype; + if (_tmp300_ != NULL) { + ValaDataType* _tmp301_; + _tmp301_ = mtype; + _tmp299_ = vala_data_type_is_invokable (_tmp301_); + } else { + _tmp299_ = FALSE; + } + if (_tmp299_) { + } else { + ValaExpression* _tmp302_; + ValaExpression* _tmp303_; + ValaSymbol* _tmp304_; + ValaSymbol* _tmp305_; + _tmp302_ = vala_method_call_get_call (self); + _tmp303_ = _tmp302_; + _tmp304_ = vala_expression_get_symbol_reference (_tmp303_); + _tmp305_ = _tmp304_; + if (VALA_IS_CLASS (_tmp305_)) { + ValaSourceReference* _tmp306_; + ValaSourceReference* _tmp307_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp300_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp301_ = _tmp300_; - vala_report_error (_tmp301_, "use `new' operator to create new objects"); + _tmp306_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp307_ = _tmp306_; + vala_report_error (_tmp307_, "use `new' operator to create new objects"); result = FALSE; _vala_code_node_unref0 (mtype); _vala_iterable_unref0 (method_type_args); _vala_code_node_unref0 (target_object_type); return result; } else { - ValaSourceReference* _tmp302_; - ValaSourceReference* _tmp303_; + ValaSourceReference* _tmp308_; + ValaSourceReference* _tmp309_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp302_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp303_ = _tmp302_; - vala_report_error (_tmp303_, "invocation not supported in this context"); + _tmp308_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp309_ = _tmp308_; + vala_report_error (_tmp309_, "invocation not supported in this context"); result = FALSE; _vala_code_node_unref0 (mtype); _vala_iterable_unref0 (method_type_args); @@ -1658,158 +1671,158 @@ } } } - _tmp304_ = mtype; - _tmp305_ = vala_data_type_get_return_type (_tmp304_); - _tmp306_ = _vala_code_node_ref0 (_tmp305_); - ret_type = _tmp306_; - _tmp307_ = mtype; - _tmp308_ = vala_data_type_get_parameters (_tmp307_); - _tmp309_ = _vala_iterable_ref0 (_tmp308_); - params = _tmp309_; _tmp310_ = mtype; - if (VALA_IS_METHOD_TYPE (_tmp310_)) { + _tmp311_ = vala_data_type_get_return_type (_tmp310_); + _tmp312_ = _vala_code_node_ref0 (_tmp311_); + ret_type = _tmp312_; + _tmp313_ = mtype; + _tmp314_ = vala_data_type_get_parameters (_tmp313_); + _tmp315_ = _vala_iterable_ref0 (_tmp314_); + params = _tmp315_; + _tmp316_ = mtype; + if (VALA_IS_METHOD_TYPE (_tmp316_)) { ValaMemberAccess* ma = NULL; - ValaExpression* _tmp311_; - ValaExpression* _tmp312_; + ValaExpression* _tmp317_; + ValaExpression* _tmp318_; ValaMethod* m = NULL; - ValaDataType* _tmp313_; - ValaMethod* _tmp314_; - ValaMethod* _tmp315_; - ValaMethod* _tmp316_; - gboolean _tmp317_; - gboolean _tmp318_; + ValaDataType* _tmp319_; + ValaMethod* _tmp320_; + ValaMethod* _tmp321_; + ValaMethod* _tmp322_; + gboolean _tmp323_; + gboolean _tmp324_; gint n_type_params = 0; - ValaMethod* _tmp350_; - ValaList* _tmp351_; - gint _tmp352_; - gint _tmp353_; + ValaMethod* _tmp356_; + ValaList* _tmp357_; + gint _tmp358_; + gint _tmp359_; gint n_type_args = 0; - ValaMemberAccess* _tmp354_; - ValaList* _tmp355_; - gint _tmp356_; - gint _tmp357_; - gboolean _tmp358_ = FALSE; - _tmp311_ = vala_method_call_get_call (self); - _tmp312_ = _tmp311_; - ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp312_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess); - _tmp313_ = mtype; - _tmp314_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp313_, VALA_TYPE_METHOD_TYPE, ValaMethodType)); - _tmp315_ = _tmp314_; - m = _tmp315_; - _tmp316_ = m; - _tmp317_ = vala_method_get_coroutine (_tmp316_); + ValaMemberAccess* _tmp360_; + ValaList* _tmp361_; + gint _tmp362_; + gint _tmp363_; + gboolean _tmp364_ = FALSE; + _tmp317_ = vala_method_call_get_call (self); _tmp318_ = _tmp317_; - if (_tmp318_) { - gboolean _tmp319_; - gboolean _tmp320_; - _tmp319_ = vala_callable_expression_get_is_yield_expression ((ValaCallableExpression*) self); - _tmp320_ = _tmp319_; - if (!_tmp320_) { - ValaMemberAccess* _tmp321_; - const gchar* _tmp322_; - const gchar* _tmp323_; - _tmp321_ = ma; - _tmp322_ = vala_member_access_get_member_name (_tmp321_); - _tmp323_ = _tmp322_; - if (g_strcmp0 (_tmp323_, "end") != 0) { - ValaMemberAccess* _tmp324_; - const gchar* _tmp325_; - const gchar* _tmp326_; - ValaMethod* _tmp330_; - ValaList* _tmp331_; - ValaList* _tmp332_; - ValaVoidType* _tmp333_; - _tmp324_ = ma; - _tmp325_ = vala_member_access_get_member_name (_tmp324_); - _tmp326_ = _tmp325_; - if (g_strcmp0 (_tmp326_, "begin") != 0) { - ValaMemberAccess* _tmp327_; - ValaSourceReference* _tmp328_; - ValaSourceReference* _tmp329_; - _tmp327_ = ma; - _tmp328_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp327_); - _tmp329_ = _tmp328_; - vala_report_deprecated (_tmp329_, "implicit .begin is deprecated"); + ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp318_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess); + _tmp319_ = mtype; + _tmp320_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp319_, VALA_TYPE_METHOD_TYPE, ValaMethodType)); + _tmp321_ = _tmp320_; + m = _tmp321_; + _tmp322_ = m; + _tmp323_ = vala_method_get_coroutine (_tmp322_); + _tmp324_ = _tmp323_; + if (_tmp324_) { + gboolean _tmp325_; + gboolean _tmp326_; + _tmp325_ = vala_callable_expression_get_is_yield_expression ((ValaCallableExpression*) self); + _tmp326_ = _tmp325_; + if (!_tmp326_) { + ValaMemberAccess* _tmp327_; + const gchar* _tmp328_; + const gchar* _tmp329_; + _tmp327_ = ma; + _tmp328_ = vala_member_access_get_member_name (_tmp327_); + _tmp329_ = _tmp328_; + if (g_strcmp0 (_tmp329_, "end") != 0) { + ValaMemberAccess* _tmp330_; + const gchar* _tmp331_; + const gchar* _tmp332_; + ValaMethod* _tmp336_; + ValaList* _tmp337_; + ValaList* _tmp338_; + ValaVoidType* _tmp339_; + _tmp330_ = ma; + _tmp331_ = vala_member_access_get_member_name (_tmp330_); + _tmp332_ = _tmp331_; + if (g_strcmp0 (_tmp332_, "begin") != 0) { + ValaMemberAccess* _tmp333_; + ValaSourceReference* _tmp334_; + ValaSourceReference* _tmp335_; + _tmp333_ = ma; + _tmp334_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp333_); + _tmp335_ = _tmp334_; + vala_report_deprecated (_tmp335_, "implicit .begin is deprecated"); } - _tmp330_ = m; - _tmp331_ = vala_method_get_async_begin_parameters (_tmp330_); - _tmp332_ = _vala_iterable_ref0 (_tmp331_); + _tmp336_ = m; + _tmp337_ = vala_method_get_async_begin_parameters (_tmp336_); + _tmp338_ = _vala_iterable_ref0 (_tmp337_); _vala_iterable_unref0 (params); - params = _tmp332_; - _tmp333_ = vala_void_type_new (NULL); + params = _tmp338_; + _tmp339_ = vala_void_type_new (NULL); _vala_code_node_unref0 (ret_type); - ret_type = (ValaDataType*) _tmp333_; + ret_type = (ValaDataType*) _tmp339_; } else { - ValaMethod* _tmp334_; - ValaList* _tmp335_; - ValaList* _tmp336_; - _tmp334_ = m; - _tmp335_ = vala_method_get_async_end_parameters (_tmp334_); - _tmp336_ = _vala_iterable_ref0 (_tmp335_); + ValaMethod* _tmp340_; + ValaList* _tmp341_; + ValaList* _tmp342_; + _tmp340_ = m; + _tmp341_ = vala_method_get_async_end_parameters (_tmp340_); + _tmp342_ = _vala_iterable_ref0 (_tmp341_); _vala_iterable_unref0 (params); - params = _tmp336_; + params = _tmp342_; } } else { - gboolean _tmp337_ = FALSE; - ValaMemberAccess* _tmp338_; - const gchar* _tmp339_; - const gchar* _tmp340_; - _tmp338_ = ma; - _tmp339_ = vala_member_access_get_member_name (_tmp338_); - _tmp340_ = _tmp339_; - if (g_strcmp0 (_tmp340_, "begin") == 0) { - _tmp337_ = TRUE; + gboolean _tmp343_ = FALSE; + ValaMemberAccess* _tmp344_; + const gchar* _tmp345_; + const gchar* _tmp346_; + _tmp344_ = ma; + _tmp345_ = vala_member_access_get_member_name (_tmp344_); + _tmp346_ = _tmp345_; + if (g_strcmp0 (_tmp346_, "begin") == 0) { + _tmp343_ = TRUE; } else { - ValaMemberAccess* _tmp341_; - const gchar* _tmp342_; - const gchar* _tmp343_; - _tmp341_ = ma; - _tmp342_ = vala_member_access_get_member_name (_tmp341_); - _tmp343_ = _tmp342_; - _tmp337_ = g_strcmp0 (_tmp343_, "end") == 0; - } - if (_tmp337_) { - ValaMemberAccess* _tmp344_; - ValaSourceReference* _tmp345_; - ValaSourceReference* _tmp346_; ValaMemberAccess* _tmp347_; const gchar* _tmp348_; const gchar* _tmp349_; - vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp344_ = ma; - _tmp345_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp344_); - _tmp346_ = _tmp345_; _tmp347_ = ma; _tmp348_ = vala_member_access_get_member_name (_tmp347_); _tmp349_ = _tmp348_; - vala_report_error (_tmp346_, "use of `%s' not allowed in yield statement", _tmp349_); + _tmp343_ = g_strcmp0 (_tmp349_, "end") == 0; + } + if (_tmp343_) { + ValaMemberAccess* _tmp350_; + ValaSourceReference* _tmp351_; + ValaSourceReference* _tmp352_; + ValaMemberAccess* _tmp353_; + const gchar* _tmp354_; + const gchar* _tmp355_; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp350_ = ma; + _tmp351_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp350_); + _tmp352_ = _tmp351_; + _tmp353_ = ma; + _tmp354_ = vala_member_access_get_member_name (_tmp353_); + _tmp355_ = _tmp354_; + vala_report_error (_tmp352_, "use of `%s' not allowed in yield statement", _tmp355_); } } } - _tmp350_ = m; - _tmp351_ = vala_method_get_type_parameters (_tmp350_); - _tmp352_ = vala_collection_get_size ((ValaCollection*) _tmp351_); - _tmp353_ = _tmp352_; - n_type_params = _tmp353_; - _tmp354_ = ma; - _tmp355_ = vala_member_access_get_type_arguments (_tmp354_); - _tmp356_ = vala_collection_get_size ((ValaCollection*) _tmp355_); - _tmp357_ = _tmp356_; - n_type_args = _tmp357_; + _tmp356_ = m; + _tmp357_ = vala_method_get_type_parameters (_tmp356_); + _tmp358_ = vala_collection_get_size ((ValaCollection*) _tmp357_); + _tmp359_ = _tmp358_; + n_type_params = _tmp359_; + _tmp360_ = ma; + _tmp361_ = vala_member_access_get_type_arguments (_tmp360_); + _tmp362_ = vala_collection_get_size ((ValaCollection*) _tmp361_); + _tmp363_ = _tmp362_; + n_type_args = _tmp363_; if (n_type_args > 0) { - _tmp358_ = n_type_args < n_type_params; + _tmp364_ = n_type_args < n_type_params; } else { - _tmp358_ = FALSE; + _tmp364_ = FALSE; } - if (_tmp358_) { - ValaMemberAccess* _tmp359_; - ValaSourceReference* _tmp360_; - ValaSourceReference* _tmp361_; + if (_tmp364_) { + ValaMemberAccess* _tmp365_; + ValaSourceReference* _tmp366_; + ValaSourceReference* _tmp367_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp359_ = ma; - _tmp360_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp359_); - _tmp361_ = _tmp360_; - vala_report_error (_tmp361_, "too few type arguments"); + _tmp365_ = ma; + _tmp366_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp365_); + _tmp367_ = _tmp366_; + vala_report_error (_tmp367_, "too few type arguments"); result = FALSE; _vala_iterable_unref0 (params); _vala_code_node_unref0 (ret_type); @@ -1818,21 +1831,21 @@ _vala_code_node_unref0 (target_object_type); return result; } else { - gboolean _tmp362_ = FALSE; + gboolean _tmp368_ = FALSE; if (n_type_args > 0) { - _tmp362_ = n_type_args > n_type_params; + _tmp368_ = n_type_args > n_type_params; } else { - _tmp362_ = FALSE; + _tmp368_ = FALSE; } - if (_tmp362_) { - ValaMemberAccess* _tmp363_; - ValaSourceReference* _tmp364_; - ValaSourceReference* _tmp365_; + if (_tmp368_) { + ValaMemberAccess* _tmp369_; + ValaSourceReference* _tmp370_; + ValaSourceReference* _tmp371_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp363_ = ma; - _tmp364_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp363_); - _tmp365_ = _tmp364_; - vala_report_error (_tmp365_, "too many type arguments"); + _tmp369_ = ma; + _tmp370_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp369_); + _tmp371_ = _tmp370_; + vala_report_error (_tmp371_, "too many type arguments"); result = FALSE; _vala_iterable_unref0 (params); _vala_code_node_unref0 (ret_type); @@ -1844,422 +1857,422 @@ } } last_arg = NULL; - _tmp366_ = self->priv->argument_list; - _tmp367_ = vala_iterable_iterator ((ValaIterable*) _tmp366_); - arg_it = _tmp367_; + _tmp372_ = self->priv->argument_list; + _tmp373_ = vala_iterable_iterator ((ValaIterable*) _tmp372_); + arg_it = _tmp373_; { ValaList* _param_list = NULL; - ValaList* _tmp368_; + ValaList* _tmp374_; gint _param_size = 0; - ValaList* _tmp369_; - gint _tmp370_; - gint _tmp371_; + ValaList* _tmp375_; + gint _tmp376_; + gint _tmp377_; gint _param_index = 0; - _tmp368_ = params; - _param_list = _tmp368_; - _tmp369_ = _param_list; - _tmp370_ = vala_collection_get_size ((ValaCollection*) _tmp369_); - _tmp371_ = _tmp370_; - _param_size = _tmp371_; + _tmp374_ = params; + _param_list = _tmp374_; + _tmp375_ = _param_list; + _tmp376_ = vala_collection_get_size ((ValaCollection*) _tmp375_); + _tmp377_ = _tmp376_; + _param_size = _tmp377_; _param_index = -1; while (TRUE) { - gint _tmp372_; - gint _tmp373_; + gint _tmp378_; + gint _tmp379_; ValaParameter* param = NULL; - ValaList* _tmp374_; - gpointer _tmp375_; - ValaParameter* _tmp376_; - ValaParameter* _tmp377_; - gboolean _tmp378_; - gboolean _tmp379_; - ValaParameter* _tmp380_; - gboolean _tmp381_; - gboolean _tmp382_; - ValaIterator* _tmp400_; + ValaList* _tmp380_; + gpointer _tmp381_; + ValaParameter* _tmp382_; + ValaParameter* _tmp383_; + gboolean _tmp384_; + gboolean _tmp385_; + ValaParameter* _tmp386_; + gboolean _tmp387_; + gboolean _tmp388_; + ValaIterator* _tmp406_; _param_index = _param_index + 1; - _tmp372_ = _param_index; - _tmp373_ = _param_size; - if (!(_tmp372_ < _tmp373_)) { + _tmp378_ = _param_index; + _tmp379_ = _param_size; + if (!(_tmp378_ < _tmp379_)) { break; } - _tmp374_ = _param_list; - _tmp375_ = vala_list_get (_tmp374_, _param_index); - param = (ValaParameter*) _tmp375_; - _tmp376_ = param; - if (!vala_code_node_check ((ValaCodeNode*) _tmp376_, context)) { + _tmp380_ = _param_list; + _tmp381_ = vala_list_get (_tmp380_, _param_index); + param = (ValaParameter*) _tmp381_; + _tmp382_ = param; + if (!vala_code_node_check ((ValaCodeNode*) _tmp382_, context)) { vala_code_node_set_error ((ValaCodeNode*) self, TRUE); } - _tmp377_ = param; - _tmp378_ = vala_parameter_get_ellipsis (_tmp377_); - _tmp379_ = _tmp378_; - if (_tmp379_) { + _tmp383_ = param; + _tmp384_ = vala_parameter_get_ellipsis (_tmp383_); + _tmp385_ = _tmp384_; + if (_tmp385_) { _vala_code_node_unref0 (param); break; } - _tmp380_ = param; - _tmp381_ = vala_parameter_get_params_array (_tmp380_); - _tmp382_ = _tmp381_; - if (_tmp382_) { + _tmp386_ = param; + _tmp387_ = vala_parameter_get_params_array (_tmp386_); + _tmp388_ = _tmp387_; + if (_tmp388_) { ValaArrayType* array_type = NULL; - ValaParameter* _tmp383_; - ValaDataType* _tmp384_; - ValaDataType* _tmp385_; - ValaArrayType* _tmp386_; - _tmp383_ = param; - _tmp384_ = vala_variable_get_variable_type ((ValaVariable*) _tmp383_); - _tmp385_ = _tmp384_; - _tmp386_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp385_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp386_; + ValaParameter* _tmp389_; + ValaDataType* _tmp390_; + ValaDataType* _tmp391_; + ValaArrayType* _tmp392_; + _tmp389_ = param; + _tmp390_ = vala_variable_get_variable_type ((ValaVariable*) _tmp389_); + _tmp391_ = _tmp390_; + _tmp392_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp391_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp392_; while (TRUE) { - ValaIterator* _tmp387_; + ValaIterator* _tmp393_; ValaExpression* arg = NULL; - ValaIterator* _tmp388_; - gpointer _tmp389_; - ValaExpression* _tmp390_; - ValaArrayType* _tmp391_; - ValaDataType* _tmp392_; - ValaDataType* _tmp393_; - ValaExpression* _tmp394_; - ValaDataType* _tmp395_; - ValaDataType* _tmp396_; + ValaIterator* _tmp394_; + gpointer _tmp395_; + ValaExpression* _tmp396_; ValaArrayType* _tmp397_; - gboolean _tmp398_; - gboolean _tmp399_; - _tmp387_ = arg_it; - if (!vala_iterator_next (_tmp387_)) { + ValaDataType* _tmp398_; + ValaDataType* _tmp399_; + ValaExpression* _tmp400_; + ValaDataType* _tmp401_; + ValaDataType* _tmp402_; + ValaArrayType* _tmp403_; + gboolean _tmp404_; + gboolean _tmp405_; + _tmp393_ = arg_it; + if (!vala_iterator_next (_tmp393_)) { break; } - _tmp388_ = arg_it; - _tmp389_ = vala_iterator_get (_tmp388_); - arg = (ValaExpression*) _tmp389_; - _tmp390_ = arg; - _tmp391_ = array_type; - _tmp392_ = vala_array_type_get_element_type (_tmp391_); - _tmp393_ = _tmp392_; - vala_expression_set_target_type (_tmp390_, _tmp393_); - _tmp394_ = arg; - _tmp395_ = vala_expression_get_target_type (_tmp394_); - _tmp396_ = _tmp395_; + _tmp394_ = arg_it; + _tmp395_ = vala_iterator_get (_tmp394_); + arg = (ValaExpression*) _tmp395_; + _tmp396_ = arg; _tmp397_ = array_type; - _tmp398_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp397_); + _tmp398_ = vala_array_type_get_element_type (_tmp397_); _tmp399_ = _tmp398_; - vala_data_type_set_value_owned (_tmp396_, _tmp399_); + vala_expression_set_target_type (_tmp396_, _tmp399_); + _tmp400_ = arg; + _tmp401_ = vala_expression_get_target_type (_tmp400_); + _tmp402_ = _tmp401_; + _tmp403_ = array_type; + _tmp404_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp403_); + _tmp405_ = _tmp404_; + vala_data_type_set_value_owned (_tmp402_, _tmp405_); _vala_code_node_unref0 (arg); } _vala_code_node_unref0 (array_type); _vala_code_node_unref0 (param); break; } - _tmp400_ = arg_it; - if (vala_iterator_next (_tmp400_)) { + _tmp406_ = arg_it; + if (vala_iterator_next (_tmp406_)) { ValaExpression* arg = NULL; - ValaIterator* _tmp401_; - gpointer _tmp402_; - ValaExpression* _tmp403_; - ValaParameter* _tmp404_; - ValaDataType* _tmp405_; - ValaDataType* _tmp406_; - ValaExpression* _tmp407_; - ValaExpression* _tmp408_; - ValaDataType* _tmp409_; - ValaDataType* _tmp410_; + ValaIterator* _tmp407_; + gpointer _tmp408_; + ValaExpression* _tmp409_; + ValaParameter* _tmp410_; ValaDataType* _tmp411_; - ValaList* _tmp412_; - ValaDataType* _tmp413_; - ValaDataType* _tmp414_; - ValaExpression* _tmp415_; - ValaExpression* _tmp416_; - _tmp401_ = arg_it; - _tmp402_ = vala_iterator_get (_tmp401_); - arg = (ValaExpression*) _tmp402_; - _tmp403_ = arg; - _tmp404_ = param; - _tmp405_ = vala_variable_get_variable_type ((ValaVariable*) _tmp404_); - _tmp406_ = _tmp405_; - vala_expression_set_formal_target_type (_tmp403_, _tmp406_); - _tmp407_ = arg; - _tmp408_ = arg; - _tmp409_ = vala_expression_get_formal_target_type (_tmp408_); - _tmp410_ = _tmp409_; - _tmp411_ = target_object_type; - _tmp412_ = method_type_args; - _tmp413_ = vala_data_type_get_actual_type (_tmp410_, _tmp411_, _tmp412_, (ValaCodeNode*) self); - _tmp414_ = _tmp413_; - vala_expression_set_target_type (_tmp407_, _tmp414_); - _vala_code_node_unref0 (_tmp414_); - _tmp415_ = arg; - _tmp416_ = _vala_code_node_ref0 (_tmp415_); + ValaDataType* _tmp412_; + ValaExpression* _tmp413_; + ValaExpression* _tmp414_; + ValaDataType* _tmp415_; + ValaDataType* _tmp416_; + ValaDataType* _tmp417_; + ValaList* _tmp418_; + ValaDataType* _tmp419_; + ValaDataType* _tmp420_; + ValaExpression* _tmp421_; + ValaExpression* _tmp422_; + _tmp407_ = arg_it; + _tmp408_ = vala_iterator_get (_tmp407_); + arg = (ValaExpression*) _tmp408_; + _tmp409_ = arg; + _tmp410_ = param; + _tmp411_ = vala_variable_get_variable_type ((ValaVariable*) _tmp410_); + _tmp412_ = _tmp411_; + vala_expression_set_formal_target_type (_tmp409_, _tmp412_); + _tmp413_ = arg; + _tmp414_ = arg; + _tmp415_ = vala_expression_get_formal_target_type (_tmp414_); + _tmp416_ = _tmp415_; + _tmp417_ = target_object_type; + _tmp418_ = method_type_args; + _tmp419_ = vala_data_type_get_actual_type (_tmp416_, _tmp417_, _tmp418_, (ValaCodeNode*) self); + _tmp420_ = _tmp419_; + vala_expression_set_target_type (_tmp413_, _tmp420_); + _vala_code_node_unref0 (_tmp420_); + _tmp421_ = arg; + _tmp422_ = _vala_code_node_ref0 (_tmp421_); _vala_code_node_unref0 (last_arg); - last_arg = _tmp416_; + last_arg = _tmp422_; _vala_code_node_unref0 (arg); } _vala_code_node_unref0 (param); } } - _tmp418_ = mtype; - if (VALA_IS_METHOD_TYPE (_tmp418_)) { - ValaDataType* _tmp419_; - ValaMethod* _tmp420_; - ValaMethod* _tmp421_; - ValaAttribute* _tmp422_; - _tmp419_ = mtype; - _tmp420_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp419_, VALA_TYPE_METHOD_TYPE, ValaMethodType)); - _tmp421_ = _tmp420_; - _tmp422_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp421_, "Print"); - _tmp417_ = _tmp422_ != NULL; + _tmp424_ = mtype; + if (VALA_IS_METHOD_TYPE (_tmp424_)) { + ValaDataType* _tmp425_; + ValaMethod* _tmp426_; + ValaMethod* _tmp427_; + ValaAttribute* _tmp428_; + _tmp425_ = mtype; + _tmp426_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp425_, VALA_TYPE_METHOD_TYPE, ValaMethodType)); + _tmp427_ = _tmp426_; + _tmp428_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp427_, "Print"); + _tmp423_ = _tmp428_ != NULL; } else { - _tmp417_ = FALSE; + _tmp423_ = FALSE; } - if (_tmp417_) { + if (_tmp423_) { ValaTemplate* template = NULL; - ValaSourceReference* _tmp423_; - ValaSourceReference* _tmp424_; - ValaTemplate* _tmp425_; - ValaList* _tmp437_; - ValaTemplate* _tmp438_; - _tmp423_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp424_ = _tmp423_; - _tmp425_ = vala_template_new (_tmp424_); - template = _tmp425_; + ValaSourceReference* _tmp429_; + ValaSourceReference* _tmp430_; + ValaTemplate* _tmp431_; + ValaList* _tmp443_; + ValaTemplate* _tmp444_; + _tmp429_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp430_ = _tmp429_; + _tmp431_ = vala_template_new (_tmp430_); + template = _tmp431_; { ValaList* _arg_list = NULL; - ValaList* _tmp426_; + ValaList* _tmp432_; gint _arg_size = 0; - ValaList* _tmp427_; - gint _tmp428_; - gint _tmp429_; + ValaList* _tmp433_; + gint _tmp434_; + gint _tmp435_; gint _arg_index = 0; - _tmp426_ = self->priv->argument_list; - _arg_list = _tmp426_; - _tmp427_ = _arg_list; - _tmp428_ = vala_collection_get_size ((ValaCollection*) _tmp427_); - _tmp429_ = _tmp428_; - _arg_size = _tmp429_; + _tmp432_ = self->priv->argument_list; + _arg_list = _tmp432_; + _tmp433_ = _arg_list; + _tmp434_ = vala_collection_get_size ((ValaCollection*) _tmp433_); + _tmp435_ = _tmp434_; + _arg_size = _tmp435_; _arg_index = -1; while (TRUE) { - gint _tmp430_; - gint _tmp431_; + gint _tmp436_; + gint _tmp437_; ValaExpression* arg = NULL; - ValaList* _tmp432_; - gpointer _tmp433_; - ValaExpression* _tmp434_; - ValaTemplate* _tmp435_; - ValaExpression* _tmp436_; + ValaList* _tmp438_; + gpointer _tmp439_; + ValaExpression* _tmp440_; + ValaTemplate* _tmp441_; + ValaExpression* _tmp442_; _arg_index = _arg_index + 1; - _tmp430_ = _arg_index; - _tmp431_ = _arg_size; - if (!(_tmp430_ < _tmp431_)) { + _tmp436_ = _arg_index; + _tmp437_ = _arg_size; + if (!(_tmp436_ < _tmp437_)) { break; } - _tmp432_ = _arg_list; - _tmp433_ = vala_list_get (_tmp432_, _arg_index); - arg = (ValaExpression*) _tmp433_; - _tmp434_ = arg; - vala_code_node_set_parent_node ((ValaCodeNode*) _tmp434_, NULL); - _tmp435_ = template; - _tmp436_ = arg; - vala_template_add_expression (_tmp435_, _tmp436_); + _tmp438_ = _arg_list; + _tmp439_ = vala_list_get (_tmp438_, _arg_index); + arg = (ValaExpression*) _tmp439_; + _tmp440_ = arg; + vala_code_node_set_parent_node ((ValaCodeNode*) _tmp440_, NULL); + _tmp441_ = template; + _tmp442_ = arg; + vala_template_add_expression (_tmp441_, _tmp442_); _vala_code_node_unref0 (arg); } } - _tmp437_ = self->priv->argument_list; - vala_collection_clear ((ValaCollection*) _tmp437_); - _tmp438_ = template; - vala_callable_expression_add_argument ((ValaCallableExpression*) self, (ValaExpression*) _tmp438_); + _tmp443_ = self->priv->argument_list; + vala_collection_clear ((ValaCollection*) _tmp443_); + _tmp444_ = template; + vala_callable_expression_add_argument ((ValaCallableExpression*) self, (ValaExpression*) _tmp444_); _vala_code_node_unref0 (template); } - _tmp440_ = mtype; - if (VALA_IS_METHOD_TYPE (_tmp440_)) { - ValaDataType* _tmp441_; - ValaMethod* _tmp442_; - ValaMethod* _tmp443_; - gboolean _tmp444_; - gboolean _tmp445_; - _tmp441_ = mtype; - _tmp442_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp441_, VALA_TYPE_METHOD_TYPE, ValaMethodType)); - _tmp443_ = _tmp442_; - _tmp444_ = vala_method_get_printf_format (_tmp443_); - _tmp445_ = _tmp444_; - _tmp439_ = _tmp445_; + _tmp446_ = mtype; + if (VALA_IS_METHOD_TYPE (_tmp446_)) { + ValaDataType* _tmp447_; + ValaMethod* _tmp448_; + ValaMethod* _tmp449_; + gboolean _tmp450_; + gboolean _tmp451_; + _tmp447_ = mtype; + _tmp448_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp447_, VALA_TYPE_METHOD_TYPE, ValaMethodType)); + _tmp449_ = _tmp448_; + _tmp450_ = vala_method_get_printf_format (_tmp449_); + _tmp451_ = _tmp450_; + _tmp445_ = _tmp451_; } else { - _tmp439_ = FALSE; + _tmp445_ = FALSE; } - if (_tmp439_) { + if (_tmp445_) { ValaStringLiteral* format_literal = NULL; - ValaExpression* _tmp446_; - ValaStringLiteral* _tmp495_; + ValaExpression* _tmp452_; + ValaStringLiteral* _tmp501_; format_literal = NULL; - _tmp446_ = last_arg; - if (VALA_IS_NULL_LITERAL (_tmp446_)) { + _tmp452_ = last_arg; + if (VALA_IS_NULL_LITERAL (_tmp452_)) { } else { - ValaExpression* _tmp447_; - _tmp447_ = last_arg; - if (_tmp447_ != NULL) { - ValaExpression* _tmp448_; - ValaStringLiteral* _tmp449_; - gboolean _tmp450_ = FALSE; - ValaStringLiteral* _tmp451_; - _tmp448_ = last_arg; - _tmp449_ = vala_string_literal_get_format_literal (_tmp448_); + ValaExpression* _tmp453_; + _tmp453_ = last_arg; + if (_tmp453_ != NULL) { + ValaExpression* _tmp454_; + ValaStringLiteral* _tmp455_; + gboolean _tmp456_ = FALSE; + ValaStringLiteral* _tmp457_; + _tmp454_ = last_arg; + _tmp455_ = vala_string_literal_get_format_literal (_tmp454_); _vala_code_node_unref0 (format_literal); - format_literal = _tmp449_; - _tmp451_ = format_literal; - if (_tmp451_ == NULL) { - ValaList* _tmp452_; - gint _tmp453_; - gint _tmp454_; - ValaList* _tmp455_; - gint _tmp456_; - gint _tmp457_; - _tmp452_ = self->priv->argument_list; - _tmp453_ = vala_collection_get_size ((ValaCollection*) _tmp452_); - _tmp454_ = _tmp453_; - _tmp455_ = params; - _tmp456_ = vala_collection_get_size ((ValaCollection*) _tmp455_); - _tmp457_ = _tmp456_; - _tmp450_ = _tmp454_ == (_tmp457_ - 1); + format_literal = _tmp455_; + _tmp457_ = format_literal; + if (_tmp457_ == NULL) { + ValaList* _tmp458_; + gint _tmp459_; + gint _tmp460_; + ValaList* _tmp461_; + gint _tmp462_; + gint _tmp463_; + _tmp458_ = self->priv->argument_list; + _tmp459_ = vala_collection_get_size ((ValaCollection*) _tmp458_); + _tmp460_ = _tmp459_; + _tmp461_ = params; + _tmp462_ = vala_collection_get_size ((ValaCollection*) _tmp461_); + _tmp463_ = _tmp462_; + _tmp456_ = _tmp460_ == (_tmp463_ - 1); } else { - _tmp450_ = FALSE; + _tmp456_ = FALSE; } - if (_tmp450_) { - ValaStringLiteral* _tmp458_; - ValaStringLiteral* _tmp459_; - ValaSemanticAnalyzer* _tmp460_; - ValaSemanticAnalyzer* _tmp461_; - ValaDataType* _tmp462_; - ValaDataType* _tmp463_; - ValaDataType* _tmp464_; - ValaList* _tmp465_; - ValaList* _tmp466_; - gint _tmp467_; - gint _tmp468_; - ValaStringLiteral* _tmp469_; - ValaList* _tmp470_; - ValaIterator* _tmp471_; - _tmp458_ = vala_string_literal_new ("\"%s\"", NULL); + if (_tmp456_) { + ValaStringLiteral* _tmp464_; + ValaStringLiteral* _tmp465_; + ValaSemanticAnalyzer* _tmp466_; + ValaSemanticAnalyzer* _tmp467_; + ValaDataType* _tmp468_; + ValaDataType* _tmp469_; + ValaDataType* _tmp470_; + ValaList* _tmp471_; + ValaList* _tmp472_; + gint _tmp473_; + gint _tmp474_; + ValaStringLiteral* _tmp475_; + ValaList* _tmp476_; + ValaIterator* _tmp477_; + _tmp464_ = vala_string_literal_new ("\"%s\"", NULL); _vala_code_node_unref0 (format_literal); - format_literal = _tmp458_; - _tmp459_ = format_literal; - _tmp460_ = vala_code_context_get_analyzer (context); - _tmp461_ = _tmp460_; - _tmp462_ = _tmp461_->string_type; - _tmp463_ = vala_data_type_copy (_tmp462_); - _tmp464_ = _tmp463_; - vala_expression_set_target_type ((ValaExpression*) _tmp459_, _tmp464_); - _vala_code_node_unref0 (_tmp464_); - _tmp465_ = self->priv->argument_list; - _tmp466_ = self->priv->argument_list; - _tmp467_ = vala_collection_get_size ((ValaCollection*) _tmp466_); - _tmp468_ = _tmp467_; - _tmp469_ = format_literal; - vala_list_insert (_tmp465_, _tmp468_ - 1, (ValaExpression*) _tmp469_); - _tmp470_ = self->priv->argument_list; - _tmp471_ = vala_iterable_iterator ((ValaIterable*) _tmp470_); + format_literal = _tmp464_; + _tmp465_ = format_literal; + _tmp466_ = vala_code_context_get_analyzer (context); + _tmp467_ = _tmp466_; + _tmp468_ = _tmp467_->string_type; + _tmp469_ = vala_data_type_copy (_tmp468_); + _tmp470_ = _tmp469_; + vala_expression_set_target_type ((ValaExpression*) _tmp465_, _tmp470_); + _vala_code_node_unref0 (_tmp470_); + _tmp471_ = self->priv->argument_list; + _tmp472_ = self->priv->argument_list; + _tmp473_ = vala_collection_get_size ((ValaCollection*) _tmp472_); + _tmp474_ = _tmp473_; + _tmp475_ = format_literal; + vala_list_insert (_tmp471_, _tmp474_ - 1, (ValaExpression*) _tmp475_); + _tmp476_ = self->priv->argument_list; + _tmp477_ = vala_iterable_iterator ((ValaIterable*) _tmp476_); _vala_iterator_unref0 (arg_it); - arg_it = _tmp471_; + arg_it = _tmp477_; { ValaList* _param_list = NULL; - ValaList* _tmp472_; + ValaList* _tmp478_; gint _param_size = 0; - ValaList* _tmp473_; - gint _tmp474_; - gint _tmp475_; + ValaList* _tmp479_; + gint _tmp480_; + gint _tmp481_; gint _param_index = 0; - _tmp472_ = params; - _param_list = _tmp472_; - _tmp473_ = _param_list; - _tmp474_ = vala_collection_get_size ((ValaCollection*) _tmp473_); - _tmp475_ = _tmp474_; - _param_size = _tmp475_; + _tmp478_ = params; + _param_list = _tmp478_; + _tmp479_ = _param_list; + _tmp480_ = vala_collection_get_size ((ValaCollection*) _tmp479_); + _tmp481_ = _tmp480_; + _param_size = _tmp481_; _param_index = -1; while (TRUE) { - gint _tmp476_; - gint _tmp477_; + gint _tmp482_; + gint _tmp483_; ValaParameter* param = NULL; - ValaList* _tmp478_; - gpointer _tmp479_; - gboolean _tmp480_ = FALSE; - ValaParameter* _tmp481_; - gboolean _tmp482_; - gboolean _tmp483_; - ValaIterator* _tmp487_; + ValaList* _tmp484_; + gpointer _tmp485_; + gboolean _tmp486_ = FALSE; + ValaParameter* _tmp487_; + gboolean _tmp488_; + gboolean _tmp489_; + ValaIterator* _tmp493_; _param_index = _param_index + 1; - _tmp476_ = _param_index; - _tmp477_ = _param_size; - if (!(_tmp476_ < _tmp477_)) { + _tmp482_ = _param_index; + _tmp483_ = _param_size; + if (!(_tmp482_ < _tmp483_)) { break; } - _tmp478_ = _param_list; - _tmp479_ = vala_list_get (_tmp478_, _param_index); - param = (ValaParameter*) _tmp479_; - _tmp481_ = param; - _tmp482_ = vala_parameter_get_ellipsis (_tmp481_); - _tmp483_ = _tmp482_; - if (_tmp483_) { - _tmp480_ = TRUE; + _tmp484_ = _param_list; + _tmp485_ = vala_list_get (_tmp484_, _param_index); + param = (ValaParameter*) _tmp485_; + _tmp487_ = param; + _tmp488_ = vala_parameter_get_ellipsis (_tmp487_); + _tmp489_ = _tmp488_; + if (_tmp489_) { + _tmp486_ = TRUE; } else { - ValaParameter* _tmp484_; - gboolean _tmp485_; - gboolean _tmp486_; - _tmp484_ = param; - _tmp485_ = vala_parameter_get_params_array (_tmp484_); - _tmp486_ = _tmp485_; - _tmp480_ = _tmp486_; + ValaParameter* _tmp490_; + gboolean _tmp491_; + gboolean _tmp492_; + _tmp490_ = param; + _tmp491_ = vala_parameter_get_params_array (_tmp490_); + _tmp492_ = _tmp491_; + _tmp486_ = _tmp492_; } - if (_tmp480_) { + if (_tmp486_) { _vala_code_node_unref0 (param); break; } - _tmp487_ = arg_it; - vala_iterator_next (_tmp487_); + _tmp493_ = arg_it; + vala_iterator_next (_tmp493_); _vala_code_node_unref0 (param); } } } } else { ValaMemberAccess* ma = NULL; - ValaExpression* _tmp488_; - ValaExpression* _tmp489_; - ValaMemberAccess* _tmp490_; - _tmp488_ = vala_method_call_get_call (self); - _tmp489_ = _tmp488_; - ma = VALA_IS_MEMBER_ACCESS (_tmp489_) ? ((ValaMemberAccess*) _tmp489_) : NULL; - _tmp490_ = ma; - if (_tmp490_ != NULL) { - ValaMemberAccess* _tmp491_; - ValaExpression* _tmp492_; - ValaExpression* _tmp493_; - ValaStringLiteral* _tmp494_; - _tmp491_ = ma; - _tmp492_ = vala_member_access_get_inner (_tmp491_); - _tmp493_ = _tmp492_; - _tmp494_ = vala_string_literal_get_format_literal (_tmp493_); + ValaExpression* _tmp494_; + ValaExpression* _tmp495_; + ValaMemberAccess* _tmp496_; + _tmp494_ = vala_method_call_get_call (self); + _tmp495_ = _tmp494_; + ma = VALA_IS_MEMBER_ACCESS (_tmp495_) ? ((ValaMemberAccess*) _tmp495_) : NULL; + _tmp496_ = ma; + if (_tmp496_ != NULL) { + ValaMemberAccess* _tmp497_; + ValaExpression* _tmp498_; + ValaExpression* _tmp499_; + ValaStringLiteral* _tmp500_; + _tmp497_ = ma; + _tmp498_ = vala_member_access_get_inner (_tmp497_); + _tmp499_ = _tmp498_; + _tmp500_ = vala_string_literal_get_format_literal (_tmp499_); _vala_code_node_unref0 (format_literal); - format_literal = _tmp494_; + format_literal = _tmp500_; } } } - _tmp495_ = format_literal; - if (_tmp495_ != NULL) { + _tmp501_ = format_literal; + if (_tmp501_ != NULL) { gchar* format = NULL; - ValaStringLiteral* _tmp496_; - gchar* _tmp497_; - ValaSemanticAnalyzer* _tmp498_; - ValaSemanticAnalyzer* _tmp499_; - const gchar* _tmp500_; - ValaIterator* _tmp501_; - ValaSourceReference* _tmp502_; - ValaSourceReference* _tmp503_; - _tmp496_ = format_literal; - _tmp497_ = vala_string_literal_eval (_tmp496_); - format = _tmp497_; - _tmp498_ = vala_code_context_get_analyzer (context); - _tmp499_ = _tmp498_; - _tmp500_ = format; - _tmp501_ = arg_it; - _tmp502_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp503_ = _tmp502_; - if (!vala_semantic_analyzer_check_print_format (_tmp499_, _tmp500_, _tmp501_, _tmp503_)) { + ValaStringLiteral* _tmp502_; + gchar* _tmp503_; + ValaSemanticAnalyzer* _tmp504_; + ValaSemanticAnalyzer* _tmp505_; + const gchar* _tmp506_; + ValaIterator* _tmp507_; + ValaSourceReference* _tmp508_; + ValaSourceReference* _tmp509_; + _tmp502_ = format_literal; + _tmp503_ = vala_string_literal_eval (_tmp502_); + format = _tmp503_; + _tmp504_ = vala_code_context_get_analyzer (context); + _tmp505_ = _tmp504_; + _tmp506_ = format; + _tmp507_ = arg_it; + _tmp508_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp509_ = _tmp508_; + if (!vala_semantic_analyzer_check_print_format (_tmp505_, _tmp506_, _tmp507_, _tmp509_)) { vala_code_node_set_error ((ValaCodeNode*) self, TRUE); result = FALSE; _g_free0 (format); @@ -2280,171 +2293,171 @@ force_lambda_method_closure = FALSE; { ValaList* _arg_list = NULL; - ValaList* _tmp504_; + ValaList* _tmp510_; gint _arg_size = 0; - ValaList* _tmp505_; - gint _tmp506_; - gint _tmp507_; + ValaList* _tmp511_; + gint _tmp512_; + gint _tmp513_; gint _arg_index = 0; - _tmp504_ = self->priv->argument_list; - _arg_list = _tmp504_; - _tmp505_ = _arg_list; - _tmp506_ = vala_collection_get_size ((ValaCollection*) _tmp505_); - _tmp507_ = _tmp506_; - _arg_size = _tmp507_; + _tmp510_ = self->priv->argument_list; + _arg_list = _tmp510_; + _tmp511_ = _arg_list; + _tmp512_ = vala_collection_get_size ((ValaCollection*) _tmp511_); + _tmp513_ = _tmp512_; + _arg_size = _tmp513_; _arg_index = -1; while (TRUE) { - gint _tmp508_; - gint _tmp509_; + gint _tmp514_; + gint _tmp515_; ValaExpression* arg = NULL; - ValaList* _tmp510_; - gpointer _tmp511_; - ValaExpression* _tmp512_; - gboolean _tmp513_ = FALSE; - ValaExpression* _tmp514_; + ValaList* _tmp516_; + gpointer _tmp517_; + ValaExpression* _tmp518_; + gboolean _tmp519_ = FALSE; + ValaExpression* _tmp520_; _arg_index = _arg_index + 1; - _tmp508_ = _arg_index; - _tmp509_ = _arg_size; - if (!(_tmp508_ < _tmp509_)) { + _tmp514_ = _arg_index; + _tmp515_ = _arg_size; + if (!(_tmp514_ < _tmp515_)) { break; } - _tmp510_ = _arg_list; - _tmp511_ = vala_list_get (_tmp510_, _arg_index); - arg = (ValaExpression*) _tmp511_; - _tmp512_ = arg; - if (!vala_code_node_check ((ValaCodeNode*) _tmp512_, context)) { + _tmp516_ = _arg_list; + _tmp517_ = vala_list_get (_tmp516_, _arg_index); + arg = (ValaExpression*) _tmp517_; + _tmp518_ = arg; + if (!vala_code_node_check ((ValaCodeNode*) _tmp518_, context)) { vala_code_node_set_error ((ValaCodeNode*) self, TRUE); _vala_code_node_unref0 (arg); continue; } - _tmp514_ = arg; - if (VALA_IS_LAMBDA_EXPRESSION (_tmp514_)) { - ValaExpression* _tmp515_; - ValaMethod* _tmp516_; - ValaMethod* _tmp517_; - gboolean _tmp518_; - gboolean _tmp519_; - _tmp515_ = arg; - _tmp516_ = vala_lambda_expression_get_method (G_TYPE_CHECK_INSTANCE_CAST (_tmp515_, VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpression)); - _tmp517_ = _tmp516_; - _tmp518_ = vala_method_get_closure (_tmp517_); - _tmp519_ = _tmp518_; - _tmp513_ = _tmp519_; + _tmp520_ = arg; + if (VALA_IS_LAMBDA_EXPRESSION (_tmp520_)) { + ValaExpression* _tmp521_; + ValaMethod* _tmp522_; + ValaMethod* _tmp523_; + gboolean _tmp524_; + gboolean _tmp525_; + _tmp521_ = arg; + _tmp522_ = vala_lambda_expression_get_method (G_TYPE_CHECK_INSTANCE_CAST (_tmp521_, VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpression)); + _tmp523_ = _tmp522_; + _tmp524_ = vala_method_get_closure (_tmp523_); + _tmp525_ = _tmp524_; + _tmp519_ = _tmp525_; } else { - _tmp513_ = FALSE; + _tmp519_ = FALSE; } - if (_tmp513_) { + if (_tmp519_) { force_lambda_method_closure = TRUE; } _vala_code_node_unref0 (arg); } } - _tmp521_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp522_ = _tmp521_; - if (!_tmp522_) { - _tmp520_ = force_lambda_method_closure; + _tmp527_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp528_ = _tmp527_; + if (!_tmp528_) { + _tmp526_ = force_lambda_method_closure; } else { - _tmp520_ = FALSE; + _tmp526_ = FALSE; } - if (_tmp520_) { + if (_tmp526_) { { ValaList* _arg_list = NULL; - ValaList* _tmp523_; + ValaList* _tmp529_; gint _arg_size = 0; - ValaList* _tmp524_; - gint _tmp525_; - gint _tmp526_; + ValaList* _tmp530_; + gint _tmp531_; + gint _tmp532_; gint _arg_index = 0; - _tmp523_ = self->priv->argument_list; - _arg_list = _tmp523_; - _tmp524_ = _arg_list; - _tmp525_ = vala_collection_get_size ((ValaCollection*) _tmp524_); - _tmp526_ = _tmp525_; - _arg_size = _tmp526_; + _tmp529_ = self->priv->argument_list; + _arg_list = _tmp529_; + _tmp530_ = _arg_list; + _tmp531_ = vala_collection_get_size ((ValaCollection*) _tmp530_); + _tmp532_ = _tmp531_; + _arg_size = _tmp532_; _arg_index = -1; while (TRUE) { - gint _tmp527_; - gint _tmp528_; + gint _tmp533_; + gint _tmp534_; ValaExpression* arg = NULL; - ValaList* _tmp529_; - gpointer _tmp530_; + ValaList* _tmp535_; + gpointer _tmp536_; ValaLambdaExpression* lambda = NULL; - ValaExpression* _tmp531_; - gboolean _tmp532_ = FALSE; - ValaLambdaExpression* _tmp533_; + ValaExpression* _tmp537_; + gboolean _tmp538_ = FALSE; + ValaLambdaExpression* _tmp539_; _arg_index = _arg_index + 1; - _tmp527_ = _arg_index; - _tmp528_ = _arg_size; - if (!(_tmp527_ < _tmp528_)) { + _tmp533_ = _arg_index; + _tmp534_ = _arg_size; + if (!(_tmp533_ < _tmp534_)) { break; } - _tmp529_ = _arg_list; - _tmp530_ = vala_list_get (_tmp529_, _arg_index); - arg = (ValaExpression*) _tmp530_; - _tmp531_ = arg; - lambda = VALA_IS_LAMBDA_EXPRESSION (_tmp531_) ? ((ValaLambdaExpression*) _tmp531_) : NULL; - _tmp533_ = lambda; - if (_tmp533_ != NULL) { - ValaLambdaExpression* _tmp534_; - ValaMethod* _tmp535_; - ValaMethod* _tmp536_; - ValaMemberBinding _tmp537_; - ValaMemberBinding _tmp538_; - _tmp534_ = lambda; - _tmp535_ = vala_lambda_expression_get_method (_tmp534_); - _tmp536_ = _tmp535_; - _tmp537_ = vala_method_get_binding (_tmp536_); - _tmp538_ = _tmp537_; - _tmp532_ = _tmp538_ != VALA_MEMBER_BINDING_STATIC; + _tmp535_ = _arg_list; + _tmp536_ = vala_list_get (_tmp535_, _arg_index); + arg = (ValaExpression*) _tmp536_; + _tmp537_ = arg; + lambda = VALA_IS_LAMBDA_EXPRESSION (_tmp537_) ? ((ValaLambdaExpression*) _tmp537_) : NULL; + _tmp539_ = lambda; + if (_tmp539_ != NULL) { + ValaLambdaExpression* _tmp540_; + ValaMethod* _tmp541_; + ValaMethod* _tmp542_; + ValaMemberBinding _tmp543_; + ValaMemberBinding _tmp544_; + _tmp540_ = lambda; + _tmp541_ = vala_lambda_expression_get_method (_tmp540_); + _tmp542_ = _tmp541_; + _tmp543_ = vala_method_get_binding (_tmp542_); + _tmp544_ = _tmp543_; + _tmp538_ = _tmp544_ != VALA_MEMBER_BINDING_STATIC; } else { - _tmp532_ = FALSE; + _tmp538_ = FALSE; } - if (_tmp532_) { - ValaLambdaExpression* _tmp539_; - ValaMethod* _tmp540_; - ValaMethod* _tmp541_; - _tmp539_ = lambda; - _tmp540_ = vala_lambda_expression_get_method (_tmp539_); - _tmp541_ = _tmp540_; - vala_method_set_closure (_tmp541_, TRUE); + if (_tmp538_) { + ValaLambdaExpression* _tmp545_; + ValaMethod* _tmp546_; + ValaMethod* _tmp547_; + _tmp545_ = lambda; + _tmp546_ = vala_lambda_expression_get_method (_tmp545_); + _tmp547_ = _tmp546_; + vala_method_set_closure (_tmp547_, TRUE); } _vala_code_node_unref0 (arg); } } } - _tmp542_ = ret_type; - if (VALA_IS_VOID_TYPE (_tmp542_)) { - gboolean _tmp543_ = FALSE; - gboolean _tmp544_ = FALSE; - ValaCodeNode* _tmp545_; - ValaCodeNode* _tmp546_; - _tmp545_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp546_ = _tmp545_; - if (!VALA_IS_EXPRESSION_STATEMENT (_tmp546_)) { - ValaCodeNode* _tmp547_; - ValaCodeNode* _tmp548_; - _tmp547_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp548_ = _tmp547_; - _tmp544_ = !VALA_IS_FOR_STATEMENT (_tmp548_); - } else { - _tmp544_ = FALSE; - } - if (_tmp544_) { - ValaCodeNode* _tmp549_; - ValaCodeNode* _tmp550_; - _tmp549_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp550_ = _tmp549_; - _tmp543_ = !VALA_IS_YIELD_STATEMENT (_tmp550_); - } else { - _tmp543_ = FALSE; - } - if (_tmp543_) { - ValaSourceReference* _tmp551_; - ValaSourceReference* _tmp552_; + _tmp548_ = ret_type; + if (VALA_IS_VOID_TYPE (_tmp548_)) { + gboolean _tmp549_ = FALSE; + gboolean _tmp550_ = FALSE; + ValaCodeNode* _tmp551_; + ValaCodeNode* _tmp552_; + _tmp551_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp552_ = _tmp551_; + if (!VALA_IS_EXPRESSION_STATEMENT (_tmp552_)) { + ValaCodeNode* _tmp553_; + ValaCodeNode* _tmp554_; + _tmp553_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp554_ = _tmp553_; + _tmp550_ = !VALA_IS_FOR_STATEMENT (_tmp554_); + } else { + _tmp550_ = FALSE; + } + if (_tmp550_) { + ValaCodeNode* _tmp555_; + ValaCodeNode* _tmp556_; + _tmp555_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp556_ = _tmp555_; + _tmp549_ = !VALA_IS_YIELD_STATEMENT (_tmp556_); + } else { + _tmp549_ = FALSE; + } + if (_tmp549_) { + ValaSourceReference* _tmp557_; + ValaSourceReference* _tmp558_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp551_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp552_ = _tmp551_; - vala_report_error (_tmp552_, "invocation of void method not allowed as expression"); + _tmp557_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp558_ = _tmp557_; + vala_report_error (_tmp558_, "invocation of void method not allowed as expression"); result = FALSE; _vala_iterator_unref0 (arg_it); _vala_code_node_unref0 (last_arg); @@ -2456,288 +2469,288 @@ return result; } } - _tmp553_ = ret_type; - _tmp554_ = vala_data_type_copy (_tmp553_); - _tmp555_ = _tmp554_; - vala_expression_set_formal_value_type ((ValaExpression*) self, _tmp555_); - _vala_code_node_unref0 (_tmp555_); - _tmp556_ = vala_expression_get_formal_value_type ((ValaExpression*) self); - _tmp557_ = _tmp556_; - _tmp558_ = target_object_type; - _tmp559_ = method_type_args; - _tmp560_ = vala_data_type_get_actual_type (_tmp557_, _tmp558_, _tmp559_, (ValaCodeNode*) self); + _tmp559_ = ret_type; + _tmp560_ = vala_data_type_copy (_tmp559_); _tmp561_ = _tmp560_; - vala_expression_set_value_type ((ValaExpression*) self, _tmp561_); + vala_expression_set_formal_value_type ((ValaExpression*) self, _tmp561_); _vala_code_node_unref0 (_tmp561_); - _tmp562_ = vala_callable_expression_get_is_yield_expression ((ValaCallableExpression*) self); + _tmp562_ = vala_expression_get_formal_value_type ((ValaExpression*) self); _tmp563_ = _tmp562_; - if (_tmp563_) { - gboolean _tmp564_ = FALSE; - ValaDataType* _tmp565_; - gboolean _tmp573_ = FALSE; - ValaSemanticAnalyzer* _tmp574_; - ValaSemanticAnalyzer* _tmp575_; - ValaMethod* _tmp576_; - ValaMethod* _tmp577_; - _tmp565_ = mtype; - if (!VALA_IS_METHOD_TYPE (_tmp565_)) { - _tmp564_ = TRUE; - } else { - ValaDataType* _tmp566_; - ValaMethod* _tmp567_; - ValaMethod* _tmp568_; - gboolean _tmp569_; - gboolean _tmp570_; - _tmp566_ = mtype; - _tmp567_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp566_, VALA_TYPE_METHOD_TYPE, ValaMethodType)); - _tmp568_ = _tmp567_; - _tmp569_ = vala_method_get_coroutine (_tmp568_); - _tmp570_ = _tmp569_; - _tmp564_ = !_tmp570_; - } - if (_tmp564_) { - ValaSourceReference* _tmp571_; - ValaSourceReference* _tmp572_; + _tmp564_ = target_object_type; + _tmp565_ = method_type_args; + _tmp566_ = vala_data_type_get_actual_type (_tmp563_, _tmp564_, _tmp565_, (ValaCodeNode*) self); + _tmp567_ = _tmp566_; + vala_expression_set_value_type ((ValaExpression*) self, _tmp567_); + _vala_code_node_unref0 (_tmp567_); + _tmp568_ = vala_callable_expression_get_is_yield_expression ((ValaCallableExpression*) self); + _tmp569_ = _tmp568_; + if (_tmp569_) { + gboolean _tmp570_ = FALSE; + ValaDataType* _tmp571_; + gboolean _tmp579_ = FALSE; + ValaSemanticAnalyzer* _tmp580_; + ValaSemanticAnalyzer* _tmp581_; + ValaMethod* _tmp582_; + ValaMethod* _tmp583_; + _tmp571_ = mtype; + if (!VALA_IS_METHOD_TYPE (_tmp571_)) { + _tmp570_ = TRUE; + } else { + ValaDataType* _tmp572_; + ValaMethod* _tmp573_; + ValaMethod* _tmp574_; + gboolean _tmp575_; + gboolean _tmp576_; + _tmp572_ = mtype; + _tmp573_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp572_, VALA_TYPE_METHOD_TYPE, ValaMethodType)); + _tmp574_ = _tmp573_; + _tmp575_ = vala_method_get_coroutine (_tmp574_); + _tmp576_ = _tmp575_; + _tmp570_ = !_tmp576_; + } + if (_tmp570_) { + ValaSourceReference* _tmp577_; + ValaSourceReference* _tmp578_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp571_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp572_ = _tmp571_; - vala_report_error (_tmp572_, "yield expression requires async method"); - } - _tmp574_ = vala_code_context_get_analyzer (context); - _tmp575_ = _tmp574_; - _tmp576_ = vala_semantic_analyzer_get_current_method (_tmp575_); - _tmp577_ = _tmp576_; - if (_tmp577_ == NULL) { - _tmp573_ = TRUE; - } else { - ValaSemanticAnalyzer* _tmp578_; - ValaSemanticAnalyzer* _tmp579_; - ValaMethod* _tmp580_; - ValaMethod* _tmp581_; - gboolean _tmp582_; - gboolean _tmp583_; - _tmp578_ = vala_code_context_get_analyzer (context); - _tmp579_ = _tmp578_; - _tmp580_ = vala_semantic_analyzer_get_current_method (_tmp579_); - _tmp581_ = _tmp580_; - _tmp582_ = vala_method_get_coroutine (_tmp581_); - _tmp583_ = _tmp582_; - _tmp573_ = !_tmp583_; - } - if (_tmp573_) { - ValaSourceReference* _tmp584_; - ValaSourceReference* _tmp585_; - vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp584_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp577_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp578_ = _tmp577_; + vala_report_error (_tmp578_, "yield expression requires async method"); + } + _tmp580_ = vala_code_context_get_analyzer (context); + _tmp581_ = _tmp580_; + _tmp582_ = vala_semantic_analyzer_get_current_method (_tmp581_); + _tmp583_ = _tmp582_; + if (_tmp583_ == NULL) { + _tmp579_ = TRUE; + } else { + ValaSemanticAnalyzer* _tmp584_; + ValaSemanticAnalyzer* _tmp585_; + ValaMethod* _tmp586_; + ValaMethod* _tmp587_; + gboolean _tmp588_; + gboolean _tmp589_; + _tmp584_ = vala_code_context_get_analyzer (context); _tmp585_ = _tmp584_; - vala_report_error (_tmp585_, "yield expression not available outside async method"); + _tmp586_ = vala_semantic_analyzer_get_current_method (_tmp585_); + _tmp587_ = _tmp586_; + _tmp588_ = vala_method_get_coroutine (_tmp587_); + _tmp589_ = _tmp588_; + _tmp579_ = !_tmp589_; + } + if (_tmp579_) { + ValaSourceReference* _tmp590_; + ValaSourceReference* _tmp591_; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp590_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp591_ = _tmp590_; + vala_report_error (_tmp591_, "yield expression not available outside async method"); } } - _tmp586_ = mtype; - if (VALA_IS_METHOD_TYPE (_tmp586_)) { + _tmp592_ = mtype; + if (VALA_IS_METHOD_TYPE (_tmp592_)) { ValaMethod* m = NULL; - ValaDataType* _tmp587_; - ValaMethod* _tmp588_; - ValaMethod* _tmp589_; - ValaMethod* _tmp590_; - gboolean _tmp591_; - gboolean _tmp592_; + ValaDataType* _tmp593_; + ValaMethod* _tmp594_; ValaMethod* _tmp595_; - gboolean _tmp596_; + ValaMethod* _tmp596_; gboolean _tmp597_; - gboolean _tmp623_ = FALSE; - gboolean _tmp624_ = FALSE; - gboolean _tmp625_ = FALSE; - gboolean _tmp626_; - gboolean _tmp627_; + gboolean _tmp598_; + ValaMethod* _tmp601_; + gboolean _tmp602_; + gboolean _tmp603_; + gboolean _tmp629_ = FALSE; + gboolean _tmp630_ = FALSE; + gboolean _tmp631_ = FALSE; + gboolean _tmp632_; + gboolean _tmp633_; ValaSignal* sig = NULL; - ValaMethod* _tmp639_; - ValaSymbol* _tmp640_; - ValaSymbol* _tmp641_; - gboolean _tmp642_ = FALSE; - ValaSignal* _tmp643_; + ValaMethod* _tmp645_; + ValaSymbol* _tmp646_; + ValaSymbol* _tmp647_; + gboolean _tmp648_ = FALSE; + ValaSignal* _tmp649_; ValaDynamicSignal* dynamic_sig = NULL; - ValaMethod* _tmp656_; - ValaSymbol* _tmp657_; - ValaSymbol* _tmp658_; - gboolean _tmp659_ = FALSE; - ValaDynamicSignal* _tmp660_; - gboolean _tmp703_ = FALSE; - ValaMethod* _tmp704_; - gboolean _tmp812_ = FALSE; - ValaMethod* _tmp813_; - _tmp587_ = mtype; - _tmp588_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp587_, VALA_TYPE_METHOD_TYPE, ValaMethodType)); - _tmp589_ = _tmp588_; - m = _tmp589_; - _tmp590_ = m; - _tmp591_ = vala_method_get_returns_floating_reference (_tmp590_); - _tmp592_ = _tmp591_; - if (_tmp592_) { - ValaDataType* _tmp593_; - ValaDataType* _tmp594_; - _tmp593_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp594_ = _tmp593_; - vala_data_type_set_floating_reference (_tmp594_, TRUE); - } - _tmp595_ = m; - _tmp596_ = vala_method_get_returns_modified_pointer (_tmp595_); - _tmp597_ = _tmp596_; - if (_tmp597_) { + ValaMethod* _tmp662_; + ValaSymbol* _tmp663_; + ValaSymbol* _tmp664_; + gboolean _tmp665_ = FALSE; + ValaDynamicSignal* _tmp666_; + gboolean _tmp716_ = FALSE; + ValaMethod* _tmp717_; + gboolean _tmp825_ = FALSE; + ValaMethod* _tmp826_; + _tmp593_ = mtype; + _tmp594_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp593_, VALA_TYPE_METHOD_TYPE, ValaMethodType)); + _tmp595_ = _tmp594_; + m = _tmp595_; + _tmp596_ = m; + _tmp597_ = vala_method_get_returns_floating_reference (_tmp596_); + _tmp598_ = _tmp597_; + if (_tmp598_) { + ValaDataType* _tmp599_; + ValaDataType* _tmp600_; + _tmp599_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp600_ = _tmp599_; + vala_data_type_set_floating_reference (_tmp600_, TRUE); + } + _tmp601_ = m; + _tmp602_ = vala_method_get_returns_modified_pointer (_tmp601_); + _tmp603_ = _tmp602_; + if (_tmp603_) { ValaExpression* inner = NULL; - ValaExpression* _tmp598_; - ValaExpression* _tmp599_; - ValaExpression* _tmp600_; - ValaExpression* _tmp601_; - ValaExpression* _tmp602_; + ValaExpression* _tmp604_; + ValaExpression* _tmp605_; + ValaExpression* _tmp606_; + ValaExpression* _tmp607_; + ValaExpression* _tmp608_; ValaProperty* prop = NULL; - ValaExpression* _tmp603_; - ValaSymbol* _tmp604_; - ValaSymbol* _tmp605_; - gboolean _tmp606_ = FALSE; - ValaProperty* _tmp607_; - _tmp598_ = vala_method_call_get_call (self); - _tmp599_ = _tmp598_; - _tmp600_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp599_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); - _tmp601_ = _tmp600_; - inner = _tmp601_; - _tmp602_ = inner; - vala_expression_set_lvalue (_tmp602_, TRUE); - _tmp603_ = inner; - _tmp604_ = vala_expression_get_symbol_reference (_tmp603_); + ValaExpression* _tmp609_; + ValaSymbol* _tmp610_; + ValaSymbol* _tmp611_; + gboolean _tmp612_ = FALSE; + ValaProperty* _tmp613_; + _tmp604_ = vala_method_call_get_call (self); _tmp605_ = _tmp604_; - prop = VALA_IS_PROPERTY (_tmp605_) ? ((ValaProperty*) _tmp605_) : NULL; - _tmp607_ = prop; - if (_tmp607_ != NULL) { - gboolean _tmp608_ = FALSE; - ValaProperty* _tmp609_; - ValaPropertyAccessor* _tmp610_; - ValaPropertyAccessor* _tmp611_; - _tmp609_ = prop; - _tmp610_ = vala_property_get_set_accessor (_tmp609_); - _tmp611_ = _tmp610_; - if (_tmp611_ == NULL) { - _tmp608_ = TRUE; + _tmp606_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp605_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); + _tmp607_ = _tmp606_; + inner = _tmp607_; + _tmp608_ = inner; + vala_expression_set_lvalue (_tmp608_, TRUE); + _tmp609_ = inner; + _tmp610_ = vala_expression_get_symbol_reference (_tmp609_); + _tmp611_ = _tmp610_; + prop = VALA_IS_PROPERTY (_tmp611_) ? ((ValaProperty*) _tmp611_) : NULL; + _tmp613_ = prop; + if (_tmp613_ != NULL) { + gboolean _tmp614_ = FALSE; + ValaProperty* _tmp615_; + ValaPropertyAccessor* _tmp616_; + ValaPropertyAccessor* _tmp617_; + _tmp615_ = prop; + _tmp616_ = vala_property_get_set_accessor (_tmp615_); + _tmp617_ = _tmp616_; + if (_tmp617_ == NULL) { + _tmp614_ = TRUE; } else { - ValaProperty* _tmp612_; - ValaPropertyAccessor* _tmp613_; - ValaPropertyAccessor* _tmp614_; - gboolean _tmp615_; - gboolean _tmp616_; - _tmp612_ = prop; - _tmp613_ = vala_property_get_set_accessor (_tmp612_); - _tmp614_ = _tmp613_; - _tmp615_ = vala_property_accessor_get_writable (_tmp614_); - _tmp616_ = _tmp615_; - _tmp608_ = !_tmp616_; + ValaProperty* _tmp618_; + ValaPropertyAccessor* _tmp619_; + ValaPropertyAccessor* _tmp620_; + gboolean _tmp621_; + gboolean _tmp622_; + _tmp618_ = prop; + _tmp619_ = vala_property_get_set_accessor (_tmp618_); + _tmp620_ = _tmp619_; + _tmp621_ = vala_property_accessor_get_writable (_tmp620_); + _tmp622_ = _tmp621_; + _tmp614_ = !_tmp622_; } - _tmp606_ = _tmp608_; + _tmp612_ = _tmp614_; } else { - _tmp606_ = FALSE; + _tmp612_ = FALSE; } - if (_tmp606_) { - ValaExpression* _tmp617_; - ValaSourceReference* _tmp618_; - ValaSourceReference* _tmp619_; - ValaProperty* _tmp620_; - gchar* _tmp621_; - gchar* _tmp622_; + if (_tmp612_) { + ValaExpression* _tmp623_; + ValaSourceReference* _tmp624_; + ValaSourceReference* _tmp625_; + ValaProperty* _tmp626_; + gchar* _tmp627_; + gchar* _tmp628_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp617_ = inner; - _tmp618_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp617_); - _tmp619_ = _tmp618_; - _tmp620_ = prop; - _tmp621_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp620_); - _tmp622_ = _tmp621_; - vala_report_error (_tmp619_, "Property `%s' is read-only", _tmp622_); - _g_free0 (_tmp622_); - } - } - _tmp626_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) self); - _tmp627_ = _tmp626_; - if (_tmp627_) { - ValaDataType* _tmp628_; - ValaDataType* _tmp629_; - gboolean _tmp630_; - gboolean _tmp631_; - _tmp628_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp629_ = _tmp628_; - _tmp630_ = vala_data_type_get_nullable (_tmp629_); - _tmp631_ = _tmp630_; - _tmp625_ = !_tmp631_; - } else { - _tmp625_ = FALSE; - } - if (_tmp625_) { - ValaDataType* _tmp632_; - ValaDataType* _tmp633_; - gboolean _tmp634_; - gboolean _tmp635_; - _tmp632_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp633_ = _tmp632_; - _tmp634_ = vala_data_type_get_floating_reference (_tmp633_); + _tmp623_ = inner; + _tmp624_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp623_); + _tmp625_ = _tmp624_; + _tmp626_ = prop; + _tmp627_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp626_); + _tmp628_ = _tmp627_; + vala_report_error (_tmp625_, "Property `%s' is read-only", _tmp628_); + _g_free0 (_tmp628_); + } + } + _tmp632_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) self); + _tmp633_ = _tmp632_; + if (_tmp633_) { + ValaDataType* _tmp634_; + ValaDataType* _tmp635_; + gboolean _tmp636_; + gboolean _tmp637_; + _tmp634_ = vala_expression_get_value_type ((ValaExpression*) self); _tmp635_ = _tmp634_; - _tmp624_ = _tmp635_; + _tmp636_ = vala_data_type_get_nullable (_tmp635_); + _tmp637_ = _tmp636_; + _tmp631_ = !_tmp637_; } else { - _tmp624_ = FALSE; + _tmp631_ = FALSE; } - if (_tmp624_) { - ValaDataType* _tmp636_; - _tmp636_ = ret_type; - _tmp623_ = VALA_IS_OBJECT_TYPE (_tmp636_); - } else { - _tmp623_ = FALSE; - } - if (_tmp623_) { - ValaDataType* _tmp637_; + if (_tmp631_) { ValaDataType* _tmp638_; - _tmp637_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp638_ = _tmp637_; - vala_data_type_set_nullable (_tmp638_, TRUE); - } - _tmp639_ = m; - _tmp640_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp639_); - _tmp641_ = _tmp640_; - sig = VALA_IS_SIGNAL (_tmp641_) ? ((ValaSignal*) _tmp641_) : NULL; - _tmp643_ = sig; - if (_tmp643_ != NULL) { - ValaMethod* _tmp644_; - const gchar* _tmp645_; - const gchar* _tmp646_; - _tmp644_ = m; - _tmp645_ = vala_symbol_get_name ((ValaSymbol*) _tmp644_); - _tmp646_ = _tmp645_; - _tmp642_ = g_strcmp0 (_tmp646_, "disconnect") == 0; - } else { - _tmp642_ = FALSE; - } - if (_tmp642_) { - gboolean _tmp647_ = FALSE; - ValaList* _tmp648_; - gboolean _tmp649_; - gboolean _tmp650_; - _tmp648_ = self->priv->argument_list; - _tmp649_ = vala_collection_get_is_empty ((ValaCollection*) _tmp648_); - _tmp650_ = _tmp649_; - if (!_tmp650_) { - ValaList* _tmp651_; - gpointer _tmp652_; - ValaExpression* _tmp653_; - _tmp651_ = self->priv->argument_list; - _tmp652_ = vala_list_get (_tmp651_, 0); - _tmp653_ = (ValaExpression*) _tmp652_; - _tmp647_ = VALA_IS_LAMBDA_EXPRESSION (_tmp653_); - _vala_code_node_unref0 (_tmp653_); + ValaDataType* _tmp639_; + gboolean _tmp640_; + gboolean _tmp641_; + _tmp638_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp639_ = _tmp638_; + _tmp640_ = vala_data_type_get_floating_reference (_tmp639_); + _tmp641_ = _tmp640_; + _tmp630_ = _tmp641_; + } else { + _tmp630_ = FALSE; + } + if (_tmp630_) { + ValaDataType* _tmp642_; + _tmp642_ = ret_type; + _tmp629_ = VALA_IS_OBJECT_TYPE (_tmp642_); + } else { + _tmp629_ = FALSE; + } + if (_tmp629_) { + ValaDataType* _tmp643_; + ValaDataType* _tmp644_; + _tmp643_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp644_ = _tmp643_; + vala_data_type_set_nullable (_tmp644_, TRUE); + } + _tmp645_ = m; + _tmp646_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp645_); + _tmp647_ = _tmp646_; + sig = VALA_IS_SIGNAL (_tmp647_) ? ((ValaSignal*) _tmp647_) : NULL; + _tmp649_ = sig; + if (_tmp649_ != NULL) { + ValaMethod* _tmp650_; + const gchar* _tmp651_; + const gchar* _tmp652_; + _tmp650_ = m; + _tmp651_ = vala_symbol_get_name ((ValaSymbol*) _tmp650_); + _tmp652_ = _tmp651_; + _tmp648_ = g_strcmp0 (_tmp652_, "disconnect") == 0; + } else { + _tmp648_ = FALSE; + } + if (_tmp648_) { + gboolean _tmp653_ = FALSE; + ValaList* _tmp654_; + gboolean _tmp655_; + gboolean _tmp656_; + _tmp654_ = self->priv->argument_list; + _tmp655_ = vala_collection_get_is_empty ((ValaCollection*) _tmp654_); + _tmp656_ = _tmp655_; + if (!_tmp656_) { + ValaList* _tmp657_; + gpointer _tmp658_; + ValaExpression* _tmp659_; + _tmp657_ = self->priv->argument_list; + _tmp658_ = vala_list_get (_tmp657_, 0); + _tmp659_ = (ValaExpression*) _tmp658_; + _tmp653_ = VALA_IS_LAMBDA_EXPRESSION (_tmp659_); + _vala_code_node_unref0 (_tmp659_); } else { - _tmp647_ = FALSE; + _tmp653_ = FALSE; } - if (_tmp647_) { - ValaSourceReference* _tmp654_; - ValaSourceReference* _tmp655_; + if (_tmp653_) { + ValaSourceReference* _tmp660_; + ValaSourceReference* _tmp661_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp654_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp655_ = _tmp654_; - vala_report_error (_tmp655_, "Cannot disconnect lambda expression from signal"); + _tmp660_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp661_ = _tmp660_; + vala_report_error (_tmp661_, "Cannot disconnect lambda expression from signal"); result = FALSE; _vala_iterator_unref0 (arg_it); _vala_code_node_unref0 (last_arg); @@ -2749,364 +2762,379 @@ return result; } } - _tmp656_ = m; - _tmp657_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp656_); - _tmp658_ = _tmp657_; - dynamic_sig = VALA_IS_DYNAMIC_SIGNAL (_tmp658_) ? ((ValaDynamicSignal*) _tmp658_) : NULL; - _tmp660_ = dynamic_sig; - if (_tmp660_ != NULL) { - ValaDynamicSignal* _tmp661_; - ValaExpression* _tmp662_; - ValaExpression* _tmp663_; - _tmp661_ = dynamic_sig; - _tmp662_ = vala_dynamic_signal_get_handler (_tmp661_); - _tmp663_ = _tmp662_; - _tmp659_ = _tmp663_ != NULL; - } else { - _tmp659_ = FALSE; - } - if (_tmp659_) { - ValaDynamicSignal* _tmp664_; - ValaDynamicSignal* _tmp665_; - ValaExpression* _tmp666_; - ValaExpression* _tmp667_; - ValaDataType* _tmp668_; - ValaDataType* _tmp669_; - ValaDataType* _tmp670_; - ValaDataType* _tmp671_; - ValaDataType* _tmp672_; - gboolean first = FALSE; - ValaDynamicSignal* _tmp690_; - ValaExpression* _tmp691_; - ValaExpression* _tmp692_; - ValaDynamicSignal* _tmp693_; - ValaDynamicSignal* _tmp694_; - ValaSymbol* _tmp695_; - ValaSymbol* _tmp696_; - ValaObjectType* _tmp697_; - ValaObjectType* _tmp698_; - ValaDelegate* _tmp699_; - ValaDelegate* _tmp700_; - ValaDelegateType* _tmp701_; - ValaDelegateType* _tmp702_; - _tmp664_ = dynamic_sig; - _tmp665_ = dynamic_sig; - _tmp666_ = vala_dynamic_signal_get_handler (_tmp665_); - _tmp667_ = _tmp666_; - _tmp668_ = vala_expression_get_value_type (_tmp667_); + _tmp662_ = m; + _tmp663_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp662_); + _tmp664_ = _tmp663_; + dynamic_sig = VALA_IS_DYNAMIC_SIGNAL (_tmp664_) ? ((ValaDynamicSignal*) _tmp664_) : NULL; + _tmp666_ = dynamic_sig; + if (_tmp666_ != NULL) { + ValaDynamicSignal* _tmp667_; + ValaExpression* _tmp668_; + ValaExpression* _tmp669_; + _tmp667_ = dynamic_sig; + _tmp668_ = vala_dynamic_signal_get_handler (_tmp667_); _tmp669_ = _tmp668_; - _tmp670_ = vala_data_type_get_return_type (_tmp669_); - _tmp671_ = vala_data_type_copy (_tmp670_); - _tmp672_ = _tmp671_; - vala_callable_set_return_type ((ValaCallable*) _tmp664_, _tmp672_); - _vala_code_node_unref0 (_tmp672_); + _tmp665_ = _tmp669_ != NULL; + } else { + _tmp665_ = FALSE; + } + if (_tmp665_) { + ValaDynamicSignal* _tmp670_; + ValaDynamicSignal* _tmp671_; + ValaExpression* _tmp672_; + ValaExpression* _tmp673_; + ValaDataType* _tmp674_; + ValaDataType* _tmp675_; + ValaDataType* _tmp676_; + ValaDataType* _tmp677_; + ValaDataType* _tmp678_; + gboolean first = FALSE; + ValaDynamicSignal* _tmp696_; + ValaExpression* _tmp697_; + ValaExpression* _tmp698_; + ValaDynamicSignal* _tmp699_; + ValaDynamicSignal* _tmp700_; + ValaSymbol* _tmp701_; + ValaSymbol* _tmp702_; + ValaObjectType* _tmp703_; + ValaObjectType* _tmp704_; + ValaDelegate* _tmp705_; + ValaDelegate* _tmp706_; + ValaDelegateType* _tmp707_; + ValaDelegateType* _tmp708_; + ValaDynamicSignal* _tmp709_; + ValaExpression* _tmp710_; + ValaExpression* _tmp711_; + ValaDataType* _tmp712_; + ValaDataType* _tmp713_; + ValaSourceReference* _tmp714_; + ValaSourceReference* _tmp715_; + _tmp670_ = dynamic_sig; + _tmp671_ = dynamic_sig; + _tmp672_ = vala_dynamic_signal_get_handler (_tmp671_); + _tmp673_ = _tmp672_; + _tmp674_ = vala_expression_get_value_type (_tmp673_); + _tmp675_ = _tmp674_; + _tmp676_ = vala_data_type_get_return_type (_tmp675_); + _tmp677_ = vala_data_type_copy (_tmp676_); + _tmp678_ = _tmp677_; + vala_callable_set_return_type ((ValaCallable*) _tmp670_, _tmp678_); + _vala_code_node_unref0 (_tmp678_); first = TRUE; { ValaList* _param_list = NULL; - ValaDynamicSignal* _tmp673_; - ValaExpression* _tmp674_; - ValaExpression* _tmp675_; - ValaDataType* _tmp676_; - ValaDataType* _tmp677_; - ValaList* _tmp678_; + ValaDynamicSignal* _tmp679_; + ValaExpression* _tmp680_; + ValaExpression* _tmp681_; + ValaDataType* _tmp682_; + ValaDataType* _tmp683_; + ValaList* _tmp684_; gint _param_size = 0; - ValaList* _tmp679_; - gint _tmp680_; - gint _tmp681_; + ValaList* _tmp685_; + gint _tmp686_; + gint _tmp687_; gint _param_index = 0; - _tmp673_ = dynamic_sig; - _tmp674_ = vala_dynamic_signal_get_handler (_tmp673_); - _tmp675_ = _tmp674_; - _tmp676_ = vala_expression_get_value_type (_tmp675_); - _tmp677_ = _tmp676_; - _tmp678_ = vala_data_type_get_parameters (_tmp677_); - _param_list = _tmp678_; - _tmp679_ = _param_list; - _tmp680_ = vala_collection_get_size ((ValaCollection*) _tmp679_); + _tmp679_ = dynamic_sig; + _tmp680_ = vala_dynamic_signal_get_handler (_tmp679_); _tmp681_ = _tmp680_; - _param_size = _tmp681_; + _tmp682_ = vala_expression_get_value_type (_tmp681_); + _tmp683_ = _tmp682_; + _tmp684_ = vala_data_type_get_parameters (_tmp683_); + _param_list = _tmp684_; + _tmp685_ = _param_list; + _tmp686_ = vala_collection_get_size ((ValaCollection*) _tmp685_); + _tmp687_ = _tmp686_; + _param_size = _tmp687_; _param_index = -1; while (TRUE) { - gint _tmp682_; - gint _tmp683_; + gint _tmp688_; + gint _tmp689_; ValaParameter* param = NULL; - ValaList* _tmp684_; - gpointer _tmp685_; + ValaList* _tmp690_; + gpointer _tmp691_; _param_index = _param_index + 1; - _tmp682_ = _param_index; - _tmp683_ = _param_size; - if (!(_tmp682_ < _tmp683_)) { + _tmp688_ = _param_index; + _tmp689_ = _param_size; + if (!(_tmp688_ < _tmp689_)) { break; } - _tmp684_ = _param_list; - _tmp685_ = vala_list_get (_tmp684_, _param_index); - param = (ValaParameter*) _tmp685_; + _tmp690_ = _param_list; + _tmp691_ = vala_list_get (_tmp690_, _param_index); + param = (ValaParameter*) _tmp691_; if (first) { first = FALSE; } else { - ValaDynamicSignal* _tmp686_; - ValaParameter* _tmp687_; - ValaParameter* _tmp688_; - ValaParameter* _tmp689_; - _tmp686_ = dynamic_sig; - _tmp687_ = param; - _tmp688_ = vala_parameter_copy (_tmp687_); - _tmp689_ = _tmp688_; - vala_callable_add_parameter ((ValaCallable*) _tmp686_, _tmp689_); - _vala_code_node_unref0 (_tmp689_); + ValaDynamicSignal* _tmp692_; + ValaParameter* _tmp693_; + ValaParameter* _tmp694_; + ValaParameter* _tmp695_; + _tmp692_ = dynamic_sig; + _tmp693_ = param; + _tmp694_ = vala_parameter_copy (_tmp693_); + _tmp695_ = _tmp694_; + vala_callable_add_parameter ((ValaCallable*) _tmp692_, _tmp695_); + _vala_code_node_unref0 (_tmp695_); } _vala_code_node_unref0 (param); } } - _tmp690_ = dynamic_sig; - _tmp691_ = vala_dynamic_signal_get_handler (_tmp690_); - _tmp692_ = _tmp691_; - _tmp693_ = dynamic_sig; - _tmp694_ = dynamic_sig; - _tmp695_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp694_); - _tmp696_ = _tmp695_; - _tmp697_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp696_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol)); + _tmp696_ = dynamic_sig; + _tmp697_ = vala_dynamic_signal_get_handler (_tmp696_); _tmp698_ = _tmp697_; - _tmp699_ = vala_signal_get_delegate ((ValaSignal*) _tmp693_, (ValaDataType*) _tmp698_, (ValaCodeNode*) self); - _tmp700_ = _tmp699_; - _tmp701_ = vala_delegate_type_new (_tmp700_); + _tmp699_ = dynamic_sig; + _tmp700_ = dynamic_sig; + _tmp701_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp700_); _tmp702_ = _tmp701_; - vala_expression_set_target_type (_tmp692_, (ValaDataType*) _tmp702_); - _vala_code_node_unref0 (_tmp702_); - _vala_code_node_unref0 (_tmp700_); - _vala_code_node_unref0 (_tmp698_); - } - _tmp704_ = m; - if (_tmp704_ != NULL) { - ValaMethod* _tmp705_; - _tmp705_ = m; - _tmp703_ = vala_method_has_type_parameters (_tmp705_); + _tmp703_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp702_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol)); + _tmp704_ = _tmp703_; + _tmp705_ = vala_signal_get_delegate ((ValaSignal*) _tmp699_, (ValaDataType*) _tmp704_, (ValaCodeNode*) self); + _tmp706_ = _tmp705_; + _tmp707_ = vala_delegate_type_new (_tmp706_); + _tmp708_ = _tmp707_; + vala_expression_set_target_type (_tmp698_, (ValaDataType*) _tmp708_); + _vala_code_node_unref0 (_tmp708_); + _vala_code_node_unref0 (_tmp706_); + _vala_code_node_unref0 (_tmp704_); + _tmp709_ = dynamic_sig; + _tmp710_ = vala_dynamic_signal_get_handler (_tmp709_); + _tmp711_ = _tmp710_; + _tmp712_ = vala_expression_get_target_type (_tmp711_); + _tmp713_ = _tmp712_; + _tmp714_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp715_ = _tmp714_; + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp713_, _tmp715_); + } + _tmp717_ = m; + if (_tmp717_ != NULL) { + ValaMethod* _tmp718_; + _tmp718_ = m; + _tmp716_ = vala_method_has_type_parameters (_tmp718_); } else { - _tmp703_ = FALSE; + _tmp716_ = FALSE; } - if (_tmp703_) { + if (_tmp716_) { ValaMemberAccess* ma = NULL; - ValaExpression* _tmp706_; - ValaExpression* _tmp707_; - ValaMemberAccess* _tmp708_; - ValaList* _tmp709_; - gint _tmp710_; - gint _tmp711_; - _tmp706_ = vala_method_call_get_call (self); - _tmp707_ = _tmp706_; - ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp707_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess); - _tmp708_ = ma; - _tmp709_ = vala_member_access_get_type_arguments (_tmp708_); - _tmp710_ = vala_collection_get_size ((ValaCollection*) _tmp709_); - _tmp711_ = _tmp710_; - if (_tmp711_ == 0) { - ValaList* _tmp778_; - ValaIterator* _tmp779_; - ValaDataType* _tmp806_; - ValaDataType* _tmp807_; - ValaDataType* _tmp808_; - ValaList* _tmp809_; - ValaDataType* _tmp810_; - ValaDataType* _tmp811_; + ValaExpression* _tmp719_; + ValaExpression* _tmp720_; + ValaMemberAccess* _tmp721_; + ValaList* _tmp722_; + gint _tmp723_; + gint _tmp724_; + _tmp719_ = vala_method_call_get_call (self); + _tmp720_ = _tmp719_; + ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp720_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess); + _tmp721_ = ma; + _tmp722_ = vala_member_access_get_type_arguments (_tmp721_); + _tmp723_ = vala_collection_get_size ((ValaCollection*) _tmp722_); + _tmp724_ = _tmp723_; + if (_tmp724_ == 0) { + ValaList* _tmp791_; + ValaIterator* _tmp792_; + ValaDataType* _tmp819_; + ValaDataType* _tmp820_; + ValaDataType* _tmp821_; + ValaList* _tmp822_; + ValaDataType* _tmp823_; + ValaDataType* _tmp824_; { ValaList* _type_param_list = NULL; - ValaMethod* _tmp712_; - ValaList* _tmp713_; + ValaMethod* _tmp725_; + ValaList* _tmp726_; gint _type_param_size = 0; - ValaList* _tmp714_; - gint _tmp715_; - gint _tmp716_; + ValaList* _tmp727_; + gint _tmp728_; + gint _tmp729_; gint _type_param_index = 0; - _tmp712_ = m; - _tmp713_ = vala_method_get_type_parameters (_tmp712_); - _type_param_list = _tmp713_; - _tmp714_ = _type_param_list; - _tmp715_ = vala_collection_get_size ((ValaCollection*) _tmp714_); - _tmp716_ = _tmp715_; - _type_param_size = _tmp716_; + _tmp725_ = m; + _tmp726_ = vala_method_get_type_parameters (_tmp725_); + _type_param_list = _tmp726_; + _tmp727_ = _type_param_list; + _tmp728_ = vala_collection_get_size ((ValaCollection*) _tmp727_); + _tmp729_ = _tmp728_; + _type_param_size = _tmp729_; _type_param_index = -1; while (TRUE) { - gint _tmp717_; - gint _tmp718_; + gint _tmp730_; + gint _tmp731_; ValaTypeParameter* type_param = NULL; - ValaList* _tmp719_; - gpointer _tmp720_; + ValaList* _tmp732_; + gpointer _tmp733_; ValaDataType* type_arg = NULL; - ValaList* _tmp721_; - ValaIterator* _tmp722_; - gboolean _tmp758_ = FALSE; - ValaDataType* _tmp759_; - ValaDataType* _tmp769_; - ValaMemberAccess* _tmp776_; - ValaDataType* _tmp777_; + ValaList* _tmp734_; + ValaIterator* _tmp735_; + gboolean _tmp771_ = FALSE; + ValaDataType* _tmp772_; + ValaDataType* _tmp782_; + ValaMemberAccess* _tmp789_; + ValaDataType* _tmp790_; _type_param_index = _type_param_index + 1; - _tmp717_ = _type_param_index; - _tmp718_ = _type_param_size; - if (!(_tmp717_ < _tmp718_)) { + _tmp730_ = _type_param_index; + _tmp731_ = _type_param_size; + if (!(_tmp730_ < _tmp731_)) { break; } - _tmp719_ = _type_param_list; - _tmp720_ = vala_list_get (_tmp719_, _type_param_index); - type_param = (ValaTypeParameter*) _tmp720_; + _tmp732_ = _type_param_list; + _tmp733_ = vala_list_get (_tmp732_, _type_param_index); + type_param = (ValaTypeParameter*) _tmp733_; type_arg = NULL; - _tmp721_ = self->priv->argument_list; - _tmp722_ = vala_iterable_iterator ((ValaIterable*) _tmp721_); + _tmp734_ = self->priv->argument_list; + _tmp735_ = vala_iterable_iterator ((ValaIterable*) _tmp734_); _vala_iterator_unref0 (arg_it); - arg_it = _tmp722_; + arg_it = _tmp735_; { ValaList* _param_list = NULL; - ValaList* _tmp723_; + ValaList* _tmp736_; gint _param_size = 0; - ValaList* _tmp724_; - gint _tmp725_; - gint _tmp726_; + ValaList* _tmp737_; + gint _tmp738_; + gint _tmp739_; gint _param_index = 0; - _tmp723_ = params; - _param_list = _tmp723_; - _tmp724_ = _param_list; - _tmp725_ = vala_collection_get_size ((ValaCollection*) _tmp724_); - _tmp726_ = _tmp725_; - _param_size = _tmp726_; + _tmp736_ = params; + _param_list = _tmp736_; + _tmp737_ = _param_list; + _tmp738_ = vala_collection_get_size ((ValaCollection*) _tmp737_); + _tmp739_ = _tmp738_; + _param_size = _tmp739_; _param_index = -1; while (TRUE) { - gint _tmp727_; - gint _tmp728_; + gint _tmp740_; + gint _tmp741_; ValaParameter* param = NULL; - ValaList* _tmp729_; - gpointer _tmp730_; - gboolean _tmp731_ = FALSE; - ValaParameter* _tmp732_; - gboolean _tmp733_; - gboolean _tmp734_; - ValaIterator* _tmp738_; + ValaList* _tmp742_; + gpointer _tmp743_; + gboolean _tmp744_ = FALSE; + ValaParameter* _tmp745_; + gboolean _tmp746_; + gboolean _tmp747_; + ValaIterator* _tmp751_; _param_index = _param_index + 1; - _tmp727_ = _param_index; - _tmp728_ = _param_size; - if (!(_tmp727_ < _tmp728_)) { + _tmp740_ = _param_index; + _tmp741_ = _param_size; + if (!(_tmp740_ < _tmp741_)) { break; } - _tmp729_ = _param_list; - _tmp730_ = vala_list_get (_tmp729_, _param_index); - param = (ValaParameter*) _tmp730_; - _tmp732_ = param; - _tmp733_ = vala_parameter_get_ellipsis (_tmp732_); - _tmp734_ = _tmp733_; - if (_tmp734_) { - _tmp731_ = TRUE; + _tmp742_ = _param_list; + _tmp743_ = vala_list_get (_tmp742_, _param_index); + param = (ValaParameter*) _tmp743_; + _tmp745_ = param; + _tmp746_ = vala_parameter_get_ellipsis (_tmp745_); + _tmp747_ = _tmp746_; + if (_tmp747_) { + _tmp744_ = TRUE; } else { - ValaParameter* _tmp735_; - gboolean _tmp736_; - gboolean _tmp737_; - _tmp735_ = param; - _tmp736_ = vala_parameter_get_params_array (_tmp735_); - _tmp737_ = _tmp736_; - _tmp731_ = _tmp737_; + ValaParameter* _tmp748_; + gboolean _tmp749_; + gboolean _tmp750_; + _tmp748_ = param; + _tmp749_ = vala_parameter_get_params_array (_tmp748_); + _tmp750_ = _tmp749_; + _tmp744_ = _tmp750_; } - if (_tmp731_) { + if (_tmp744_) { _vala_code_node_unref0 (param); break; } - _tmp738_ = arg_it; - if (vala_iterator_next (_tmp738_)) { + _tmp751_ = arg_it; + if (vala_iterator_next (_tmp751_)) { ValaExpression* arg = NULL; - ValaIterator* _tmp739_; - gpointer _tmp740_; - ValaParameter* _tmp741_; - ValaDataType* _tmp742_; - ValaDataType* _tmp743_; - ValaTypeParameter* _tmp744_; - ValaExpression* _tmp745_; - ValaDataType* _tmp746_; - ValaDataType* _tmp747_; - ValaDataType* _tmp748_; - ValaDataType* _tmp749_; - ValaExpression* _tmp750_; - ValaExpression* _tmp751_; - ValaDataType* _tmp752_; - ValaDataType* _tmp753_; - ValaDataType* _tmp754_; - ValaList* _tmp755_; + ValaIterator* _tmp752_; + gpointer _tmp753_; + ValaParameter* _tmp754_; + ValaDataType* _tmp755_; ValaDataType* _tmp756_; - ValaDataType* _tmp757_; - _tmp739_ = arg_it; - _tmp740_ = vala_iterator_get (_tmp739_); - arg = (ValaExpression*) _tmp740_; - _tmp741_ = param; - _tmp742_ = vala_variable_get_variable_type ((ValaVariable*) _tmp741_); - _tmp743_ = _tmp742_; - _tmp744_ = type_param; - _tmp745_ = arg; - _tmp746_ = vala_expression_get_value_type (_tmp745_); - _tmp747_ = _tmp746_; - _tmp748_ = vala_data_type_infer_type_argument (_tmp743_, _tmp744_, _tmp747_); + ValaTypeParameter* _tmp757_; + ValaExpression* _tmp758_; + ValaDataType* _tmp759_; + ValaDataType* _tmp760_; + ValaDataType* _tmp761_; + ValaDataType* _tmp762_; + ValaExpression* _tmp763_; + ValaExpression* _tmp764_; + ValaDataType* _tmp765_; + ValaDataType* _tmp766_; + ValaDataType* _tmp767_; + ValaList* _tmp768_; + ValaDataType* _tmp769_; + ValaDataType* _tmp770_; + _tmp752_ = arg_it; + _tmp753_ = vala_iterator_get (_tmp752_); + arg = (ValaExpression*) _tmp753_; + _tmp754_ = param; + _tmp755_ = vala_variable_get_variable_type ((ValaVariable*) _tmp754_); + _tmp756_ = _tmp755_; + _tmp757_ = type_param; + _tmp758_ = arg; + _tmp759_ = vala_expression_get_value_type (_tmp758_); + _tmp760_ = _tmp759_; + _tmp761_ = vala_data_type_infer_type_argument (_tmp756_, _tmp757_, _tmp760_); _vala_code_node_unref0 (type_arg); - type_arg = _tmp748_; - _tmp749_ = type_arg; - if (_tmp749_ != NULL) { + type_arg = _tmp761_; + _tmp762_ = type_arg; + if (_tmp762_ != NULL) { _vala_code_node_unref0 (arg); _vala_code_node_unref0 (param); break; } - _tmp750_ = arg; - _tmp751_ = arg; - _tmp752_ = vala_expression_get_formal_target_type (_tmp751_); - _tmp753_ = _tmp752_; - _tmp754_ = target_object_type; - _tmp755_ = method_type_args; - _tmp756_ = vala_data_type_get_actual_type (_tmp753_, _tmp754_, _tmp755_, (ValaCodeNode*) self); - _tmp757_ = _tmp756_; - vala_expression_set_target_type (_tmp750_, _tmp757_); - _vala_code_node_unref0 (_tmp757_); + _tmp763_ = arg; + _tmp764_ = arg; + _tmp765_ = vala_expression_get_formal_target_type (_tmp764_); + _tmp766_ = _tmp765_; + _tmp767_ = target_object_type; + _tmp768_ = method_type_args; + _tmp769_ = vala_data_type_get_actual_type (_tmp766_, _tmp767_, _tmp768_, (ValaCodeNode*) self); + _tmp770_ = _tmp769_; + vala_expression_set_target_type (_tmp763_, _tmp770_); + _vala_code_node_unref0 (_tmp770_); _vala_code_node_unref0 (arg); } _vala_code_node_unref0 (param); } } - _tmp759_ = type_arg; - if (_tmp759_ == NULL) { - ValaDataType* _tmp760_; - ValaDataType* _tmp761_; - _tmp760_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp761_ = _tmp760_; - _tmp758_ = _tmp761_ != NULL; + _tmp772_ = type_arg; + if (_tmp772_ == NULL) { + ValaDataType* _tmp773_; + ValaDataType* _tmp774_; + _tmp773_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp774_ = _tmp773_; + _tmp771_ = _tmp774_ != NULL; } else { - _tmp758_ = FALSE; + _tmp771_ = FALSE; } - if (_tmp758_) { - ValaMethod* _tmp762_; - ValaDataType* _tmp763_; - ValaDataType* _tmp764_; - ValaTypeParameter* _tmp765_; - ValaDataType* _tmp766_; - ValaDataType* _tmp767_; - ValaDataType* _tmp768_; - _tmp762_ = m; - _tmp763_ = vala_callable_get_return_type ((ValaCallable*) _tmp762_); - _tmp764_ = _tmp763_; - _tmp765_ = type_param; - _tmp766_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp767_ = _tmp766_; - _tmp768_ = vala_data_type_infer_type_argument (_tmp764_, _tmp765_, _tmp767_); + if (_tmp771_) { + ValaMethod* _tmp775_; + ValaDataType* _tmp776_; + ValaDataType* _tmp777_; + ValaTypeParameter* _tmp778_; + ValaDataType* _tmp779_; + ValaDataType* _tmp780_; + ValaDataType* _tmp781_; + _tmp775_ = m; + _tmp776_ = vala_callable_get_return_type ((ValaCallable*) _tmp775_); + _tmp777_ = _tmp776_; + _tmp778_ = type_param; + _tmp779_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp780_ = _tmp779_; + _tmp781_ = vala_data_type_infer_type_argument (_tmp777_, _tmp778_, _tmp780_); _vala_code_node_unref0 (type_arg); - type_arg = _tmp768_; + type_arg = _tmp781_; } - _tmp769_ = type_arg; - if (_tmp769_ == NULL) { - ValaMemberAccess* _tmp770_; - ValaSourceReference* _tmp771_; - ValaSourceReference* _tmp772_; - ValaTypeParameter* _tmp773_; - gchar* _tmp774_; - gchar* _tmp775_; + _tmp782_ = type_arg; + if (_tmp782_ == NULL) { + ValaMemberAccess* _tmp783_; + ValaSourceReference* _tmp784_; + ValaSourceReference* _tmp785_; + ValaTypeParameter* _tmp786_; + gchar* _tmp787_; + gchar* _tmp788_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp770_ = ma; - _tmp771_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp770_); - _tmp772_ = _tmp771_; - _tmp773_ = type_param; - _tmp774_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp773_); - _tmp775_ = _tmp774_; - vala_report_error (_tmp772_, "cannot infer generic type argument for type parameter `%s'", _tmp775_); - _g_free0 (_tmp775_); + _tmp783_ = ma; + _tmp784_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp783_); + _tmp785_ = _tmp784_; + _tmp786_ = type_param; + _tmp787_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp786_); + _tmp788_ = _tmp787_; + vala_report_error (_tmp785_, "cannot infer generic type argument for type parameter `%s'", _tmp788_); + _g_free0 (_tmp788_); result = FALSE; _vala_code_node_unref0 (type_arg); _vala_code_node_unref0 (type_param); @@ -3119,154 +3147,161 @@ _vala_code_node_unref0 (target_object_type); return result; } - _tmp776_ = ma; - _tmp777_ = type_arg; - vala_member_access_add_type_argument (_tmp776_, _tmp777_); + _tmp789_ = ma; + _tmp790_ = type_arg; + vala_member_access_add_type_argument (_tmp789_, _tmp790_); _vala_code_node_unref0 (type_arg); _vala_code_node_unref0 (type_param); } } - _tmp778_ = self->priv->argument_list; - _tmp779_ = vala_iterable_iterator ((ValaIterable*) _tmp778_); + _tmp791_ = self->priv->argument_list; + _tmp792_ = vala_iterable_iterator ((ValaIterable*) _tmp791_); _vala_iterator_unref0 (arg_it); - arg_it = _tmp779_; + arg_it = _tmp792_; { ValaList* _param_list = NULL; - ValaList* _tmp780_; + ValaList* _tmp793_; gint _param_size = 0; - ValaList* _tmp781_; - gint _tmp782_; - gint _tmp783_; + ValaList* _tmp794_; + gint _tmp795_; + gint _tmp796_; gint _param_index = 0; - _tmp780_ = params; - _param_list = _tmp780_; - _tmp781_ = _param_list; - _tmp782_ = vala_collection_get_size ((ValaCollection*) _tmp781_); - _tmp783_ = _tmp782_; - _param_size = _tmp783_; + _tmp793_ = params; + _param_list = _tmp793_; + _tmp794_ = _param_list; + _tmp795_ = vala_collection_get_size ((ValaCollection*) _tmp794_); + _tmp796_ = _tmp795_; + _param_size = _tmp796_; _param_index = -1; while (TRUE) { - gint _tmp784_; - gint _tmp785_; + gint _tmp797_; + gint _tmp798_; ValaParameter* param = NULL; - ValaList* _tmp786_; - gpointer _tmp787_; - gboolean _tmp788_ = FALSE; - ValaParameter* _tmp789_; - gboolean _tmp790_; - gboolean _tmp791_; - ValaIterator* _tmp795_; + ValaList* _tmp799_; + gpointer _tmp800_; + gboolean _tmp801_ = FALSE; + ValaParameter* _tmp802_; + gboolean _tmp803_; + gboolean _tmp804_; + ValaIterator* _tmp808_; _param_index = _param_index + 1; - _tmp784_ = _param_index; - _tmp785_ = _param_size; - if (!(_tmp784_ < _tmp785_)) { + _tmp797_ = _param_index; + _tmp798_ = _param_size; + if (!(_tmp797_ < _tmp798_)) { break; } - _tmp786_ = _param_list; - _tmp787_ = vala_list_get (_tmp786_, _param_index); - param = (ValaParameter*) _tmp787_; - _tmp789_ = param; - _tmp790_ = vala_parameter_get_ellipsis (_tmp789_); - _tmp791_ = _tmp790_; - if (_tmp791_) { - _tmp788_ = TRUE; + _tmp799_ = _param_list; + _tmp800_ = vala_list_get (_tmp799_, _param_index); + param = (ValaParameter*) _tmp800_; + _tmp802_ = param; + _tmp803_ = vala_parameter_get_ellipsis (_tmp802_); + _tmp804_ = _tmp803_; + if (_tmp804_) { + _tmp801_ = TRUE; } else { - ValaParameter* _tmp792_; - gboolean _tmp793_; - gboolean _tmp794_; - _tmp792_ = param; - _tmp793_ = vala_parameter_get_params_array (_tmp792_); - _tmp794_ = _tmp793_; - _tmp788_ = _tmp794_; + ValaParameter* _tmp805_; + gboolean _tmp806_; + gboolean _tmp807_; + _tmp805_ = param; + _tmp806_ = vala_parameter_get_params_array (_tmp805_); + _tmp807_ = _tmp806_; + _tmp801_ = _tmp807_; } - if (_tmp788_) { + if (_tmp801_) { _vala_code_node_unref0 (param); break; } - _tmp795_ = arg_it; - if (vala_iterator_next (_tmp795_)) { + _tmp808_ = arg_it; + if (vala_iterator_next (_tmp808_)) { ValaExpression* arg = NULL; - ValaIterator* _tmp796_; - gpointer _tmp797_; - ValaExpression* _tmp798_; - ValaExpression* _tmp799_; - ValaDataType* _tmp800_; - ValaDataType* _tmp801_; - ValaDataType* _tmp802_; - ValaList* _tmp803_; - ValaDataType* _tmp804_; - ValaDataType* _tmp805_; - _tmp796_ = arg_it; - _tmp797_ = vala_iterator_get (_tmp796_); - arg = (ValaExpression*) _tmp797_; - _tmp798_ = arg; - _tmp799_ = arg; - _tmp800_ = vala_expression_get_formal_target_type (_tmp799_); - _tmp801_ = _tmp800_; - _tmp802_ = target_object_type; - _tmp803_ = method_type_args; - _tmp804_ = vala_data_type_get_actual_type (_tmp801_, _tmp802_, _tmp803_, (ValaCodeNode*) self); - _tmp805_ = _tmp804_; - vala_expression_set_target_type (_tmp798_, _tmp805_); - _vala_code_node_unref0 (_tmp805_); + ValaIterator* _tmp809_; + gpointer _tmp810_; + ValaExpression* _tmp811_; + ValaExpression* _tmp812_; + ValaDataType* _tmp813_; + ValaDataType* _tmp814_; + ValaDataType* _tmp815_; + ValaList* _tmp816_; + ValaDataType* _tmp817_; + ValaDataType* _tmp818_; + _tmp809_ = arg_it; + _tmp810_ = vala_iterator_get (_tmp809_); + arg = (ValaExpression*) _tmp810_; + _tmp811_ = arg; + _tmp812_ = arg; + _tmp813_ = vala_expression_get_formal_target_type (_tmp812_); + _tmp814_ = _tmp813_; + _tmp815_ = target_object_type; + _tmp816_ = method_type_args; + _tmp817_ = vala_data_type_get_actual_type (_tmp814_, _tmp815_, _tmp816_, (ValaCodeNode*) self); + _tmp818_ = _tmp817_; + vala_expression_set_target_type (_tmp811_, _tmp818_); + _vala_code_node_unref0 (_tmp818_); _vala_code_node_unref0 (arg); } _vala_code_node_unref0 (param); } } - _tmp806_ = vala_expression_get_formal_value_type ((ValaExpression*) self); - _tmp807_ = _tmp806_; - _tmp808_ = target_object_type; - _tmp809_ = method_type_args; - _tmp810_ = vala_data_type_get_actual_type (_tmp807_, _tmp808_, _tmp809_, (ValaCodeNode*) self); - _tmp811_ = _tmp810_; - vala_expression_set_value_type ((ValaExpression*) self, _tmp811_); - _vala_code_node_unref0 (_tmp811_); - } - } - _tmp813_ = m; - if (_tmp813_ != NULL) { - ValaMethod* _tmp814_; - gboolean _tmp815_; - gboolean _tmp816_; - _tmp814_ = m; - _tmp815_ = vala_method_get_coroutine (_tmp814_); - _tmp816_ = _tmp815_; - _tmp812_ = _tmp816_; + _tmp819_ = vala_expression_get_formal_value_type ((ValaExpression*) self); + _tmp820_ = _tmp819_; + _tmp821_ = target_object_type; + _tmp822_ = method_type_args; + _tmp823_ = vala_data_type_get_actual_type (_tmp820_, _tmp821_, _tmp822_, (ValaCodeNode*) self); + _tmp824_ = _tmp823_; + vala_expression_set_value_type ((ValaExpression*) self, _tmp824_); + _vala_code_node_unref0 (_tmp824_); + } + } + _tmp826_ = m; + if (_tmp826_ != NULL) { + ValaMethod* _tmp827_; + gboolean _tmp828_; + gboolean _tmp829_; + _tmp827_ = m; + _tmp828_ = vala_method_get_coroutine (_tmp827_); + _tmp829_ = _tmp828_; + _tmp825_ = _tmp829_; } else { - _tmp812_ = FALSE; + _tmp825_ = FALSE; } - if (_tmp812_) { + if (_tmp825_) { ValaMemberAccess* ma = NULL; - ValaExpression* _tmp817_; - ValaExpression* _tmp818_; - ValaMemberAccess* _tmp819_; - const gchar* _tmp820_; - const gchar* _tmp821_; - _tmp817_ = vala_method_call_get_call (self); - _tmp818_ = _tmp817_; - ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp818_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess); - _tmp819_ = ma; - _tmp820_ = vala_member_access_get_member_name (_tmp819_); - _tmp821_ = _tmp820_; - if (g_strcmp0 (_tmp821_, "end") == 0) { - ValaMethod* _tmp822_; - ValaMethod* _tmp823_; - ValaMethodType* _tmp824_; - _tmp822_ = m; - _tmp823_ = vala_method_get_end_method (_tmp822_); - _tmp824_ = vala_method_type_new (_tmp823_); + ValaExpression* _tmp830_; + ValaExpression* _tmp831_; + ValaMemberAccess* _tmp832_; + const gchar* _tmp833_; + const gchar* _tmp834_; + _tmp830_ = vala_method_call_get_call (self); + _tmp831_ = _tmp830_; + ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp831_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess); + _tmp832_ = ma; + _tmp833_ = vala_member_access_get_member_name (_tmp832_); + _tmp834_ = _tmp833_; + if (g_strcmp0 (_tmp834_, "end") == 0) { + ValaMethod* _tmp835_; + ValaMethod* _tmp836_; + ValaMethodType* _tmp837_; + ValaDataType* _tmp838_; + ValaSourceReference* _tmp839_; + ValaSourceReference* _tmp840_; + _tmp835_ = m; + _tmp836_ = vala_method_get_end_method (_tmp835_); + _tmp837_ = vala_method_type_new (_tmp836_); _vala_code_node_unref0 (mtype); - mtype = (ValaDataType*) _tmp824_; + mtype = (ValaDataType*) _tmp837_; + _tmp838_ = mtype; + _tmp839_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp840_ = _tmp839_; + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp838_, _tmp840_); } } } - _tmp825_ = vala_code_context_get_analyzer (context); - _tmp826_ = _tmp825_; - _tmp827_ = mtype; - _tmp828_ = params; - _tmp829_ = self->priv->argument_list; - if (!vala_semantic_analyzer_check_arguments (_tmp826_, (ValaExpression*) self, _tmp827_, _tmp828_, _tmp829_)) { + _tmp841_ = vala_code_context_get_analyzer (context); + _tmp842_ = _tmp841_; + _tmp843_ = mtype; + _tmp844_ = params; + _tmp845_ = self->priv->argument_list; + if (!vala_semantic_analyzer_check_arguments (_tmp842_, (ValaExpression*) self, _tmp843_, _tmp844_, _tmp845_)) { vala_code_node_set_error ((ValaCodeNode*) self, TRUE); result = FALSE; _vala_iterator_unref0 (arg_it); @@ -3280,322 +3315,322 @@ } { ValaList* _arg_list = NULL; - ValaList* _tmp830_; + ValaList* _tmp846_; gint _arg_size = 0; - ValaList* _tmp831_; - gint _tmp832_; - gint _tmp833_; + ValaList* _tmp847_; + gint _tmp848_; + gint _tmp849_; gint _arg_index = 0; - _tmp830_ = self->priv->argument_list; - _arg_list = _tmp830_; - _tmp831_ = _arg_list; - _tmp832_ = vala_collection_get_size ((ValaCollection*) _tmp831_); - _tmp833_ = _tmp832_; - _arg_size = _tmp833_; + _tmp846_ = self->priv->argument_list; + _arg_list = _tmp846_; + _tmp847_ = _arg_list; + _tmp848_ = vala_collection_get_size ((ValaCollection*) _tmp847_); + _tmp849_ = _tmp848_; + _arg_size = _tmp849_; _arg_index = -1; while (TRUE) { - gint _tmp834_; - gint _tmp835_; + gint _tmp850_; + gint _tmp851_; ValaExpression* arg = NULL; - ValaList* _tmp836_; - gpointer _tmp837_; + ValaList* _tmp852_; + gpointer _tmp853_; ValaSizeofExpression* sizeof_expr = NULL; - ValaExpression* _tmp838_; - gboolean _tmp839_ = FALSE; - ValaSizeofExpression* _tmp840_; + ValaExpression* _tmp854_; + gboolean _tmp855_ = FALSE; + ValaSizeofExpression* _tmp856_; _arg_index = _arg_index + 1; - _tmp834_ = _arg_index; - _tmp835_ = _arg_size; - if (!(_tmp834_ < _tmp835_)) { + _tmp850_ = _arg_index; + _tmp851_ = _arg_size; + if (!(_tmp850_ < _tmp851_)) { break; } - _tmp836_ = _arg_list; - _tmp837_ = vala_list_get (_tmp836_, _arg_index); - arg = (ValaExpression*) _tmp837_; - _tmp838_ = arg; - sizeof_expr = VALA_IS_SIZEOF_EXPRESSION (_tmp838_) ? ((ValaSizeofExpression*) _tmp838_) : NULL; - _tmp840_ = sizeof_expr; - if (_tmp840_ != NULL) { - ValaSizeofExpression* _tmp841_; - ValaDataType* _tmp842_; - ValaDataType* _tmp843_; - _tmp841_ = sizeof_expr; - _tmp842_ = vala_sizeof_expression_get_type_reference (_tmp841_); - _tmp843_ = _tmp842_; - _tmp839_ = VALA_IS_GENERIC_TYPE (_tmp843_); + _tmp852_ = _arg_list; + _tmp853_ = vala_list_get (_tmp852_, _arg_index); + arg = (ValaExpression*) _tmp853_; + _tmp854_ = arg; + sizeof_expr = VALA_IS_SIZEOF_EXPRESSION (_tmp854_) ? ((ValaSizeofExpression*) _tmp854_) : NULL; + _tmp856_ = sizeof_expr; + if (_tmp856_ != NULL) { + ValaSizeofExpression* _tmp857_; + ValaDataType* _tmp858_; + ValaDataType* _tmp859_; + _tmp857_ = sizeof_expr; + _tmp858_ = vala_sizeof_expression_get_type_reference (_tmp857_); + _tmp859_ = _tmp858_; + _tmp855_ = VALA_IS_GENERIC_TYPE (_tmp859_); } else { - _tmp839_ = FALSE; + _tmp855_ = FALSE; } - if (_tmp839_) { + if (_tmp855_) { ValaDataType* sizeof_type = NULL; - ValaSizeofExpression* _tmp844_; - ValaDataType* _tmp845_; - ValaDataType* _tmp846_; - ValaDataType* _tmp847_; - ValaList* _tmp848_; - ValaDataType* _tmp849_; - ValaExpression* _tmp850_; - ValaDataType* _tmp851_; - ValaSourceReference* _tmp852_; - ValaSourceReference* _tmp853_; - ValaSizeofExpression* _tmp854_; - ValaSizeofExpression* _tmp855_; - _tmp844_ = sizeof_expr; - _tmp845_ = vala_sizeof_expression_get_type_reference (_tmp844_); - _tmp846_ = _tmp845_; - _tmp847_ = target_object_type; - _tmp848_ = method_type_args; - _tmp849_ = vala_data_type_get_actual_type (_tmp846_, _tmp847_, _tmp848_, (ValaCodeNode*) self); - sizeof_type = _tmp849_; - _tmp850_ = arg; - _tmp851_ = sizeof_type; - _tmp852_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp853_ = _tmp852_; - _tmp854_ = vala_sizeof_expression_new (_tmp851_, _tmp853_); - _tmp855_ = _tmp854_; - vala_code_node_replace_expression ((ValaCodeNode*) self, _tmp850_, (ValaExpression*) _tmp855_); - _vala_code_node_unref0 (_tmp855_); + ValaSizeofExpression* _tmp860_; + ValaDataType* _tmp861_; + ValaDataType* _tmp862_; + ValaDataType* _tmp863_; + ValaList* _tmp864_; + ValaDataType* _tmp865_; + ValaExpression* _tmp866_; + ValaDataType* _tmp867_; + ValaSourceReference* _tmp868_; + ValaSourceReference* _tmp869_; + ValaSizeofExpression* _tmp870_; + ValaSizeofExpression* _tmp871_; + _tmp860_ = sizeof_expr; + _tmp861_ = vala_sizeof_expression_get_type_reference (_tmp860_); + _tmp862_ = _tmp861_; + _tmp863_ = target_object_type; + _tmp864_ = method_type_args; + _tmp865_ = vala_data_type_get_actual_type (_tmp862_, _tmp863_, _tmp864_, (ValaCodeNode*) self); + sizeof_type = _tmp865_; + _tmp866_ = arg; + _tmp867_ = sizeof_type; + _tmp868_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp869_ = _tmp868_; + _tmp870_ = vala_sizeof_expression_new (_tmp867_, _tmp869_); + _tmp871_ = _tmp870_; + vala_code_node_replace_expression ((ValaCodeNode*) self, _tmp866_, (ValaExpression*) _tmp871_); + _vala_code_node_unref0 (_tmp871_); _vala_code_node_unref0 (sizeof_type); } _vala_code_node_unref0 (arg); } } - _tmp858_ = base_cm; - if (_tmp858_ != NULL) { - ValaCreationMethod* _tmp859_; - _tmp859_ = base_cm; - _tmp857_ = vala_method_is_variadic ((ValaMethod*) _tmp859_); + _tmp874_ = base_cm; + if (_tmp874_ != NULL) { + ValaCreationMethod* _tmp875_; + _tmp875_ = base_cm; + _tmp873_ = vala_method_is_variadic ((ValaMethod*) _tmp875_); } else { - _tmp857_ = FALSE; + _tmp873_ = FALSE; } - if (_tmp857_) { - ValaList* _tmp860_; - gint _tmp861_; - gint _tmp862_; - ValaCreationMethod* _tmp863_; - ValaList* _tmp864_; - gint _tmp865_; - gint _tmp866_; - _tmp860_ = self->priv->argument_list; - _tmp861_ = vala_collection_get_size ((ValaCollection*) _tmp860_); - _tmp862_ = _tmp861_; - _tmp863_ = base_cm; - _tmp864_ = vala_callable_get_parameters ((ValaCallable*) _tmp863_); - _tmp865_ = vala_collection_get_size ((ValaCollection*) _tmp864_); - _tmp866_ = _tmp865_; - _tmp856_ = _tmp862_ == _tmp866_; + if (_tmp873_) { + ValaList* _tmp876_; + gint _tmp877_; + gint _tmp878_; + ValaCreationMethod* _tmp879_; + ValaList* _tmp880_; + gint _tmp881_; + gint _tmp882_; + _tmp876_ = self->priv->argument_list; + _tmp877_ = vala_collection_get_size ((ValaCollection*) _tmp876_); + _tmp878_ = _tmp877_; + _tmp879_ = base_cm; + _tmp880_ = vala_callable_get_parameters ((ValaCallable*) _tmp879_); + _tmp881_ = vala_collection_get_size ((ValaCollection*) _tmp880_); + _tmp882_ = _tmp881_; + _tmp872_ = _tmp878_ == _tmp882_; } else { - _tmp856_ = FALSE; + _tmp872_ = FALSE; } - if (_tmp856_) { + if (_tmp872_) { ValaExpression* this_last_arg = NULL; - ValaList* _tmp867_; - ValaList* _tmp868_; - gint _tmp869_; - gint _tmp870_; - gpointer _tmp871_; - gboolean _tmp872_ = FALSE; - ValaExpression* _tmp873_; - ValaDataType* _tmp874_; - ValaDataType* _tmp875_; - _tmp867_ = self->priv->argument_list; - _tmp868_ = self->priv->argument_list; - _tmp869_ = vala_collection_get_size ((ValaCollection*) _tmp868_); - _tmp870_ = _tmp869_; - _tmp871_ = vala_list_get (_tmp867_, _tmp870_ - 1); - this_last_arg = (ValaExpression*) _tmp871_; - _tmp873_ = this_last_arg; - _tmp874_ = vala_expression_get_value_type (_tmp873_); - _tmp875_ = _tmp874_; - if (VALA_IS_STRUCT_VALUE_TYPE (_tmp875_)) { - ValaExpression* _tmp876_; - ValaDataType* _tmp877_; - ValaDataType* _tmp878_; - ValaTypeSymbol* _tmp879_; - ValaTypeSymbol* _tmp880_; - ValaSemanticAnalyzer* _tmp881_; - ValaSemanticAnalyzer* _tmp882_; - ValaDataType* _tmp883_; - ValaTypeSymbol* _tmp884_; - ValaTypeSymbol* _tmp885_; - _tmp876_ = this_last_arg; - _tmp877_ = vala_expression_get_value_type (_tmp876_); - _tmp878_ = _tmp877_; - _tmp879_ = vala_data_type_get_type_symbol (_tmp878_); - _tmp880_ = _tmp879_; - _tmp881_ = vala_code_context_get_analyzer (context); - _tmp882_ = _tmp881_; - _tmp883_ = _tmp882_->va_list_type; - _tmp884_ = vala_data_type_get_type_symbol (_tmp883_); - _tmp885_ = _tmp884_; - _tmp872_ = _tmp880_ == _tmp885_; + ValaList* _tmp883_; + ValaList* _tmp884_; + gint _tmp885_; + gint _tmp886_; + gpointer _tmp887_; + gboolean _tmp888_ = FALSE; + ValaExpression* _tmp889_; + ValaDataType* _tmp890_; + ValaDataType* _tmp891_; + _tmp883_ = self->priv->argument_list; + _tmp884_ = self->priv->argument_list; + _tmp885_ = vala_collection_get_size ((ValaCollection*) _tmp884_); + _tmp886_ = _tmp885_; + _tmp887_ = vala_list_get (_tmp883_, _tmp886_ - 1); + this_last_arg = (ValaExpression*) _tmp887_; + _tmp889_ = this_last_arg; + _tmp890_ = vala_expression_get_value_type (_tmp889_); + _tmp891_ = _tmp890_; + if (VALA_IS_STRUCT_VALUE_TYPE (_tmp891_)) { + ValaExpression* _tmp892_; + ValaDataType* _tmp893_; + ValaDataType* _tmp894_; + ValaTypeSymbol* _tmp895_; + ValaTypeSymbol* _tmp896_; + ValaSemanticAnalyzer* _tmp897_; + ValaSemanticAnalyzer* _tmp898_; + ValaDataType* _tmp899_; + ValaTypeSymbol* _tmp900_; + ValaTypeSymbol* _tmp901_; + _tmp892_ = this_last_arg; + _tmp893_ = vala_expression_get_value_type (_tmp892_); + _tmp894_ = _tmp893_; + _tmp895_ = vala_data_type_get_type_symbol (_tmp894_); + _tmp896_ = _tmp895_; + _tmp897_ = vala_code_context_get_analyzer (context); + _tmp898_ = _tmp897_; + _tmp899_ = _tmp898_->va_list_type; + _tmp900_ = vala_data_type_get_type_symbol (_tmp899_); + _tmp901_ = _tmp900_; + _tmp888_ = _tmp896_ == _tmp901_; } else { - _tmp872_ = FALSE; + _tmp888_ = FALSE; } - if (_tmp872_) { + if (_tmp888_) { vala_method_call_set_is_constructv_chainup (self, TRUE); } _vala_code_node_unref0 (this_last_arg); } - _tmp886_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp887_ = _tmp886_; - vala_code_node_check ((ValaCodeNode*) _tmp887_, context); - _tmp888_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) self); - _tmp889_ = _tmp888_; - if (_tmp889_) { - gboolean _tmp890_ = FALSE; - ValaCodeNode* _tmp891_; - ValaCodeNode* _tmp892_; - _tmp891_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp892_ = _tmp891_; - if (VALA_IS_LOCAL_VARIABLE (_tmp892_)) { - _tmp890_ = TRUE; - } else { - ValaCodeNode* _tmp893_; - ValaCodeNode* _tmp894_; - _tmp893_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp894_ = _tmp893_; - _tmp890_ = VALA_IS_EXPRESSION_STATEMENT (_tmp894_); - } - if (_tmp890_) { - } else { - ValaSemanticAnalyzer* _tmp895_; - ValaSemanticAnalyzer* _tmp896_; - ValaSymbol* _tmp897_; - ValaSymbol* _tmp898_; - _tmp895_ = vala_code_context_get_analyzer (context); - _tmp896_ = _tmp895_; - _tmp897_ = vala_semantic_analyzer_get_current_symbol (_tmp896_); - _tmp898_ = _tmp897_; - if (!VALA_IS_BLOCK (_tmp898_)) { - ValaSourceReference* _tmp899_; - ValaSourceReference* _tmp900_; + _tmp902_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp903_ = _tmp902_; + vala_code_node_check ((ValaCodeNode*) _tmp903_, context); + _tmp904_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) self); + _tmp905_ = _tmp904_; + if (_tmp905_) { + gboolean _tmp906_ = FALSE; + ValaCodeNode* _tmp907_; + ValaCodeNode* _tmp908_; + _tmp907_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp908_ = _tmp907_; + if (VALA_IS_LOCAL_VARIABLE (_tmp908_)) { + _tmp906_ = TRUE; + } else { + ValaCodeNode* _tmp909_; + ValaCodeNode* _tmp910_; + _tmp909_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp910_ = _tmp909_; + _tmp906_ = VALA_IS_EXPRESSION_STATEMENT (_tmp910_); + } + if (_tmp906_) { + } else { + ValaSemanticAnalyzer* _tmp911_; + ValaSemanticAnalyzer* _tmp912_; + ValaSymbol* _tmp913_; + ValaSymbol* _tmp914_; + _tmp911_ = vala_code_context_get_analyzer (context); + _tmp912_ = _tmp911_; + _tmp913_ = vala_semantic_analyzer_get_current_symbol (_tmp912_); + _tmp914_ = _tmp913_; + if (!VALA_IS_BLOCK (_tmp914_)) { + ValaSourceReference* _tmp915_; + ValaSourceReference* _tmp916_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp899_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp900_ = _tmp899_; - vala_report_error (_tmp900_, "Field initializers must not throw errors"); + _tmp915_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp916_ = _tmp915_; + vala_report_error (_tmp916_, "Field initializers must not throw errors"); } else { ValaCodeNode* old_parent_node = NULL; - ValaCodeNode* _tmp901_; - ValaCodeNode* _tmp902_; - ValaCodeNode* _tmp903_; + ValaCodeNode* _tmp917_; + ValaCodeNode* _tmp918_; + ValaCodeNode* _tmp919_; ValaLocalVariable* local = NULL; - ValaDataType* _tmp904_; - ValaDataType* _tmp905_; - ValaDataType* _tmp906_; - ValaDataType* _tmp907_; - gchar* _tmp908_; - gchar* _tmp909_; - ValaSourceReference* _tmp910_; - ValaSourceReference* _tmp911_; - ValaLocalVariable* _tmp912_; - ValaLocalVariable* _tmp913_; + ValaDataType* _tmp920_; + ValaDataType* _tmp921_; + ValaDataType* _tmp922_; + ValaDataType* _tmp923_; + gchar* _tmp924_; + gchar* _tmp925_; + ValaSourceReference* _tmp926_; + ValaSourceReference* _tmp927_; + ValaLocalVariable* _tmp928_; + ValaLocalVariable* _tmp929_; ValaDeclarationStatement* decl = NULL; - ValaLocalVariable* _tmp914_; - ValaSourceReference* _tmp915_; - ValaSourceReference* _tmp916_; - ValaDeclarationStatement* _tmp917_; - ValaDataType* _tmp918_; - ValaDataType* _tmp919_; - ValaSemanticAnalyzer* _tmp923_; - ValaSemanticAnalyzer* _tmp924_; - ValaBlock* _tmp925_; - ValaDeclarationStatement* _tmp926_; + ValaLocalVariable* _tmp930_; + ValaSourceReference* _tmp931_; + ValaSourceReference* _tmp932_; + ValaDeclarationStatement* _tmp933_; + ValaDataType* _tmp934_; + ValaDataType* _tmp935_; + ValaSemanticAnalyzer* _tmp939_; + ValaSemanticAnalyzer* _tmp940_; + ValaBlock* _tmp941_; + ValaDeclarationStatement* _tmp942_; ValaExpression* temp_access = NULL; - ValaLocalVariable* _tmp927_; - ValaDataType* _tmp928_; - ValaDataType* _tmp929_; - ValaExpression* _tmp930_; - ValaExpression* _tmp931_; - ValaDataType* _tmp932_; - ValaDataType* _tmp933_; - ValaLocalVariable* _tmp934_; - ValaDeclarationStatement* _tmp935_; + ValaLocalVariable* _tmp943_; + ValaDataType* _tmp944_; + ValaDataType* _tmp945_; + ValaExpression* _tmp946_; + ValaExpression* _tmp947_; + ValaDataType* _tmp948_; + ValaDataType* _tmp949_; + ValaLocalVariable* _tmp950_; + ValaDeclarationStatement* _tmp951_; ValaBlock* block = NULL; - ValaSemanticAnalyzer* _tmp936_; - ValaSemanticAnalyzer* _tmp937_; - ValaSymbol* _tmp938_; - ValaSymbol* _tmp939_; - ValaBlock* _tmp940_; - ValaBlock* _tmp941_; - ValaLocalVariable* _tmp942_; - ValaSemanticAnalyzer* _tmp943_; - ValaSemanticAnalyzer* _tmp944_; - ValaBlock* _tmp945_; - ValaLocalVariable* _tmp946_; - ValaCodeNode* _tmp947_; - ValaExpression* _tmp948_; - ValaExpression* _tmp949_; - _tmp901_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp902_ = _tmp901_; - _tmp903_ = _vala_code_node_ref0 (_tmp902_); - old_parent_node = _tmp903_; - _tmp904_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp905_ = _tmp904_; - _tmp906_ = vala_data_type_copy (_tmp905_); - _tmp907_ = _tmp906_; - _tmp908_ = vala_code_node_get_temp_name (); - _tmp909_ = _tmp908_; - _tmp910_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp911_ = _tmp910_; - _tmp912_ = vala_local_variable_new (_tmp907_, _tmp909_, NULL, _tmp911_); - _tmp913_ = _tmp912_; - _g_free0 (_tmp909_); - _vala_code_node_unref0 (_tmp907_); - local = _tmp913_; - _tmp914_ = local; - _tmp915_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp916_ = _tmp915_; - _tmp917_ = vala_declaration_statement_new ((ValaSymbol*) _tmp914_, _tmp916_); - decl = _tmp917_; - _tmp918_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp919_ = _tmp918_; - if (_tmp919_ == NULL) { - ValaLocalVariable* _tmp920_; - ValaDataType* _tmp921_; - ValaDataType* _tmp922_; - _tmp920_ = local; - _tmp921_ = vala_variable_get_variable_type ((ValaVariable*) _tmp920_); - _tmp922_ = _tmp921_; - vala_data_type_set_floating_reference (_tmp922_, FALSE); - } - _tmp923_ = vala_code_context_get_analyzer (context); - _tmp924_ = _tmp923_; - _tmp925_ = _tmp924_->insert_block; - _tmp926_ = decl; - vala_expression_insert_statement ((ValaExpression*) self, _tmp925_, (ValaStatement*) _tmp926_); - _tmp927_ = local; - _tmp928_ = vala_expression_get_target_type ((ValaExpression*) self); + ValaSemanticAnalyzer* _tmp952_; + ValaSemanticAnalyzer* _tmp953_; + ValaSymbol* _tmp954_; + ValaSymbol* _tmp955_; + ValaBlock* _tmp956_; + ValaBlock* _tmp957_; + ValaLocalVariable* _tmp958_; + ValaSemanticAnalyzer* _tmp959_; + ValaSemanticAnalyzer* _tmp960_; + ValaBlock* _tmp961_; + ValaLocalVariable* _tmp962_; + ValaCodeNode* _tmp963_; + ValaExpression* _tmp964_; + ValaExpression* _tmp965_; + _tmp917_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp918_ = _tmp917_; + _tmp919_ = _vala_code_node_ref0 (_tmp918_); + old_parent_node = _tmp919_; + _tmp920_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp921_ = _tmp920_; + _tmp922_ = vala_data_type_copy (_tmp921_); + _tmp923_ = _tmp922_; + _tmp924_ = vala_code_node_get_temp_name (); + _tmp925_ = _tmp924_; + _tmp926_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp927_ = _tmp926_; + _tmp928_ = vala_local_variable_new (_tmp923_, _tmp925_, NULL, _tmp927_); _tmp929_ = _tmp928_; - _tmp930_ = vala_semantic_analyzer_create_temp_access (_tmp927_, _tmp929_); - temp_access = _tmp930_; - _tmp931_ = temp_access; - _tmp932_ = vala_expression_get_formal_target_type ((ValaExpression*) self); - _tmp933_ = _tmp932_; - vala_expression_set_formal_target_type (_tmp931_, _tmp933_); - _tmp934_ = local; - vala_variable_set_initializer ((ValaVariable*) _tmp934_, (ValaExpression*) self); - _tmp935_ = decl; - vala_code_node_check ((ValaCodeNode*) _tmp935_, context); - _tmp936_ = vala_code_context_get_analyzer (context); - _tmp937_ = _tmp936_; - _tmp938_ = vala_semantic_analyzer_get_current_symbol (_tmp937_); - _tmp939_ = _tmp938_; - _tmp940_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp939_, VALA_TYPE_BLOCK, ValaBlock)); - block = _tmp940_; - _tmp941_ = block; - _tmp942_ = local; - vala_block_remove_local_variable (_tmp941_, _tmp942_); - _tmp943_ = vala_code_context_get_analyzer (context); - _tmp944_ = _tmp943_; - _tmp945_ = _tmp944_->insert_block; - _tmp946_ = local; - vala_block_add_local_variable (_tmp945_, _tmp946_); - _tmp947_ = old_parent_node; - _tmp948_ = temp_access; - vala_code_node_replace_expression (_tmp947_, (ValaExpression*) self, _tmp948_); - _tmp949_ = temp_access; - vala_code_node_check ((ValaCodeNode*) _tmp949_, context); + _g_free0 (_tmp925_); + _vala_code_node_unref0 (_tmp923_); + local = _tmp929_; + _tmp930_ = local; + _tmp931_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp932_ = _tmp931_; + _tmp933_ = vala_declaration_statement_new ((ValaSymbol*) _tmp930_, _tmp932_); + decl = _tmp933_; + _tmp934_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp935_ = _tmp934_; + if (_tmp935_ == NULL) { + ValaLocalVariable* _tmp936_; + ValaDataType* _tmp937_; + ValaDataType* _tmp938_; + _tmp936_ = local; + _tmp937_ = vala_variable_get_variable_type ((ValaVariable*) _tmp936_); + _tmp938_ = _tmp937_; + vala_data_type_set_floating_reference (_tmp938_, FALSE); + } + _tmp939_ = vala_code_context_get_analyzer (context); + _tmp940_ = _tmp939_; + _tmp941_ = _tmp940_->insert_block; + _tmp942_ = decl; + vala_expression_insert_statement ((ValaExpression*) self, _tmp941_, (ValaStatement*) _tmp942_); + _tmp943_ = local; + _tmp944_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp945_ = _tmp944_; + _tmp946_ = vala_semantic_analyzer_create_temp_access (_tmp943_, _tmp945_); + temp_access = _tmp946_; + _tmp947_ = temp_access; + _tmp948_ = vala_expression_get_formal_target_type ((ValaExpression*) self); + _tmp949_ = _tmp948_; + vala_expression_set_formal_target_type (_tmp947_, _tmp949_); + _tmp950_ = local; + vala_variable_set_initializer ((ValaVariable*) _tmp950_, (ValaExpression*) self); + _tmp951_ = decl; + vala_code_node_check ((ValaCodeNode*) _tmp951_, context); + _tmp952_ = vala_code_context_get_analyzer (context); + _tmp953_ = _tmp952_; + _tmp954_ = vala_semantic_analyzer_get_current_symbol (_tmp953_); + _tmp955_ = _tmp954_; + _tmp956_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp955_, VALA_TYPE_BLOCK, ValaBlock)); + block = _tmp956_; + _tmp957_ = block; + _tmp958_ = local; + vala_block_remove_local_variable (_tmp957_, _tmp958_); + _tmp959_ = vala_code_context_get_analyzer (context); + _tmp960_ = _tmp959_; + _tmp961_ = _tmp960_->insert_block; + _tmp962_ = local; + vala_block_add_local_variable (_tmp961_, _tmp962_); + _tmp963_ = old_parent_node; + _tmp964_ = temp_access; + vala_code_node_replace_expression (_tmp963_, (ValaExpression*) self, _tmp964_); + _tmp965_ = temp_access; + vala_code_node_check ((ValaCodeNode*) _tmp965_, context); _vala_code_node_unref0 (block); _vala_code_node_unref0 (temp_access); _vala_code_node_unref0 (decl); @@ -3604,9 +3639,9 @@ } } } - _tmp950_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp951_ = _tmp950_; - result = !_tmp951_; + _tmp966_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp967_ = _tmp966_; + result = !_tmp967_; _vala_iterator_unref0 (arg_it); _vala_code_node_unref0 (last_arg); _vala_iterable_unref0 (params); diff -Nru vala-0.52.6/vala/valamethodcall.vala vala-0.52.7/vala/valamethodcall.vala --- vala-0.52.6/vala/valamethodcall.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vala/valamethodcall.vala 2021-10-30 08:19:54.000000000 +0000 @@ -296,6 +296,7 @@ return false; } call.value_type = new ObjectType (context.analyzer.object_type); + call.value_type.source_reference = source_reference; mtype = call.value_type; } } @@ -562,6 +563,7 @@ } } dynamic_sig.handler.target_type = new DelegateType (dynamic_sig.get_delegate (new ObjectType ((ObjectTypeSymbol) dynamic_sig.parent_symbol), this)); + dynamic_sig.handler.target_type.source_reference = source_reference; } if (m != null && m.has_type_parameters ()) { @@ -627,6 +629,7 @@ unowned MemberAccess ma = (MemberAccess) call; if (ma.member_name == "end") { mtype = new MethodType (m.get_end_method ()); + mtype.source_reference = source_reference; } } } diff -Nru vala-0.52.6/vala/valamethod.vala vala-0.52.7/vala/valamethod.vala --- vala-0.52.6/vala/valamethod.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vala/valamethod.vala 2021-10-30 08:19:54.000000000 +0000 @@ -832,10 +832,6 @@ source_reference.file.context.module_init_method = this; } - if (return_type != null) { - return_type.check (context); - } - if (parameters.size == 1 && parameters[0].ellipsis && body != null && binding != MemberBinding.INSTANCE) { // accept just `...' for external methods and instance methods error = true; @@ -849,6 +845,7 @@ var optional_param = false; var params_array_param = false; + var ellipsis_param = false; foreach (Parameter param in parameters) { if (!param.check (context)) { error = true; @@ -873,11 +870,18 @@ optional_param = true; } + // Disallow parameter after params array or ellipsis if (params_array_param) { Report.error (param.source_reference, "parameter follows params-array parameter"); } else if (param.params_array) { params_array_param = true; } + if (ellipsis_param) { + Report.error (param.source_reference, "parameter follows ellipsis parameter"); + } else if (param.ellipsis) { + ellipsis_param = true; + } + // Add local variable to provide access to params arrays which will be constructed out of the given va-args if (param.params_array && body != null) { if (params_array_var != null) { @@ -920,6 +924,10 @@ if (error_types != null) { foreach (DataType error_type in error_types) { + if (!(error_type is ErrorType)) { + error = true; + Report.error (error_type.source_reference, "`%s' is not an error type", error_type.to_string ()); + } error_type.check (context); // check whether error type is at least as accessible as the method @@ -1240,11 +1248,12 @@ } var callback_type = new DelegateType ((Delegate) glib_ns.scope.lookup ("AsyncReadyCallback")); + callback_type.source_reference = source_reference; callback_type.nullable = true; callback_type.value_owned = true; callback_type.is_called_once = true; - var callback_param = new Parameter ("_callback_", callback_type); + var callback_param = new Parameter ("_callback_", callback_type, source_reference); callback_param.initializer = new NullLiteral (source_reference); callback_param.initializer.target_type = callback_type.copy (); callback_param.set_attribute_double ("CCode", "pos", -1); @@ -1271,7 +1280,7 @@ var glib_ns = CodeContext.get ().root.scope.lookup ("GLib"); var result_type = new ObjectType ((ObjectTypeSymbol) glib_ns.scope.lookup ("AsyncResult")); - var result_param = new Parameter ("_res_", result_type); + var result_param = new Parameter ("_res_", result_type, source_reference); result_param.set_attribute_double ("CCode", "pos", get_attribute_double ("CCode", "async_result_pos", 0.1)); scope.add (null, result_param); async_end_parameters.add (result_param); diff -Nru vala-0.52.6/vala/valaobjecttype.c vala-0.52.7/vala/valaobjecttype.c --- vala-0.52.6/vala/valaobjecttype.c 2021-10-04 09:46:53.000000000 +0000 +++ vala-0.52.7/vala/valaobjecttype.c 2021-10-30 08:24:06.000000000 +0000 @@ -363,10 +363,12 @@ _tmp0_ = vala_data_type_get_type_symbol ((ValaDataType*) self); _tmp1_ = _tmp0_; if (!vala_code_node_check ((ValaCodeNode*) _tmp1_, context)) { + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); result = FALSE; return result; } if (!vala_data_type_check_type_arguments ((ValaDataType*) self, context, TRUE)) { + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); result = FALSE; return result; } diff -Nru vala-0.52.6/vala/valaobjecttype.vala vala-0.52.7/vala/valaobjecttype.vala --- vala-0.52.6/vala/valaobjecttype.vala 2021-10-04 06:42:32.000000000 +0000 +++ vala-0.52.7/vala/valaobjecttype.vala 2021-10-30 07:37:56.000000000 +0000 @@ -100,11 +100,13 @@ public override bool check (CodeContext context) { if (!type_symbol.check (context)) { + error = true; return false; } // check whether there is the expected amount of type-arguments if (!check_type_arguments (context, true)) { + error = true; return false; } diff -Nru vala-0.52.6/vala/valaparser.c vala-0.52.7/vala/valaparser.c --- vala-0.52.6/vala/valaparser.c 2021-10-04 09:46:53.000000000 +0000 +++ vala-0.52.7/vala/valaparser.c 2021-10-30 08:24:06.000000000 +0000 @@ -5704,23 +5704,13 @@ ValaExpression* _tmp6_; ValaSourceReference* _tmp7_; ValaSourceReference* _tmp8_; - GError* _tmp9_; + ValaExpression* _tmp9_; _tmp6_ = expr; _tmp7_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp6_); _tmp8_ = _tmp7_; vala_report_error (_tmp8_, "syntax error, expected method call"); - _tmp9_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, "expected method call"); - _inner_error0_ = _tmp9_; - if (_inner_error0_->domain == VALA_PARSE_ERROR) { - g_propagate_error (error, _inner_error0_); - _vala_code_node_unref0 (expr); - return NULL; - } else { - _vala_code_node_unref0 (expr); - g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code); - g_clear_error (&_inner_error0_); - return NULL; - } + _tmp9_ = expr; + vala_code_node_set_error ((ValaCodeNode*) _tmp9_, TRUE); } _tmp10_ = call; if (_tmp10_ != NULL) { @@ -18746,8 +18736,8 @@ ValaSourceLocation inner_begin = {0}; ValaSourceLocation _tmp16_ = {0}; ValaSymbol* _result_ = NULL; - ValaErrorDomain* _tmp41_; - ValaSymbol* _tmp42_; + ValaErrorDomain* _tmp42_; + ValaSymbol* _tmp43_; GError* _inner_error0_ = NULL; g_return_if_fail (self != NULL); g_return_if_fail (parent != NULL); @@ -18880,9 +18870,10 @@ ValaErrorCode* _tmp31_; ValaErrorCode* _tmp32_; ValaErrorCode* _tmp33_; - ValaList* _tmp34_; - ValaErrorDomain* _tmp38_; - ValaErrorCode* _tmp39_; + ValaErrorCode* _tmp34_; + ValaList* _tmp35_; + ValaErrorDomain* _tmp39_; + ValaErrorCode* _tmp40_; if (!_tmp19_) { if (!vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA)) { break; @@ -18947,14 +18938,16 @@ _vala_source_reference_unref0 (_tmp29_); ec = _tmp32_; _tmp33_ = ec; - _tmp34_ = code_attrs; - vala_parser_set_attributes (self, (ValaCodeNode*) _tmp33_, _tmp34_); + vala_symbol_set_access ((ValaSymbol*) _tmp33_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp34_ = ec; + _tmp35_ = code_attrs; + vala_parser_set_attributes (self, (ValaCodeNode*) _tmp34_, _tmp35_); if (vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN)) { - ValaExpression* _tmp35_ = NULL; - ValaExpression* _tmp36_; - ValaErrorCode* _tmp37_; - _tmp36_ = vala_parser_parse_expression (self, &_inner_error0_); - _tmp35_ = _tmp36_; + ValaExpression* _tmp36_ = NULL; + ValaExpression* _tmp37_; + ValaErrorCode* _tmp38_; + _tmp37_ = vala_parser_parse_expression (self, &_inner_error0_); + _tmp36_ = _tmp37_; if (G_UNLIKELY (_inner_error0_ != NULL)) { if (_inner_error0_->domain == VALA_PARSE_ERROR) { g_propagate_error (error, _inner_error0_); @@ -18975,13 +18968,13 @@ return; } } - _tmp37_ = ec; - vala_error_code_set_value (_tmp37_, _tmp35_); - _vala_code_node_unref0 (_tmp35_); - } - _tmp38_ = ed; - _tmp39_ = ec; - vala_error_domain_add_code (_tmp38_, _tmp39_); + _tmp38_ = ec; + vala_error_code_set_value (_tmp38_, _tmp36_); + _vala_code_node_unref0 (_tmp36_); + } + _tmp39_ = ed; + _tmp40_ = ec; + vala_error_domain_add_code (_tmp39_, _tmp40_); _vala_comment_unref0 (self->priv->comment); self->priv->comment = NULL; _vala_code_node_unref0 (ec); @@ -18991,12 +18984,12 @@ } if (vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON)) { while (TRUE) { - ValaErrorDomain* _tmp40_; + ValaErrorDomain* _tmp41_; if (!(vala_parser_current (self) != VALA_TOKEN_TYPE_CLOSE_BRACE)) { break; } - _tmp40_ = ed; - vala_parser_parse_declaration (self, (ValaSymbol*) _tmp40_, FALSE, &_inner_error0_); + _tmp41_ = ed; + vala_parser_parse_declaration (self, (ValaSymbol*) _tmp41_, FALSE, &_inner_error0_); if (G_UNLIKELY (_inner_error0_ != NULL)) { if (_inner_error0_->domain == VALA_PARSE_ERROR) { g_propagate_error (error, _inner_error0_); @@ -19028,78 +19021,78 @@ return; } } - _tmp41_ = ed; - _tmp42_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp41_); - _result_ = _tmp42_; + _tmp42_ = ed; + _tmp43_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp42_); + _result_ = _tmp43_; while (TRUE) { - ValaUnresolvedSymbol* _tmp43_; ValaUnresolvedSymbol* _tmp44_; ValaUnresolvedSymbol* _tmp45_; ValaUnresolvedSymbol* _tmp46_; ValaUnresolvedSymbol* _tmp47_; - ValaSymbol* _tmp48_ = NULL; - ValaUnresolvedSymbol* _tmp49_; + ValaUnresolvedSymbol* _tmp48_; + ValaSymbol* _tmp49_ = NULL; + ValaUnresolvedSymbol* _tmp50_; ValaSymbol* next = NULL; - ValaSymbol* _tmp58_; ValaSymbol* _tmp59_; - ValaSymbol* _tmp64_; + ValaSymbol* _tmp60_; ValaSymbol* _tmp65_; - _tmp43_ = sym; - if (!(_tmp43_ != NULL)) { + ValaSymbol* _tmp66_; + _tmp44_ = sym; + if (!(_tmp44_ != NULL)) { break; } - _tmp44_ = sym; - _tmp45_ = vala_unresolved_symbol_get_inner (_tmp44_); - _tmp46_ = _tmp45_; - _tmp47_ = _vala_code_node_ref0 (_tmp46_); + _tmp45_ = sym; + _tmp46_ = vala_unresolved_symbol_get_inner (_tmp45_); + _tmp47_ = _tmp46_; + _tmp48_ = _vala_code_node_ref0 (_tmp47_); _vala_code_node_unref0 (sym); - sym = _tmp47_; - _tmp49_ = sym; - if (_tmp49_ != NULL) { - ValaUnresolvedSymbol* _tmp50_; - const gchar* _tmp51_; + sym = _tmp48_; + _tmp50_ = sym; + if (_tmp50_ != NULL) { + ValaUnresolvedSymbol* _tmp51_; const gchar* _tmp52_; - ValaErrorDomain* _tmp53_; - ValaSourceReference* _tmp54_; + const gchar* _tmp53_; + ValaErrorDomain* _tmp54_; ValaSourceReference* _tmp55_; - ValaNamespace* _tmp56_; - _tmp50_ = sym; - _tmp51_ = vala_symbol_get_name ((ValaSymbol*) _tmp50_); - _tmp52_ = _tmp51_; - _tmp53_ = ed; - _tmp54_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp53_); - _tmp55_ = _tmp54_; - _tmp56_ = vala_namespace_new (_tmp52_, _tmp55_); - _vala_code_node_unref0 (_tmp48_); - _tmp48_ = (ValaSymbol*) _tmp56_; - } else { - ValaSymbol* _tmp57_; - _tmp57_ = _vala_code_node_ref0 (parent); - _vala_code_node_unref0 (_tmp48_); - _tmp48_ = _tmp57_; - } - _tmp58_ = _vala_code_node_ref0 (_tmp48_); - next = _tmp58_; - _tmp59_ = _result_; - if (VALA_IS_NAMESPACE (_tmp59_)) { - ValaSymbol* _tmp60_; + ValaSourceReference* _tmp56_; + ValaNamespace* _tmp57_; + _tmp51_ = sym; + _tmp52_ = vala_symbol_get_name ((ValaSymbol*) _tmp51_); + _tmp53_ = _tmp52_; + _tmp54_ = ed; + _tmp55_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp54_); + _tmp56_ = _tmp55_; + _tmp57_ = vala_namespace_new (_tmp53_, _tmp56_); + _vala_code_node_unref0 (_tmp49_); + _tmp49_ = (ValaSymbol*) _tmp57_; + } else { + ValaSymbol* _tmp58_; + _tmp58_ = _vala_code_node_ref0 (parent); + _vala_code_node_unref0 (_tmp49_); + _tmp49_ = _tmp58_; + } + _tmp59_ = _vala_code_node_ref0 (_tmp49_); + next = _tmp59_; + _tmp60_ = _result_; + if (VALA_IS_NAMESPACE (_tmp60_)) { ValaSymbol* _tmp61_; - _tmp60_ = next; - _tmp61_ = _result_; - vala_symbol_add_namespace (_tmp60_, G_TYPE_CHECK_INSTANCE_CAST (_tmp61_, VALA_TYPE_NAMESPACE, ValaNamespace)); - } else { ValaSymbol* _tmp62_; + _tmp61_ = next; + _tmp62_ = _result_; + vala_symbol_add_namespace (_tmp61_, G_TYPE_CHECK_INSTANCE_CAST (_tmp62_, VALA_TYPE_NAMESPACE, ValaNamespace)); + } else { ValaSymbol* _tmp63_; - _tmp62_ = next; - _tmp63_ = _result_; - vala_symbol_add_error_domain (_tmp62_, G_TYPE_CHECK_INSTANCE_CAST (_tmp63_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain)); + ValaSymbol* _tmp64_; + _tmp63_ = next; + _tmp64_ = _result_; + vala_symbol_add_error_domain (_tmp63_, G_TYPE_CHECK_INSTANCE_CAST (_tmp64_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain)); } - _tmp64_ = next; - _tmp65_ = _vala_code_node_ref0 (_tmp64_); + _tmp65_ = next; + _tmp66_ = _vala_code_node_ref0 (_tmp65_); _vala_code_node_unref0 (_result_); - _result_ = _tmp65_; + _result_ = _tmp66_; _vala_code_node_unref0 (next); - _vala_code_node_unref0 (_tmp48_); + _vala_code_node_unref0 (_tmp49_); } _vala_code_node_unref0 (_result_); _vala_code_node_unref0 (ed); diff -Nru vala-0.52.6/vala/valaparser.vala vala-0.52.7/vala/valaparser.vala --- vala-0.52.6/vala/valaparser.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vala/valaparser.vala 2021-10-30 08:19:54.000000000 +0000 @@ -1091,7 +1091,7 @@ unowned ObjectCreationExpression? object_creation = expr as ObjectCreationExpression; if (call == null && object_creation == null) { Report.error (expr.source_reference, "syntax error, expected method call"); - throw new ParseError.SYNTAX ("expected method call"); + expr.error = true; } if (call != null) { @@ -3440,6 +3440,7 @@ } var ec = new ErrorCode (id, get_src (code_begin), comment); + ec.access = SymbolAccessibility.PUBLIC; set_attributes (ec, code_attrs); if (accept (TokenType.ASSIGN)) { ec.value = parse_expression (); diff -Nru vala-0.52.6/vala/valasignal.c vala-0.52.7/vala/valasignal.c --- vala-0.52.6/vala/valasignal.c 2021-10-04 09:46:53.000000000 +0000 +++ vala-0.52.7/vala/valasignal.c 2021-10-30 08:24:06.000000000 +0000 @@ -285,21 +285,23 @@ ValaDataType* _tmp2_; ValaDelegate* generated_delegate = NULL; ValaDataType* _tmp3_; - ValaDelegate* _tmp4_; - ValaDelegate* _tmp5_; + ValaSourceReference* _tmp4_; + ValaSourceReference* _tmp5_; ValaDelegate* _tmp6_; - ValaScope* _tmp7_; - ValaScope* _tmp8_; + ValaDelegate* _tmp7_; + ValaDelegate* _tmp8_; + ValaScope* _tmp9_; + ValaScope* _tmp10_; ValaDataType* sender_param_type = NULL; - ValaDataType* _tmp9_; - ValaDataType* _tmp10_; ValaDataType* _tmp11_; - ValaDelegate* _tmp12_; + ValaDataType* _tmp12_; ValaDataType* _tmp13_; + ValaDelegate* _tmp14_; + ValaDataType* _tmp15_; gboolean is_generic = FALSE; - ValaScope* _tmp85_; - ValaScope* _tmp86_; - ValaDelegate* _tmp87_; + ValaScope* _tmp87_; + ValaScope* _tmp88_; + ValaDelegate* _tmp89_; ValaDelegate* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (sender_type != NULL, NULL); @@ -309,86 +311,88 @@ _tmp2_ = vala_data_type_get_actual_type (_tmp1_, sender_type, NULL, node_reference); actual_return_type = _tmp2_; _tmp3_ = actual_return_type; - _tmp4_ = vala_delegate_new (NULL, _tmp3_, NULL, NULL); - generated_delegate = _tmp4_; - _tmp5_ = generated_delegate; - vala_symbol_set_access ((ValaSymbol*) _tmp5_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); - _tmp6_ = generated_delegate; - _tmp7_ = vala_symbol_get_scope ((ValaSymbol*) self); - _tmp8_ = _tmp7_; - vala_symbol_set_owner ((ValaSymbol*) _tmp6_, _tmp8_); - _tmp9_ = vala_data_type_copy (sender_type); - sender_param_type = _tmp9_; - _tmp10_ = sender_param_type; - vala_data_type_set_value_owned (_tmp10_, FALSE); - _tmp11_ = sender_param_type; - vala_data_type_set_nullable (_tmp11_, FALSE); - _tmp12_ = generated_delegate; + _tmp4_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp5_ = _tmp4_; + _tmp6_ = vala_delegate_new (NULL, _tmp3_, _tmp5_, NULL); + generated_delegate = _tmp6_; + _tmp7_ = generated_delegate; + vala_symbol_set_access ((ValaSymbol*) _tmp7_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp8_ = generated_delegate; + _tmp9_ = vala_symbol_get_scope ((ValaSymbol*) self); + _tmp10_ = _tmp9_; + vala_symbol_set_owner ((ValaSymbol*) _tmp8_, _tmp10_); + _tmp11_ = vala_data_type_copy (sender_type); + sender_param_type = _tmp11_; + _tmp12_ = sender_param_type; + vala_data_type_set_value_owned (_tmp12_, FALSE); _tmp13_ = sender_param_type; - vala_delegate_set_sender_type (_tmp12_, _tmp13_); + vala_data_type_set_nullable (_tmp13_, FALSE); + _tmp14_ = generated_delegate; + _tmp15_ = sender_param_type; + vala_delegate_set_sender_type (_tmp14_, _tmp15_); is_generic = FALSE; { ValaList* _param_list = NULL; - ValaList* _tmp14_; + ValaList* _tmp16_; gint _param_size = 0; - ValaList* _tmp15_; - gint _tmp16_; - gint _tmp17_; + ValaList* _tmp17_; + gint _tmp18_; + gint _tmp19_; gint _param_index = 0; - _tmp14_ = self->priv->parameters; - _param_list = _tmp14_; - _tmp15_ = _param_list; - _tmp16_ = vala_collection_get_size ((ValaCollection*) _tmp15_); - _tmp17_ = _tmp16_; - _param_size = _tmp17_; + _tmp16_ = self->priv->parameters; + _param_list = _tmp16_; + _tmp17_ = _param_list; + _tmp18_ = vala_collection_get_size ((ValaCollection*) _tmp17_); + _tmp19_ = _tmp18_; + _param_size = _tmp19_; _param_index = -1; while (TRUE) { - gint _tmp18_; - gint _tmp19_; + gint _tmp20_; + gint _tmp21_; ValaParameter* param = NULL; - ValaList* _tmp20_; - gpointer _tmp21_; + ValaList* _tmp22_; + gpointer _tmp23_; ValaParameter* actual_param = NULL; - ValaParameter* _tmp22_; - ValaParameter* _tmp23_; ValaParameter* _tmp24_; ValaParameter* _tmp25_; - ValaDataType* _tmp26_; - ValaDataType* _tmp27_; + ValaParameter* _tmp26_; + ValaParameter* _tmp27_; ValaDataType* _tmp28_; ValaDataType* _tmp29_; - ValaDelegate* _tmp30_; - ValaParameter* _tmp31_; - ValaParameter* _tmp32_; - ValaDataType* _tmp33_; - ValaDataType* _tmp34_; + ValaDataType* _tmp30_; + ValaDataType* _tmp31_; + ValaDelegate* _tmp32_; + ValaParameter* _tmp33_; + ValaParameter* _tmp34_; + ValaDataType* _tmp35_; + ValaDataType* _tmp36_; _param_index = _param_index + 1; - _tmp18_ = _param_index; - _tmp19_ = _param_size; - if (!(_tmp18_ < _tmp19_)) { + _tmp20_ = _param_index; + _tmp21_ = _param_size; + if (!(_tmp20_ < _tmp21_)) { break; } - _tmp20_ = _param_list; - _tmp21_ = vala_list_get (_tmp20_, _param_index); - param = (ValaParameter*) _tmp21_; - _tmp22_ = param; - _tmp23_ = vala_parameter_copy (_tmp22_); - actual_param = _tmp23_; - _tmp24_ = actual_param; - _tmp25_ = actual_param; - _tmp26_ = vala_variable_get_variable_type ((ValaVariable*) _tmp25_); - _tmp27_ = _tmp26_; - _tmp28_ = vala_data_type_get_actual_type (_tmp27_, sender_type, NULL, node_reference); + _tmp22_ = _param_list; + _tmp23_ = vala_list_get (_tmp22_, _param_index); + param = (ValaParameter*) _tmp23_; + _tmp24_ = param; + _tmp25_ = vala_parameter_copy (_tmp24_); + actual_param = _tmp25_; + _tmp26_ = actual_param; + _tmp27_ = actual_param; + _tmp28_ = vala_variable_get_variable_type ((ValaVariable*) _tmp27_); _tmp29_ = _tmp28_; - vala_variable_set_variable_type ((ValaVariable*) _tmp24_, _tmp29_); - _vala_code_node_unref0 (_tmp29_); - _tmp30_ = generated_delegate; - _tmp31_ = actual_param; - vala_callable_add_parameter ((ValaCallable*) _tmp30_, _tmp31_); - _tmp32_ = actual_param; - _tmp33_ = vala_variable_get_variable_type ((ValaVariable*) _tmp32_); - _tmp34_ = _tmp33_; - if (vala_data_type_is_generic (_tmp34_)) { + _tmp30_ = vala_data_type_get_actual_type (_tmp29_, sender_type, NULL, node_reference); + _tmp31_ = _tmp30_; + vala_variable_set_variable_type ((ValaVariable*) _tmp26_, _tmp31_); + _vala_code_node_unref0 (_tmp31_); + _tmp32_ = generated_delegate; + _tmp33_ = actual_param; + vala_callable_add_parameter ((ValaCallable*) _tmp32_, _tmp33_); + _tmp34_ = actual_param; + _tmp35_ = vala_variable_get_variable_type ((ValaVariable*) _tmp34_); + _tmp36_ = _tmp35_; + if (vala_data_type_is_generic (_tmp36_)) { is_generic = TRUE; } _vala_code_node_unref0 (actual_param); @@ -397,156 +401,156 @@ } if (is_generic) { ValaObjectTypeSymbol* cl = NULL; - ValaSymbol* _tmp35_; - ValaSymbol* _tmp36_; - _tmp35_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp36_ = _tmp35_; - cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp36_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol); + ValaSymbol* _tmp37_; + ValaSymbol* _tmp38_; + _tmp37_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp38_ = _tmp37_; + cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp38_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol); { ValaList* _type_param_list = NULL; - ValaObjectTypeSymbol* _tmp37_; - ValaList* _tmp38_; + ValaObjectTypeSymbol* _tmp39_; + ValaList* _tmp40_; gint _type_param_size = 0; - ValaList* _tmp39_; - gint _tmp40_; - gint _tmp41_; + ValaList* _tmp41_; + gint _tmp42_; + gint _tmp43_; gint _type_param_index = 0; - _tmp37_ = cl; - _tmp38_ = vala_object_type_symbol_get_type_parameters (_tmp37_); - _type_param_list = _tmp38_; - _tmp39_ = _type_param_list; - _tmp40_ = vala_collection_get_size ((ValaCollection*) _tmp39_); - _tmp41_ = _tmp40_; - _type_param_size = _tmp41_; + _tmp39_ = cl; + _tmp40_ = vala_object_type_symbol_get_type_parameters (_tmp39_); + _type_param_list = _tmp40_; + _tmp41_ = _type_param_list; + _tmp42_ = vala_collection_get_size ((ValaCollection*) _tmp41_); + _tmp43_ = _tmp42_; + _type_param_size = _tmp43_; _type_param_index = -1; while (TRUE) { - gint _tmp42_; - gint _tmp43_; + gint _tmp44_; + gint _tmp45_; ValaTypeParameter* type_param = NULL; - ValaList* _tmp44_; - gpointer _tmp45_; - ValaDelegate* _tmp46_; - ValaTypeParameter* _tmp47_; - const gchar* _tmp48_; - const gchar* _tmp49_; - ValaTypeParameter* _tmp50_; - ValaSourceReference* _tmp51_; - ValaSourceReference* _tmp52_; - ValaTypeParameter* _tmp53_; - ValaTypeParameter* _tmp54_; + ValaList* _tmp46_; + gpointer _tmp47_; + ValaDelegate* _tmp48_; + ValaTypeParameter* _tmp49_; + const gchar* _tmp50_; + const gchar* _tmp51_; + ValaTypeParameter* _tmp52_; + ValaSourceReference* _tmp53_; + ValaSourceReference* _tmp54_; + ValaTypeParameter* _tmp55_; + ValaTypeParameter* _tmp56_; _type_param_index = _type_param_index + 1; - _tmp42_ = _type_param_index; - _tmp43_ = _type_param_size; - if (!(_tmp42_ < _tmp43_)) { + _tmp44_ = _type_param_index; + _tmp45_ = _type_param_size; + if (!(_tmp44_ < _tmp45_)) { break; } - _tmp44_ = _type_param_list; - _tmp45_ = vala_list_get (_tmp44_, _type_param_index); - type_param = (ValaTypeParameter*) _tmp45_; - _tmp46_ = generated_delegate; - _tmp47_ = type_param; - _tmp48_ = vala_symbol_get_name ((ValaSymbol*) _tmp47_); - _tmp49_ = _tmp48_; - _tmp50_ = type_param; - _tmp51_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp50_); - _tmp52_ = _tmp51_; - _tmp53_ = vala_typeparameter_new (_tmp49_, _tmp52_); + _tmp46_ = _type_param_list; + _tmp47_ = vala_list_get (_tmp46_, _type_param_index); + type_param = (ValaTypeParameter*) _tmp47_; + _tmp48_ = generated_delegate; + _tmp49_ = type_param; + _tmp50_ = vala_symbol_get_name ((ValaSymbol*) _tmp49_); + _tmp51_ = _tmp50_; + _tmp52_ = type_param; + _tmp53_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp52_); _tmp54_ = _tmp53_; - vala_delegate_add_type_parameter (_tmp46_, _tmp54_); - _vala_code_node_unref0 (_tmp54_); + _tmp55_ = vala_typeparameter_new (_tmp51_, _tmp54_); + _tmp56_ = _tmp55_; + vala_delegate_add_type_parameter (_tmp48_, _tmp56_); + _vala_code_node_unref0 (_tmp56_); _vala_code_node_unref0 (type_param); } } { ValaList* _param_list = NULL; - ValaDelegate* _tmp55_; - ValaList* _tmp56_; + ValaDelegate* _tmp57_; + ValaList* _tmp58_; gint _param_size = 0; - ValaList* _tmp57_; - gint _tmp58_; - gint _tmp59_; + ValaList* _tmp59_; + gint _tmp60_; + gint _tmp61_; gint _param_index = 0; - _tmp55_ = generated_delegate; - _tmp56_ = vala_callable_get_parameters ((ValaCallable*) _tmp55_); - _param_list = _tmp56_; - _tmp57_ = _param_list; - _tmp58_ = vala_collection_get_size ((ValaCollection*) _tmp57_); - _tmp59_ = _tmp58_; - _param_size = _tmp59_; + _tmp57_ = generated_delegate; + _tmp58_ = vala_callable_get_parameters ((ValaCallable*) _tmp57_); + _param_list = _tmp58_; + _tmp59_ = _param_list; + _tmp60_ = vala_collection_get_size ((ValaCollection*) _tmp59_); + _tmp61_ = _tmp60_; + _param_size = _tmp61_; _param_index = -1; while (TRUE) { - gint _tmp60_; - gint _tmp61_; + gint _tmp62_; + gint _tmp63_; ValaParameter* param = NULL; - ValaList* _tmp62_; - gpointer _tmp63_; + ValaList* _tmp64_; + gpointer _tmp65_; _param_index = _param_index + 1; - _tmp60_ = _param_index; - _tmp61_ = _param_size; - if (!(_tmp60_ < _tmp61_)) { + _tmp62_ = _param_index; + _tmp63_ = _param_size; + if (!(_tmp62_ < _tmp63_)) { break; } - _tmp62_ = _param_list; - _tmp63_ = vala_list_get (_tmp62_, _param_index); - param = (ValaParameter*) _tmp63_; + _tmp64_ = _param_list; + _tmp65_ = vala_list_get (_tmp64_, _param_index); + param = (ValaParameter*) _tmp65_; { ValaList* _type_param_list = NULL; - ValaDelegate* _tmp64_; - ValaList* _tmp65_; + ValaDelegate* _tmp66_; + ValaList* _tmp67_; gint _type_param_size = 0; - ValaList* _tmp66_; - gint _tmp67_; - gint _tmp68_; + ValaList* _tmp68_; + gint _tmp69_; + gint _tmp70_; gint _type_param_index = 0; - _tmp64_ = generated_delegate; - _tmp65_ = vala_delegate_get_type_parameters (_tmp64_); - _type_param_list = _tmp65_; - _tmp66_ = _type_param_list; - _tmp67_ = vala_collection_get_size ((ValaCollection*) _tmp66_); - _tmp68_ = _tmp67_; - _type_param_size = _tmp68_; + _tmp66_ = generated_delegate; + _tmp67_ = vala_delegate_get_type_parameters (_tmp66_); + _type_param_list = _tmp67_; + _tmp68_ = _type_param_list; + _tmp69_ = vala_collection_get_size ((ValaCollection*) _tmp68_); + _tmp70_ = _tmp69_; + _type_param_size = _tmp70_; _type_param_index = -1; while (TRUE) { - gint _tmp69_; - gint _tmp70_; + gint _tmp71_; + gint _tmp72_; ValaTypeParameter* type_param = NULL; - ValaList* _tmp71_; - gpointer _tmp72_; - ValaParameter* _tmp73_; - ValaDataType* _tmp74_; - ValaDataType* _tmp75_; - ValaObjectTypeSymbol* _tmp76_; - ValaList* _tmp77_; + ValaList* _tmp73_; + gpointer _tmp74_; + ValaParameter* _tmp75_; + ValaDataType* _tmp76_; + ValaDataType* _tmp77_; ValaObjectTypeSymbol* _tmp78_; - ValaTypeParameter* _tmp79_; - const gchar* _tmp80_; - const gchar* _tmp81_; - gpointer _tmp82_; - ValaTypeParameter* _tmp83_; - ValaTypeParameter* _tmp84_; + ValaList* _tmp79_; + ValaObjectTypeSymbol* _tmp80_; + ValaTypeParameter* _tmp81_; + const gchar* _tmp82_; + const gchar* _tmp83_; + gpointer _tmp84_; + ValaTypeParameter* _tmp85_; + ValaTypeParameter* _tmp86_; _type_param_index = _type_param_index + 1; - _tmp69_ = _type_param_index; - _tmp70_ = _type_param_size; - if (!(_tmp69_ < _tmp70_)) { + _tmp71_ = _type_param_index; + _tmp72_ = _type_param_size; + if (!(_tmp71_ < _tmp72_)) { break; } - _tmp71_ = _type_param_list; - _tmp72_ = vala_list_get (_tmp71_, _type_param_index); - type_param = (ValaTypeParameter*) _tmp72_; - _tmp73_ = param; - _tmp74_ = vala_variable_get_variable_type ((ValaVariable*) _tmp73_); - _tmp75_ = _tmp74_; - _tmp76_ = cl; - _tmp77_ = vala_object_type_symbol_get_type_parameters (_tmp76_); + _tmp73_ = _type_param_list; + _tmp74_ = vala_list_get (_tmp73_, _type_param_index); + type_param = (ValaTypeParameter*) _tmp74_; + _tmp75_ = param; + _tmp76_ = vala_variable_get_variable_type ((ValaVariable*) _tmp75_); + _tmp77_ = _tmp76_; _tmp78_ = cl; - _tmp79_ = type_param; - _tmp80_ = vala_symbol_get_name ((ValaSymbol*) _tmp79_); - _tmp81_ = _tmp80_; - _tmp82_ = vala_list_get (_tmp77_, vala_typesymbol_get_type_parameter_index ((ValaTypeSymbol*) _tmp78_, _tmp81_)); - _tmp83_ = (ValaTypeParameter*) _tmp82_; - _tmp84_ = type_param; - vala_data_type_replace_type_parameter (_tmp75_, _tmp83_, _tmp84_); - _vala_code_node_unref0 (_tmp83_); + _tmp79_ = vala_object_type_symbol_get_type_parameters (_tmp78_); + _tmp80_ = cl; + _tmp81_ = type_param; + _tmp82_ = vala_symbol_get_name ((ValaSymbol*) _tmp81_); + _tmp83_ = _tmp82_; + _tmp84_ = vala_list_get (_tmp79_, vala_typesymbol_get_type_parameter_index ((ValaTypeSymbol*) _tmp80_, _tmp83_)); + _tmp85_ = (ValaTypeParameter*) _tmp84_; + _tmp86_ = type_param; + vala_data_type_replace_type_parameter (_tmp77_, _tmp85_, _tmp86_); + _vala_code_node_unref0 (_tmp85_); _vala_code_node_unref0 (type_param); } } @@ -554,10 +558,10 @@ } } } - _tmp85_ = vala_symbol_get_scope ((ValaSymbol*) self); - _tmp86_ = _tmp85_; - _tmp87_ = generated_delegate; - vala_scope_add (_tmp86_, NULL, (ValaSymbol*) _tmp87_); + _tmp87_ = vala_symbol_get_scope ((ValaSymbol*) self); + _tmp88_ = _tmp87_; + _tmp89_ = generated_delegate; + vala_scope_add (_tmp88_, NULL, (ValaSymbol*) _tmp89_); result = generated_delegate; _vala_code_node_unref0 (sender_param_type); _vala_code_node_unref0 (actual_return_type); diff -Nru vala-0.52.6/vala/valasignaltype.c vala-0.52.7/vala/valasignaltype.c --- vala-0.52.6/vala/valasignaltype.c 2021-10-04 09:46:53.000000000 +0000 +++ vala-0.52.7/vala/valasignaltype.c 2021-10-30 08:24:06.000000000 +0000 @@ -164,9 +164,12 @@ ValaDelegateType* _tmp12_; ValaDelegateType* _tmp13_; ValaDelegateType* _tmp14_; - ValaDelegateType* _tmp15_; - ValaDelegate* _tmp16_; - ValaDelegate* _tmp17_; + ValaSourceReference* _tmp15_; + ValaSourceReference* _tmp16_; + ValaDelegateType* _tmp17_; + ValaDelegateType* _tmp18_; + ValaDelegate* _tmp19_; + ValaDelegate* _tmp20_; ValaDelegateType* result = NULL; g_return_val_if_fail (self != NULL, NULL); _tmp0_ = vala_signal_type_get_signal_symbol (self); @@ -188,57 +191,68 @@ _vala_code_node_unref0 (_tmp11_); _result_ = _tmp13_; _tmp14_ = _result_; - vala_data_type_set_value_owned ((ValaDataType*) _tmp14_, TRUE); - _tmp15_ = _result_; - _tmp16_ = vala_delegate_type_get_delegate_symbol (_tmp15_); - _tmp17_ = _tmp16_; - if (vala_delegate_has_type_parameters (_tmp17_)) { + _tmp15_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp16_ = _tmp15_; + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp14_, _tmp16_); + _tmp17_ = _result_; + vala_data_type_set_value_owned ((ValaDataType*) _tmp17_, TRUE); + _tmp18_ = _result_; + _tmp19_ = vala_delegate_type_get_delegate_symbol (_tmp18_); + _tmp20_ = _tmp19_; + if (vala_delegate_has_type_parameters (_tmp20_)) { { ValaList* _type_param_list = NULL; - ValaObjectTypeSymbol* _tmp18_; - ValaList* _tmp19_; + ValaObjectTypeSymbol* _tmp21_; + ValaList* _tmp22_; gint _type_param_size = 0; - ValaList* _tmp20_; - gint _tmp21_; - gint _tmp22_; + ValaList* _tmp23_; + gint _tmp24_; + gint _tmp25_; gint _type_param_index = 0; - _tmp18_ = type_sym; - _tmp19_ = vala_object_type_symbol_get_type_parameters (_tmp18_); - _type_param_list = _tmp19_; - _tmp20_ = _type_param_list; - _tmp21_ = vala_collection_get_size ((ValaCollection*) _tmp20_); - _tmp22_ = _tmp21_; - _type_param_size = _tmp22_; + _tmp21_ = type_sym; + _tmp22_ = vala_object_type_symbol_get_type_parameters (_tmp21_); + _type_param_list = _tmp22_; + _tmp23_ = _type_param_list; + _tmp24_ = vala_collection_get_size ((ValaCollection*) _tmp23_); + _tmp25_ = _tmp24_; + _type_param_size = _tmp25_; _type_param_index = -1; while (TRUE) { - gint _tmp23_; - gint _tmp24_; + gint _tmp26_; + gint _tmp27_; ValaTypeParameter* type_param = NULL; - ValaList* _tmp25_; - gpointer _tmp26_; + ValaList* _tmp28_; + gpointer _tmp29_; ValaGenericType* type_arg = NULL; - ValaTypeParameter* _tmp27_; - ValaGenericType* _tmp28_; - ValaGenericType* _tmp29_; - ValaDelegateType* _tmp30_; + ValaTypeParameter* _tmp30_; ValaGenericType* _tmp31_; + ValaGenericType* _tmp32_; + ValaSourceReference* _tmp33_; + ValaSourceReference* _tmp34_; + ValaGenericType* _tmp35_; + ValaDelegateType* _tmp36_; + ValaGenericType* _tmp37_; _type_param_index = _type_param_index + 1; - _tmp23_ = _type_param_index; - _tmp24_ = _type_param_size; - if (!(_tmp23_ < _tmp24_)) { + _tmp26_ = _type_param_index; + _tmp27_ = _type_param_size; + if (!(_tmp26_ < _tmp27_)) { break; } - _tmp25_ = _type_param_list; - _tmp26_ = vala_list_get (_tmp25_, _type_param_index); - type_param = (ValaTypeParameter*) _tmp26_; - _tmp27_ = type_param; - _tmp28_ = vala_generic_type_new (_tmp27_); - type_arg = _tmp28_; - _tmp29_ = type_arg; - vala_data_type_set_value_owned ((ValaDataType*) _tmp29_, TRUE); - _tmp30_ = _result_; - _tmp31_ = type_arg; - vala_data_type_add_type_argument ((ValaDataType*) _tmp30_, (ValaDataType*) _tmp31_); + _tmp28_ = _type_param_list; + _tmp29_ = vala_list_get (_tmp28_, _type_param_index); + type_param = (ValaTypeParameter*) _tmp29_; + _tmp30_ = type_param; + _tmp31_ = vala_generic_type_new (_tmp30_); + type_arg = _tmp31_; + _tmp32_ = type_arg; + _tmp33_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp34_ = _tmp33_; + vala_code_node_set_source_reference ((ValaCodeNode*) _tmp32_, _tmp34_); + _tmp35_ = type_arg; + vala_data_type_set_value_owned ((ValaDataType*) _tmp35_, TRUE); + _tmp36_ = _result_; + _tmp37_ = type_arg; + vala_data_type_add_type_argument ((ValaDataType*) _tmp36_, (ValaDataType*) _tmp37_); _vala_code_node_unref0 (type_arg); _vala_code_node_unref0 (type_param); } @@ -254,7 +268,7 @@ vala_signal_type_get_connect_method (ValaSignalType* self) { ValaMethod* _tmp0_; - ValaMethod* _tmp22_; + ValaMethod* _tmp26_; ValaMethod* result = NULL; g_return_val_if_fail (self != NULL, NULL); _tmp0_ = self->priv->connect_method; @@ -268,19 +282,23 @@ ValaDataType* _tmp6_; ValaDataType* _tmp7_; ValaDataType* _tmp8_; - ValaMethod* _tmp9_; - ValaMethod* _tmp10_; + ValaSourceReference* _tmp9_; + ValaSourceReference* _tmp10_; ValaMethod* _tmp11_; ValaMethod* _tmp12_; - ValaSignal* _tmp13_; - ValaSignal* _tmp14_; - ValaScope* _tmp15_; - ValaScope* _tmp16_; - ValaMethod* _tmp17_; - ValaDelegateType* _tmp18_; - ValaDelegateType* _tmp19_; - ValaParameter* _tmp20_; - ValaParameter* _tmp21_; + ValaMethod* _tmp13_; + ValaMethod* _tmp14_; + ValaSignal* _tmp15_; + ValaSignal* _tmp16_; + ValaScope* _tmp17_; + ValaScope* _tmp18_; + ValaMethod* _tmp19_; + ValaDelegateType* _tmp20_; + ValaDelegateType* _tmp21_; + ValaSourceReference* _tmp22_; + ValaSourceReference* _tmp23_; + ValaParameter* _tmp24_; + ValaParameter* _tmp25_; _tmp1_ = vala_code_context_get (); _tmp2_ = _tmp1_; _tmp3_ = vala_code_context_get_analyzer (_tmp2_); @@ -291,31 +309,35 @@ _vala_code_context_unref0 (_tmp2_); ulong_type = _tmp7_; _tmp8_ = ulong_type; - _tmp9_ = vala_method_new ("connect", _tmp8_, NULL, NULL); + _tmp9_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp10_ = _tmp9_; + _tmp11_ = vala_method_new ("connect", _tmp8_, _tmp10_, NULL); _vala_code_node_unref0 (self->priv->connect_method); - self->priv->connect_method = _tmp9_; - _tmp10_ = self->priv->connect_method; - vala_symbol_set_access ((ValaSymbol*) _tmp10_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); - _tmp11_ = self->priv->connect_method; - vala_symbol_set_external ((ValaSymbol*) _tmp11_, TRUE); + self->priv->connect_method = _tmp11_; _tmp12_ = self->priv->connect_method; - _tmp13_ = vala_signal_type_get_signal_symbol (self); - _tmp14_ = _tmp13_; - _tmp15_ = vala_symbol_get_scope ((ValaSymbol*) _tmp14_); + vala_symbol_set_access ((ValaSymbol*) _tmp12_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp13_ = self->priv->connect_method; + vala_symbol_set_external ((ValaSymbol*) _tmp13_, TRUE); + _tmp14_ = self->priv->connect_method; + _tmp15_ = vala_signal_type_get_signal_symbol (self); _tmp16_ = _tmp15_; - vala_symbol_set_owner ((ValaSymbol*) _tmp12_, _tmp16_); - _tmp17_ = self->priv->connect_method; - _tmp18_ = vala_signal_type_get_handler_type (self); - _tmp19_ = _tmp18_; - _tmp20_ = vala_parameter_new ("handler", (ValaDataType*) _tmp19_, NULL); + _tmp17_ = vala_symbol_get_scope ((ValaSymbol*) _tmp16_); + _tmp18_ = _tmp17_; + vala_symbol_set_owner ((ValaSymbol*) _tmp14_, _tmp18_); + _tmp19_ = self->priv->connect_method; + _tmp20_ = vala_signal_type_get_handler_type (self); _tmp21_ = _tmp20_; - vala_callable_add_parameter ((ValaCallable*) _tmp17_, _tmp21_); + _tmp22_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp23_ = _tmp22_; + _tmp24_ = vala_parameter_new ("handler", (ValaDataType*) _tmp21_, _tmp23_); + _tmp25_ = _tmp24_; + vala_callable_add_parameter ((ValaCallable*) _tmp19_, _tmp25_); + _vala_code_node_unref0 (_tmp25_); _vala_code_node_unref0 (_tmp21_); - _vala_code_node_unref0 (_tmp19_); _vala_code_node_unref0 (ulong_type); } - _tmp22_ = self->priv->connect_method; - result = _tmp22_; + _tmp26_ = self->priv->connect_method; + result = _tmp26_; return result; } @@ -323,7 +345,7 @@ vala_signal_type_get_connect_after_method (ValaSignalType* self) { ValaMethod* _tmp0_; - ValaMethod* _tmp22_; + ValaMethod* _tmp26_; ValaMethod* result = NULL; g_return_val_if_fail (self != NULL, NULL); _tmp0_ = self->priv->connect_after_method; @@ -337,19 +359,23 @@ ValaDataType* _tmp6_; ValaDataType* _tmp7_; ValaDataType* _tmp8_; - ValaMethod* _tmp9_; - ValaMethod* _tmp10_; + ValaSourceReference* _tmp9_; + ValaSourceReference* _tmp10_; ValaMethod* _tmp11_; ValaMethod* _tmp12_; - ValaSignal* _tmp13_; - ValaSignal* _tmp14_; - ValaScope* _tmp15_; - ValaScope* _tmp16_; - ValaMethod* _tmp17_; - ValaDelegateType* _tmp18_; - ValaDelegateType* _tmp19_; - ValaParameter* _tmp20_; - ValaParameter* _tmp21_; + ValaMethod* _tmp13_; + ValaMethod* _tmp14_; + ValaSignal* _tmp15_; + ValaSignal* _tmp16_; + ValaScope* _tmp17_; + ValaScope* _tmp18_; + ValaMethod* _tmp19_; + ValaDelegateType* _tmp20_; + ValaDelegateType* _tmp21_; + ValaSourceReference* _tmp22_; + ValaSourceReference* _tmp23_; + ValaParameter* _tmp24_; + ValaParameter* _tmp25_; _tmp1_ = vala_code_context_get (); _tmp2_ = _tmp1_; _tmp3_ = vala_code_context_get_analyzer (_tmp2_); @@ -360,31 +386,35 @@ _vala_code_context_unref0 (_tmp2_); ulong_type = _tmp7_; _tmp8_ = ulong_type; - _tmp9_ = vala_method_new ("connect_after", _tmp8_, NULL, NULL); + _tmp9_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp10_ = _tmp9_; + _tmp11_ = vala_method_new ("connect_after", _tmp8_, _tmp10_, NULL); _vala_code_node_unref0 (self->priv->connect_after_method); - self->priv->connect_after_method = _tmp9_; - _tmp10_ = self->priv->connect_after_method; - vala_symbol_set_access ((ValaSymbol*) _tmp10_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); - _tmp11_ = self->priv->connect_after_method; - vala_symbol_set_external ((ValaSymbol*) _tmp11_, TRUE); + self->priv->connect_after_method = _tmp11_; _tmp12_ = self->priv->connect_after_method; - _tmp13_ = vala_signal_type_get_signal_symbol (self); - _tmp14_ = _tmp13_; - _tmp15_ = vala_symbol_get_scope ((ValaSymbol*) _tmp14_); + vala_symbol_set_access ((ValaSymbol*) _tmp12_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp13_ = self->priv->connect_after_method; + vala_symbol_set_external ((ValaSymbol*) _tmp13_, TRUE); + _tmp14_ = self->priv->connect_after_method; + _tmp15_ = vala_signal_type_get_signal_symbol (self); _tmp16_ = _tmp15_; - vala_symbol_set_owner ((ValaSymbol*) _tmp12_, _tmp16_); - _tmp17_ = self->priv->connect_after_method; - _tmp18_ = vala_signal_type_get_handler_type (self); - _tmp19_ = _tmp18_; - _tmp20_ = vala_parameter_new ("handler", (ValaDataType*) _tmp19_, NULL); + _tmp17_ = vala_symbol_get_scope ((ValaSymbol*) _tmp16_); + _tmp18_ = _tmp17_; + vala_symbol_set_owner ((ValaSymbol*) _tmp14_, _tmp18_); + _tmp19_ = self->priv->connect_after_method; + _tmp20_ = vala_signal_type_get_handler_type (self); _tmp21_ = _tmp20_; - vala_callable_add_parameter ((ValaCallable*) _tmp17_, _tmp21_); + _tmp22_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp23_ = _tmp22_; + _tmp24_ = vala_parameter_new ("handler", (ValaDataType*) _tmp21_, _tmp23_); + _tmp25_ = _tmp24_; + vala_callable_add_parameter ((ValaCallable*) _tmp19_, _tmp25_); + _vala_code_node_unref0 (_tmp25_); _vala_code_node_unref0 (_tmp21_); - _vala_code_node_unref0 (_tmp19_); _vala_code_node_unref0 (ulong_type); } - _tmp22_ = self->priv->connect_after_method; - result = _tmp22_; + _tmp26_ = self->priv->connect_after_method; + result = _tmp26_; return result; } @@ -392,53 +422,61 @@ vala_signal_type_get_disconnect_method (ValaSignalType* self) { ValaMethod* _tmp0_; - ValaMethod* _tmp16_; + ValaMethod* _tmp20_; ValaMethod* result = NULL; g_return_val_if_fail (self != NULL, NULL); _tmp0_ = self->priv->disconnect_method; if (_tmp0_ == NULL) { ValaVoidType* _tmp1_; ValaVoidType* _tmp2_; - ValaMethod* _tmp3_; - ValaMethod* _tmp4_; + ValaSourceReference* _tmp3_; + ValaSourceReference* _tmp4_; ValaMethod* _tmp5_; ValaMethod* _tmp6_; - ValaSignal* _tmp7_; - ValaSignal* _tmp8_; - ValaScope* _tmp9_; - ValaScope* _tmp10_; - ValaMethod* _tmp11_; - ValaDelegateType* _tmp12_; - ValaDelegateType* _tmp13_; - ValaParameter* _tmp14_; - ValaParameter* _tmp15_; + ValaMethod* _tmp7_; + ValaMethod* _tmp8_; + ValaSignal* _tmp9_; + ValaSignal* _tmp10_; + ValaScope* _tmp11_; + ValaScope* _tmp12_; + ValaMethod* _tmp13_; + ValaDelegateType* _tmp14_; + ValaDelegateType* _tmp15_; + ValaSourceReference* _tmp16_; + ValaSourceReference* _tmp17_; + ValaParameter* _tmp18_; + ValaParameter* _tmp19_; _tmp1_ = vala_void_type_new (NULL); _tmp2_ = _tmp1_; - _tmp3_ = vala_method_new ("disconnect", (ValaDataType*) _tmp2_, NULL, NULL); + _tmp3_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp4_ = _tmp3_; + _tmp5_ = vala_method_new ("disconnect", (ValaDataType*) _tmp2_, _tmp4_, NULL); _vala_code_node_unref0 (self->priv->disconnect_method); - self->priv->disconnect_method = _tmp3_; + self->priv->disconnect_method = _tmp5_; _vala_code_node_unref0 (_tmp2_); - _tmp4_ = self->priv->disconnect_method; - vala_symbol_set_access ((ValaSymbol*) _tmp4_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); - _tmp5_ = self->priv->disconnect_method; - vala_symbol_set_external ((ValaSymbol*) _tmp5_, TRUE); _tmp6_ = self->priv->disconnect_method; - _tmp7_ = vala_signal_type_get_signal_symbol (self); - _tmp8_ = _tmp7_; - _tmp9_ = vala_symbol_get_scope ((ValaSymbol*) _tmp8_); + vala_symbol_set_access ((ValaSymbol*) _tmp6_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC); + _tmp7_ = self->priv->disconnect_method; + vala_symbol_set_external ((ValaSymbol*) _tmp7_, TRUE); + _tmp8_ = self->priv->disconnect_method; + _tmp9_ = vala_signal_type_get_signal_symbol (self); _tmp10_ = _tmp9_; - vala_symbol_set_owner ((ValaSymbol*) _tmp6_, _tmp10_); - _tmp11_ = self->priv->disconnect_method; - _tmp12_ = vala_signal_type_get_handler_type (self); - _tmp13_ = _tmp12_; - _tmp14_ = vala_parameter_new ("handler", (ValaDataType*) _tmp13_, NULL); + _tmp11_ = vala_symbol_get_scope ((ValaSymbol*) _tmp10_); + _tmp12_ = _tmp11_; + vala_symbol_set_owner ((ValaSymbol*) _tmp8_, _tmp12_); + _tmp13_ = self->priv->disconnect_method; + _tmp14_ = vala_signal_type_get_handler_type (self); _tmp15_ = _tmp14_; - vala_callable_add_parameter ((ValaCallable*) _tmp11_, _tmp15_); + _tmp16_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp17_ = _tmp16_; + _tmp18_ = vala_parameter_new ("handler", (ValaDataType*) _tmp15_, _tmp17_); + _tmp19_ = _tmp18_; + vala_callable_add_parameter ((ValaCallable*) _tmp13_, _tmp19_); + _vala_code_node_unref0 (_tmp19_); _vala_code_node_unref0 (_tmp15_); - _vala_code_node_unref0 (_tmp13_); } - _tmp16_ = self->priv->disconnect_method; - result = _tmp16_; + _tmp20_ = self->priv->disconnect_method; + result = _tmp20_; return result; } diff -Nru vala-0.52.6/vala/valasignaltype.vala vala-0.52.7/vala/valasignaltype.vala --- vala-0.52.6/vala/valasignaltype.vala 2021-10-04 06:42:32.000000000 +0000 +++ vala-0.52.7/vala/valasignaltype.vala 2021-10-30 07:37:56.000000000 +0000 @@ -56,11 +56,13 @@ var type_sym = (ObjectTypeSymbol) signal_symbol.parent_symbol; var sender_type = SemanticAnalyzer.get_data_type_for_symbol (type_sym); var result = new DelegateType (signal_symbol.get_delegate (sender_type, this)); + result.source_reference = source_reference; result.value_owned = true; if (result.delegate_symbol.has_type_parameters ()) { foreach (var type_param in type_sym.get_type_parameters ()) { var type_arg = new GenericType (type_param); + type_arg.source_reference = source_reference; type_arg.value_owned = true; result.add_type_argument (type_arg); } @@ -72,11 +74,11 @@ unowned Method get_connect_method () { if (connect_method == null) { var ulong_type = CodeContext.get ().analyzer.ulong_type.copy (); - connect_method = new Method ("connect", ulong_type); + connect_method = new Method ("connect", ulong_type, source_reference); connect_method.access = SymbolAccessibility.PUBLIC; connect_method.external = true; connect_method.owner = signal_symbol.scope; - connect_method.add_parameter (new Parameter ("handler", get_handler_type ())); + connect_method.add_parameter (new Parameter ("handler", get_handler_type (), source_reference)); } return connect_method; } @@ -84,22 +86,22 @@ unowned Method get_connect_after_method () { if (connect_after_method == null) { var ulong_type = CodeContext.get ().analyzer.ulong_type.copy (); - connect_after_method = new Method ("connect_after", ulong_type); + connect_after_method = new Method ("connect_after", ulong_type, source_reference); connect_after_method.access = SymbolAccessibility.PUBLIC; connect_after_method.external = true; connect_after_method.owner = signal_symbol.scope; - connect_after_method.add_parameter (new Parameter ("handler", get_handler_type ())); + connect_after_method.add_parameter (new Parameter ("handler", get_handler_type (), source_reference)); } return connect_after_method; } unowned Method get_disconnect_method () { if (disconnect_method == null) { - disconnect_method = new Method ("disconnect", new VoidType ()); + disconnect_method = new Method ("disconnect", new VoidType (), source_reference); disconnect_method.access = SymbolAccessibility.PUBLIC; disconnect_method.external = true; disconnect_method.owner = signal_symbol.scope; - disconnect_method.add_parameter (new Parameter ("handler", get_handler_type ())); + disconnect_method.add_parameter (new Parameter ("handler", get_handler_type (), source_reference)); } return disconnect_method; } diff -Nru vala-0.52.6/vala/valasignal.vala vala-0.52.7/vala/valasignal.vala --- vala-0.52.6/vala/valasignal.vala 2021-09-30 15:37:07.000000000 +0000 +++ vala-0.52.7/vala/valasignal.vala 2021-10-26 12:38:24.000000000 +0000 @@ -104,7 +104,7 @@ public Delegate get_delegate (DataType sender_type, CodeNode node_reference) { var actual_return_type = return_type.get_actual_type (sender_type, null, node_reference); - var generated_delegate = new Delegate (null, actual_return_type); + var generated_delegate = new Delegate (null, actual_return_type, source_reference); generated_delegate.access = SymbolAccessibility.PUBLIC; generated_delegate.owner = scope; diff -Nru vala-0.52.6/vala/valasliceexpression.c vala-0.52.7/vala/valasliceexpression.c --- vala-0.52.6/vala/valasliceexpression.c 2021-10-04 09:46:53.000000000 +0000 +++ vala-0.52.7/vala/valasliceexpression.c 2021-10-30 08:24:06.000000000 +0000 @@ -326,8 +326,8 @@ ValaExpression* _tmp47_; ValaDataType* _tmp48_; ValaDataType* _tmp49_; - gboolean _tmp125_; - gboolean _tmp126_; + gboolean _tmp129_; + gboolean _tmp130_; gboolean result = FALSE; self = (ValaSliceExpression*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -566,14 +566,14 @@ ValaSymbol* _tmp95_; ValaMethod* _tmp96_; ValaMethod* _tmp97_; - ValaSourceReference* _tmp117_; - ValaSourceReference* _tmp118_; - ValaExpression* _tmp119_; - ValaExpression* _tmp120_; - ValaDataType* _tmp121_; - ValaDataType* _tmp122_; - gchar* _tmp123_; - gchar* _tmp124_; + ValaSourceReference* _tmp121_; + ValaSourceReference* _tmp122_; + ValaExpression* _tmp123_; + ValaExpression* _tmp124_; + ValaDataType* _tmp125_; + ValaDataType* _tmp126_; + gchar* _tmp127_; + gchar* _tmp128_; _tmp91_ = vala_slice_expression_get_container (self); _tmp92_ = _tmp91_; _tmp93_ = vala_expression_get_value_type (_tmp92_); @@ -589,69 +589,77 @@ ValaMethodCall* slice_call = NULL; ValaExpression* _tmp98_; ValaExpression* _tmp99_; - ValaMemberAccess* _tmp100_; - ValaMemberAccess* _tmp101_; - ValaMethodCall* _tmp102_; - ValaMethodCall* _tmp103_; - ValaMethodCall* _tmp104_; - ValaExpression* _tmp105_; - ValaExpression* _tmp106_; + ValaSourceReference* _tmp100_; + ValaSourceReference* _tmp101_; + ValaMemberAccess* _tmp102_; + ValaMemberAccess* _tmp103_; + ValaSourceReference* _tmp104_; + ValaSourceReference* _tmp105_; + ValaMethodCall* _tmp106_; ValaMethodCall* _tmp107_; - ValaExpression* _tmp108_; + ValaMethodCall* _tmp108_; ValaExpression* _tmp109_; - ValaMethodCall* _tmp110_; - ValaDataType* _tmp111_; - ValaDataType* _tmp112_; - ValaCodeNode* _tmp113_; - ValaCodeNode* _tmp114_; - ValaMethodCall* _tmp115_; - ValaMethodCall* _tmp116_; + ValaExpression* _tmp110_; + ValaMethodCall* _tmp111_; + ValaExpression* _tmp112_; + ValaExpression* _tmp113_; + ValaMethodCall* _tmp114_; + ValaDataType* _tmp115_; + ValaDataType* _tmp116_; + ValaCodeNode* _tmp117_; + ValaCodeNode* _tmp118_; + ValaMethodCall* _tmp119_; + ValaMethodCall* _tmp120_; _tmp98_ = vala_slice_expression_get_container (self); _tmp99_ = _tmp98_; - _tmp100_ = vala_member_access_new (_tmp99_, "slice", NULL); + _tmp100_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp101_ = _tmp100_; - _tmp102_ = vala_method_call_new ((ValaExpression*) _tmp101_, NULL); + _tmp102_ = vala_member_access_new (_tmp99_, "slice", _tmp101_); _tmp103_ = _tmp102_; - _vala_code_node_unref0 (_tmp101_); - slice_call = _tmp103_; - _tmp104_ = slice_call; - _tmp105_ = vala_slice_expression_get_start (self); - _tmp106_ = _tmp105_; - vala_callable_expression_add_argument ((ValaCallableExpression*) _tmp104_, _tmp106_); - _tmp107_ = slice_call; - _tmp108_ = vala_slice_expression_get_stop (self); - _tmp109_ = _tmp108_; - vala_callable_expression_add_argument ((ValaCallableExpression*) _tmp107_, _tmp109_); - _tmp110_ = slice_call; - _tmp111_ = vala_expression_get_target_type ((ValaExpression*) self); - _tmp112_ = _tmp111_; - vala_expression_set_target_type ((ValaExpression*) _tmp110_, _tmp112_); - _tmp113_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); - _tmp114_ = _tmp113_; - _tmp115_ = slice_call; - vala_code_node_replace_expression (_tmp114_, (ValaExpression*) self, (ValaExpression*) _tmp115_); - _tmp116_ = slice_call; - result = vala_code_node_check ((ValaCodeNode*) _tmp116_, context); + _tmp104_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp105_ = _tmp104_; + _tmp106_ = vala_method_call_new ((ValaExpression*) _tmp103_, _tmp105_); + _tmp107_ = _tmp106_; + _vala_code_node_unref0 (_tmp103_); + slice_call = _tmp107_; + _tmp108_ = slice_call; + _tmp109_ = vala_slice_expression_get_start (self); + _tmp110_ = _tmp109_; + vala_callable_expression_add_argument ((ValaCallableExpression*) _tmp108_, _tmp110_); + _tmp111_ = slice_call; + _tmp112_ = vala_slice_expression_get_stop (self); + _tmp113_ = _tmp112_; + vala_callable_expression_add_argument ((ValaCallableExpression*) _tmp111_, _tmp113_); + _tmp114_ = slice_call; + _tmp115_ = vala_expression_get_target_type ((ValaExpression*) self); + _tmp116_ = _tmp115_; + vala_expression_set_target_type ((ValaExpression*) _tmp114_, _tmp116_); + _tmp117_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp118_ = _tmp117_; + _tmp119_ = slice_call; + vala_code_node_replace_expression (_tmp118_, (ValaExpression*) self, (ValaExpression*) _tmp119_); + _tmp120_ = slice_call; + result = vala_code_node_check ((ValaCodeNode*) _tmp120_, context); _vala_code_node_unref0 (slice_call); _vala_code_node_unref0 (slice_method); return result; } vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp117_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp118_ = _tmp117_; - _tmp119_ = vala_slice_expression_get_container (self); - _tmp120_ = _tmp119_; - _tmp121_ = vala_expression_get_value_type (_tmp120_); + _tmp121_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp122_ = _tmp121_; - _tmp123_ = vala_code_node_to_string ((ValaCodeNode*) _tmp122_); + _tmp123_ = vala_slice_expression_get_container (self); _tmp124_ = _tmp123_; - vala_report_error (_tmp118_, "The expression `%s' does not denote an array", _tmp124_); - _g_free0 (_tmp124_); + _tmp125_ = vala_expression_get_value_type (_tmp124_); + _tmp126_ = _tmp125_; + _tmp127_ = vala_code_node_to_string ((ValaCodeNode*) _tmp126_); + _tmp128_ = _tmp127_; + vala_report_error (_tmp122_, "The expression `%s' does not denote an array", _tmp128_); + _g_free0 (_tmp128_); _vala_code_node_unref0 (slice_method); } - _tmp125_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp126_ = _tmp125_; - result = !_tmp126_; + _tmp129_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp130_ = _tmp129_; + result = !_tmp130_; return result; } diff -Nru vala-0.52.6/vala/valasliceexpression.vala vala-0.52.7/vala/valasliceexpression.vala --- vala-0.52.6/vala/valasliceexpression.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vala/valasliceexpression.vala 2021-10-30 08:19:54.000000000 +0000 @@ -168,7 +168,7 @@ } else { var slice_method = container.value_type.get_member ("slice") as Method; if (slice_method != null) { - var slice_call = new MethodCall (new MemberAccess (container, "slice")); + var slice_call = new MethodCall (new MemberAccess (container, "slice", source_reference), source_reference); slice_call.add_argument (start); slice_call.add_argument (stop); slice_call.target_type = this.target_type; diff -Nru vala-0.52.6/vala/valaunaryexpression.c vala-0.52.7/vala/valaunaryexpression.c --- vala-0.52.6/vala/valaunaryexpression.c 2021-10-04 09:46:53.000000000 +0000 +++ vala-0.52.7/vala/valaunaryexpression.c 2021-10-30 08:24:06.000000000 +0000 @@ -61,8 +61,6 @@ ValaDataType* type); static gboolean vala_unary_expression_is_integer_type (ValaUnaryExpression* self, ValaDataType* type); -static ValaMemberAccess* vala_unary_expression_find_member_access (ValaUnaryExpression* self, - ValaExpression* expr); static void vala_unary_expression_real_get_error_types (ValaCodeNode* base, ValaCollection* collection, ValaSourceReference* source_reference); @@ -425,23 +423,6 @@ return result; } -static ValaMemberAccess* -vala_unary_expression_find_member_access (ValaUnaryExpression* self, - ValaExpression* expr) -{ - ValaMemberAccess* result = NULL; - g_return_val_if_fail (self != NULL, NULL); - g_return_val_if_fail (expr != NULL, NULL); - if (VALA_IS_MEMBER_ACCESS (expr)) { - ValaMemberAccess* _tmp0_; - _tmp0_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (expr, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); - result = _tmp0_; - return result; - } - result = NULL; - return result; -} - static void vala_unary_expression_real_get_error_types (ValaCodeNode* base, ValaCollection* collection, @@ -474,10 +455,10 @@ ValaDataType* _tmp31_; ValaDataType* _tmp32_; ValaUnaryOperator _tmp47_; - ValaDataType* _tmp183_; - ValaDataType* _tmp184_; - gboolean _tmp185_; - gboolean _tmp186_; + ValaDataType* _tmp181_; + ValaDataType* _tmp182_; + gboolean _tmp183_; + gboolean _tmp184_; gboolean result = FALSE; self = (ValaUnaryExpression*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -788,15 +769,12 @@ ValaExpression* _tmp112_; ValaDataType* _tmp113_; ValaDataType* _tmp114_; - ValaMemberAccess* ma = NULL; ValaExpression* _tmp123_; ValaExpression* _tmp124_; - ValaMemberAccess* _tmp125_; - ValaMemberAccess* _tmp126_; - ValaExpression* _tmp129_; - ValaExpression* _tmp130_; - ValaDataType* _tmp131_; - ValaDataType* _tmp132_; + ValaExpression* _tmp127_; + ValaExpression* _tmp128_; + ValaDataType* _tmp129_; + ValaDataType* _tmp130_; _tmp111_ = vala_unary_expression_get_inner (self); _tmp112_ = _tmp111_; _tmp113_ = vala_expression_get_value_type (_tmp112_); @@ -826,163 +804,158 @@ } _tmp123_ = vala_unary_expression_get_inner (self); _tmp124_ = _tmp123_; - _tmp125_ = vala_unary_expression_find_member_access (self, _tmp124_); - ma = _tmp125_; - _tmp126_ = ma; - if (_tmp126_ == NULL) { - ValaSourceReference* _tmp127_; - ValaSourceReference* _tmp128_; + if (!VALA_IS_MEMBER_ACCESS (_tmp124_)) { + ValaSourceReference* _tmp125_; + ValaSourceReference* _tmp126_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp127_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp128_ = _tmp127_; - vala_report_error (_tmp128_, "Prefix operators not supported for this expression"); + _tmp125_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp126_ = _tmp125_; + vala_report_error (_tmp126_, "Prefix operators not supported for this expression"); result = FALSE; - _vala_code_node_unref0 (ma); return result; } - _tmp129_ = vala_unary_expression_get_inner (self); + _tmp127_ = vala_unary_expression_get_inner (self); + _tmp128_ = _tmp127_; + _tmp129_ = vala_expression_get_value_type (_tmp128_); _tmp130_ = _tmp129_; - _tmp131_ = vala_expression_get_value_type (_tmp130_); - _tmp132_ = _tmp131_; - vala_expression_set_value_type ((ValaExpression*) self, _tmp132_); - _vala_code_node_unref0 (ma); + vala_expression_set_value_type ((ValaExpression*) self, _tmp130_); break; } case VALA_UNARY_OPERATOR_REF: case VALA_UNARY_OPERATOR_OUT: { ValaElementAccess* ea = NULL; - ValaExpression* _tmp133_; - ValaExpression* _tmp134_; + ValaExpression* _tmp131_; + ValaExpression* _tmp132_; + gboolean _tmp133_ = FALSE; + gboolean _tmp134_ = FALSE; gboolean _tmp135_ = FALSE; - gboolean _tmp136_ = FALSE; - gboolean _tmp137_ = FALSE; - ValaExpression* _tmp138_; - ValaExpression* _tmp139_; - ValaSymbol* _tmp140_; - ValaSymbol* _tmp141_; - gboolean _tmp163_ = FALSE; - ValaExpression* _tmp164_; - ValaExpression* _tmp165_; - ValaSymbol* _tmp166_; - ValaSymbol* _tmp167_; - _tmp133_ = vala_unary_expression_get_inner (self); - _tmp134_ = _tmp133_; - ea = VALA_IS_ELEMENT_ACCESS (_tmp134_) ? ((ValaElementAccess*) _tmp134_) : NULL; - _tmp138_ = vala_unary_expression_get_inner (self); + ValaExpression* _tmp136_; + ValaExpression* _tmp137_; + ValaSymbol* _tmp138_; + ValaSymbol* _tmp139_; + gboolean _tmp161_ = FALSE; + ValaExpression* _tmp162_; + ValaExpression* _tmp163_; + ValaSymbol* _tmp164_; + ValaSymbol* _tmp165_; + _tmp131_ = vala_unary_expression_get_inner (self); + _tmp132_ = _tmp131_; + ea = VALA_IS_ELEMENT_ACCESS (_tmp132_) ? ((ValaElementAccess*) _tmp132_) : NULL; + _tmp136_ = vala_unary_expression_get_inner (self); + _tmp137_ = _tmp136_; + _tmp138_ = vala_expression_get_symbol_reference (_tmp137_); _tmp139_ = _tmp138_; - _tmp140_ = vala_expression_get_symbol_reference (_tmp139_); - _tmp141_ = _tmp140_; - if (VALA_IS_FIELD (_tmp141_)) { - _tmp137_ = TRUE; + if (VALA_IS_FIELD (_tmp139_)) { + _tmp135_ = TRUE; } else { - ValaExpression* _tmp142_; - ValaExpression* _tmp143_; - ValaSymbol* _tmp144_; - ValaSymbol* _tmp145_; - _tmp142_ = vala_unary_expression_get_inner (self); + ValaExpression* _tmp140_; + ValaExpression* _tmp141_; + ValaSymbol* _tmp142_; + ValaSymbol* _tmp143_; + _tmp140_ = vala_unary_expression_get_inner (self); + _tmp141_ = _tmp140_; + _tmp142_ = vala_expression_get_symbol_reference (_tmp141_); _tmp143_ = _tmp142_; - _tmp144_ = vala_expression_get_symbol_reference (_tmp143_); - _tmp145_ = _tmp144_; - _tmp137_ = VALA_IS_PARAMETER (_tmp145_); + _tmp135_ = VALA_IS_PARAMETER (_tmp143_); } - if (_tmp137_) { - _tmp136_ = TRUE; + if (_tmp135_) { + _tmp134_ = TRUE; } else { - ValaExpression* _tmp146_; - ValaExpression* _tmp147_; - ValaSymbol* _tmp148_; - ValaSymbol* _tmp149_; - _tmp146_ = vala_unary_expression_get_inner (self); + ValaExpression* _tmp144_; + ValaExpression* _tmp145_; + ValaSymbol* _tmp146_; + ValaSymbol* _tmp147_; + _tmp144_ = vala_unary_expression_get_inner (self); + _tmp145_ = _tmp144_; + _tmp146_ = vala_expression_get_symbol_reference (_tmp145_); _tmp147_ = _tmp146_; - _tmp148_ = vala_expression_get_symbol_reference (_tmp147_); - _tmp149_ = _tmp148_; - _tmp136_ = VALA_IS_LOCAL_VARIABLE (_tmp149_); + _tmp134_ = VALA_IS_LOCAL_VARIABLE (_tmp147_); } - if (_tmp136_) { - _tmp135_ = TRUE; + if (_tmp134_) { + _tmp133_ = TRUE; } else { - gboolean _tmp150_ = FALSE; - ValaElementAccess* _tmp151_; - _tmp151_ = ea; - if (_tmp151_ != NULL) { - ValaElementAccess* _tmp152_; - ValaExpression* _tmp153_; - ValaExpression* _tmp154_; - ValaDataType* _tmp155_; - ValaDataType* _tmp156_; - _tmp152_ = ea; - _tmp153_ = vala_element_access_get_container (_tmp152_); + gboolean _tmp148_ = FALSE; + ValaElementAccess* _tmp149_; + _tmp149_ = ea; + if (_tmp149_ != NULL) { + ValaElementAccess* _tmp150_; + ValaExpression* _tmp151_; + ValaExpression* _tmp152_; + ValaDataType* _tmp153_; + ValaDataType* _tmp154_; + _tmp150_ = ea; + _tmp151_ = vala_element_access_get_container (_tmp150_); + _tmp152_ = _tmp151_; + _tmp153_ = vala_expression_get_value_type (_tmp152_); _tmp154_ = _tmp153_; - _tmp155_ = vala_expression_get_value_type (_tmp154_); - _tmp156_ = _tmp155_; - _tmp150_ = VALA_IS_ARRAY_TYPE (_tmp156_); + _tmp148_ = VALA_IS_ARRAY_TYPE (_tmp154_); } else { - _tmp150_ = FALSE; + _tmp148_ = FALSE; } - _tmp135_ = _tmp150_; + _tmp133_ = _tmp148_; } - if (_tmp135_) { - ValaExpression* _tmp157_; - ValaExpression* _tmp158_; - ValaDataType* _tmp159_; - ValaDataType* _tmp160_; + if (_tmp133_) { + ValaExpression* _tmp155_; + ValaExpression* _tmp156_; + ValaDataType* _tmp157_; + ValaDataType* _tmp158_; vala_expression_set_lvalue ((ValaExpression*) self, TRUE); - _tmp157_ = vala_unary_expression_get_inner (self); + _tmp155_ = vala_unary_expression_get_inner (self); + _tmp156_ = _tmp155_; + _tmp157_ = vala_expression_get_value_type (_tmp156_); _tmp158_ = _tmp157_; - _tmp159_ = vala_expression_get_value_type (_tmp158_); - _tmp160_ = _tmp159_; - vala_expression_set_value_type ((ValaExpression*) self, _tmp160_); + vala_expression_set_value_type ((ValaExpression*) self, _tmp158_); } else { - ValaSourceReference* _tmp161_; - ValaSourceReference* _tmp162_; + ValaSourceReference* _tmp159_; + ValaSourceReference* _tmp160_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp161_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp162_ = _tmp161_; - vala_report_error (_tmp162_, "ref and out method arguments can only be used with fields, parameters," \ + _tmp159_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp160_ = _tmp159_; + vala_report_error (_tmp160_, "ref and out method arguments can only be used with fields, parameters," \ " local variables, and array element access"); result = FALSE; return result; } - _tmp164_ = vala_unary_expression_get_inner (self); + _tmp162_ = vala_unary_expression_get_inner (self); + _tmp163_ = _tmp162_; + _tmp164_ = vala_expression_get_symbol_reference (_tmp163_); _tmp165_ = _tmp164_; - _tmp166_ = vala_expression_get_symbol_reference (_tmp165_); - _tmp167_ = _tmp166_; - if (_tmp167_ != NULL) { - ValaExpression* _tmp168_; - ValaExpression* _tmp169_; - ValaSymbol* _tmp170_; - ValaSymbol* _tmp171_; - ValaAttribute* _tmp172_; - _tmp168_ = vala_unary_expression_get_inner (self); + if (_tmp165_ != NULL) { + ValaExpression* _tmp166_; + ValaExpression* _tmp167_; + ValaSymbol* _tmp168_; + ValaSymbol* _tmp169_; + ValaAttribute* _tmp170_; + _tmp166_ = vala_unary_expression_get_inner (self); + _tmp167_ = _tmp166_; + _tmp168_ = vala_expression_get_symbol_reference (_tmp167_); _tmp169_ = _tmp168_; - _tmp170_ = vala_expression_get_symbol_reference (_tmp169_); - _tmp171_ = _tmp170_; - _tmp172_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp171_, "GtkChild"); - _tmp163_ = _tmp172_ != NULL; + _tmp170_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp169_, "GtkChild"); + _tmp161_ = _tmp170_ != NULL; } else { - _tmp163_ = FALSE; + _tmp161_ = FALSE; } - if (_tmp163_) { - ValaSourceReference* _tmp173_; - ValaSourceReference* _tmp174_; - ValaExpression* _tmp175_; - ValaExpression* _tmp176_; - ValaSymbol* _tmp177_; - ValaSymbol* _tmp178_; - gchar* _tmp179_; - gchar* _tmp180_; + if (_tmp161_) { + ValaSourceReference* _tmp171_; + ValaSourceReference* _tmp172_; + ValaExpression* _tmp173_; + ValaExpression* _tmp174_; + ValaSymbol* _tmp175_; + ValaSymbol* _tmp176_; + gchar* _tmp177_; + gchar* _tmp178_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp173_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp171_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp172_ = _tmp171_; + _tmp173_ = vala_unary_expression_get_inner (self); _tmp174_ = _tmp173_; - _tmp175_ = vala_unary_expression_get_inner (self); + _tmp175_ = vala_expression_get_symbol_reference (_tmp174_); _tmp176_ = _tmp175_; - _tmp177_ = vala_expression_get_symbol_reference (_tmp176_); + _tmp177_ = vala_symbol_get_full_name (_tmp176_); _tmp178_ = _tmp177_; - _tmp179_ = vala_symbol_get_full_name (_tmp178_); - _tmp180_ = _tmp179_; - vala_report_error (_tmp174_, "Assignment of [GtkChild] `%s' is not allowed", _tmp180_); - _g_free0 (_tmp180_); + vala_report_error (_tmp172_, "Assignment of [GtkChild] `%s' is not allowed", _tmp178_); + _g_free0 (_tmp178_); result = FALSE; return result; } @@ -990,22 +963,22 @@ } default: { - ValaSourceReference* _tmp181_; - ValaSourceReference* _tmp182_; + ValaSourceReference* _tmp179_; + ValaSourceReference* _tmp180_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp181_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp182_ = _tmp181_; - vala_report_error (_tmp182_, "internal error: unsupported unary operator"); + _tmp179_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp180_ = _tmp179_; + vala_report_error (_tmp180_, "internal error: unsupported unary operator"); result = FALSE; return result; } } - _tmp183_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp181_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp182_ = _tmp181_; + vala_code_node_check ((ValaCodeNode*) _tmp182_, context); + _tmp183_ = vala_code_node_get_error ((ValaCodeNode*) self); _tmp184_ = _tmp183_; - vala_code_node_check ((ValaCodeNode*) _tmp184_, context); - _tmp185_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp186_ = _tmp185_; - result = !_tmp186_; + result = !_tmp184_; return result; } diff -Nru vala-0.52.6/vala/valaunaryexpression.vala vala-0.52.7/vala/valaunaryexpression.vala --- vala-0.52.6/vala/valaunaryexpression.vala 2021-09-30 15:37:07.000000000 +0000 +++ vala-0.52.7/vala/valaunaryexpression.vala 2021-10-26 12:38:24.000000000 +0000 @@ -128,14 +128,6 @@ return st.is_integer_type (); } - MemberAccess? find_member_access (Expression expr) { - if (expr is MemberAccess) { - return (MemberAccess) expr; - } - - return null; - } - public override void get_error_types (Collection collection, SourceReference? source_reference = null) { inner.get_error_types (collection, source_reference); } @@ -211,8 +203,7 @@ return false; } - var ma = find_member_access (inner); - if (ma == null) { + if (!(inner is MemberAccess)) { error = true; Report.error (source_reference, "Prefix operators not supported for this expression"); return false; diff -Nru vala-0.52.6/vala/valavaluetype.c vala-0.52.7/vala/valavaluetype.c --- vala-0.52.6/vala/valavaluetype.c 2021-10-04 09:46:53.000000000 +0000 +++ vala-0.52.7/vala/valavaluetype.c 2021-10-30 08:24:06.000000000 +0000 @@ -95,7 +95,17 @@ g_return_val_if_fail (context != NULL, FALSE); _tmp0_ = vala_data_type_get_type_symbol ((ValaDataType*) self); _tmp1_ = _tmp0_; - result = vala_code_node_check ((ValaCodeNode*) _tmp1_, context); + if (!vala_code_node_check ((ValaCodeNode*) _tmp1_, context)) { + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + result = FALSE; + return result; + } + if (!vala_data_type_check_type_arguments ((ValaDataType*) self, context, TRUE)) { + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + result = FALSE; + return result; + } + result = TRUE; return result; } diff -Nru vala-0.52.6/vala/valavaluetype.vala vala-0.52.7/vala/valavaluetype.vala --- vala-0.52.6/vala/valavaluetype.vala 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vala/valavaluetype.vala 2021-10-30 08:19:54.000000000 +0000 @@ -49,6 +49,17 @@ } public override bool check (CodeContext context) { - return type_symbol.check (context); + if (!type_symbol.check (context)) { + error = true; + return false; + } + + // check whether there is the expected amount of type-arguments + if (!check_type_arguments (context, true)) { + error = true; + return false; + } + + return true; } } diff -Nru vala-0.52.6/vala/valaversion.vala vala-0.52.7/vala/valaversion.vala --- vala-0.52.6/vala/valaversion.vala 2021-10-04 09:46:50.000000000 +0000 +++ vala-0.52.7/vala/valaversion.vala 2021-10-30 08:24:03.000000000 +0000 @@ -35,7 +35,7 @@ * Like get_micro_version, but from the headers used at application compile time, * rather than from the library linked against at application run time */ - public const int MICRO_VERSION = 6; + public const int MICRO_VERSION = 7; /** * The API version string @@ -45,7 +45,7 @@ /** * The full build-version string generated by the build-system */ - public const string BUILD_VERSION = "0.52.6"; + public const string BUILD_VERSION = "0.52.7"; /** * Returns the major version number of the vala library. diff -Nru vala-0.52.6/valadoc/doclets/devhelp/Makefile.in vala-0.52.7/valadoc/doclets/devhelp/Makefile.in --- vala-0.52.6/valadoc/doclets/devhelp/Makefile.in 2021-10-04 09:46:43.000000000 +0000 +++ vala-0.52.7/valadoc/doclets/devhelp/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/valadoc/doclets/gtkdoc/Makefile.in vala-0.52.7/valadoc/doclets/gtkdoc/Makefile.in --- vala-0.52.6/valadoc/doclets/gtkdoc/Makefile.in 2021-10-04 09:46:43.000000000 +0000 +++ vala-0.52.7/valadoc/doclets/gtkdoc/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/valadoc/doclets/html/Makefile.in vala-0.52.7/valadoc/doclets/html/Makefile.in --- vala-0.52.6/valadoc/doclets/html/Makefile.in 2021-10-04 09:46:43.000000000 +0000 +++ vala-0.52.7/valadoc/doclets/html/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/valadoc/doclets/Makefile.in vala-0.52.7/valadoc/doclets/Makefile.in --- vala-0.52.6/valadoc/doclets/Makefile.in 2021-10-04 09:46:43.000000000 +0000 +++ vala-0.52.7/valadoc/doclets/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/valadoc/icons/Makefile.in vala-0.52.7/valadoc/icons/Makefile.in --- vala-0.52.6/valadoc/icons/Makefile.in 2021-10-04 09:46:43.000000000 +0000 +++ vala-0.52.7/valadoc/icons/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/valadoc/Makefile.in vala-0.52.7/valadoc/Makefile.in --- vala-0.52.6/valadoc/Makefile.in 2021-10-04 09:46:42.000000000 +0000 +++ vala-0.52.7/valadoc/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/valadoc/tests/Makefile.in vala-0.52.7/valadoc/tests/Makefile.in --- vala-0.52.6/valadoc/tests/Makefile.in 2021-10-04 09:46:43.000000000 +0000 +++ vala-0.52.7/valadoc/tests/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/vapi/glib-2.0.vapi vala-0.52.7/vapi/glib-2.0.vapi --- vala-0.52.6/vapi/glib-2.0.vapi 2021-10-04 08:38:30.000000000 +0000 +++ vala-0.52.7/vapi/glib-2.0.vapi 2021-10-30 08:19:54.000000000 +0000 @@ -4995,12 +4995,42 @@ public void insert_sorted (owned G data, CompareFunc compare_func); [ReturnsModifiedPointer ()] public void remove (G data); + [CCode (cname = "vala_g_list_remove_full")] + [ReturnsModifiedPointer ()] + public unowned List remove_full (G data, FreeFunc? func) { + unowned List? l = this; + while (l != null) { + if (((!) l).data != data) { + l = ((!) l).next; + } else { + func (((!) l).data); + delete_link ((!) l); + break; + } + } + return this; + } [ReturnsModifiedPointer ()] public void remove_link (List llink); [ReturnsModifiedPointer ()] public void delete_link (List link_); [ReturnsModifiedPointer ()] public void remove_all (G data); + [CCode (cname = "vala_g_list_remove_all_full")] + [ReturnsModifiedPointer ()] + public unowned List remove_all_full (G data, FreeFunc? func) { + unowned List? l = this; + while (l != null) { + if (((!) l).data != data) { + l = ((!) l).next; + } else { + func (((!) l).data); + delete_link ((!) l); + l = this; + } + } + return this; + } public uint length (); public List copy (); @@ -5062,12 +5092,42 @@ public void insert_sorted (owned G data, CompareFunc compare_func); [ReturnsModifiedPointer ()] public void remove (G data); + [CCode (cname = "vala_g_slist_remove_full")] + [ReturnsModifiedPointer ()] + public unowned SList remove_full (G data, FreeFunc? func) { + unowned SList? l = this; + while (l != null) { + if (((!) l).data != data) { + l = ((!) l).next; + } else { + func (((!) l).data); + delete_link ((!) l); + break; + } + } + return this; + } [ReturnsModifiedPointer ()] public void remove_link (SList llink); [ReturnsModifiedPointer ()] public void delete_link (SList link_); [ReturnsModifiedPointer ()] public void remove_all (G data); + [CCode (cname = "vala_g_slist_remove_all_full")] + [ReturnsModifiedPointer ()] + public unowned SList remove_all_full (G data, FreeFunc? func) { + unowned SList? l = this; + while (l != null) { + if (((!) l).data != data) { + l = ((!) l).next; + } else { + func (((!) l).data); + delete_link ((!) l); + l = this; + } + } + return this; + } public uint length (); public SList copy (); @@ -5166,8 +5226,33 @@ public int index (G data); [Version (since = "2.4")] public bool remove (G data); + [CCode (cname = "vala_g_queue_remove_full")] + public bool remove_full (G data, FreeFunc? func) { + unowned List? l = head.find (data); + if (l != null) { + func (((!) l).data); + delete_link ((!) l); + return true; + } else { + return false; + } + } [Version (since = "2.4")] public uint remove_all (G data); + [CCode (cname = "vala_g_queue_remove_all_full")] + public uint remove_all_full (G data, FreeFunc? func) { + var old_length = length; + unowned List? l = head; + while (l != null) { + unowned List? next = ((!) l).next; + if (((!) l).data == data) { + func (((!) l).data); + delete_link ((!) l); + } + l = next; + } + return old_length - length; + } [Version (since = "2.4")] public void delete_link (List link); [Version (since = "2.4")] diff -Nru vala-0.52.6/vapi/Makefile.in vala-0.52.7/vapi/Makefile.in --- vala-0.52.6/vapi/Makefile.in 2021-10-04 09:46:43.000000000 +0000 +++ vala-0.52.7/vapi/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/vapigen/Makefile.in vala-0.52.7/vapigen/Makefile.in --- vala-0.52.6/vapigen/Makefile.in 2021-10-04 09:46:43.000000000 +0000 +++ vala-0.52.7/vapigen/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/vapigen/vala-gen-introspect/Makefile.in vala-0.52.7/vapigen/vala-gen-introspect/Makefile.in --- vala-0.52.6/vapigen/vala-gen-introspect/Makefile.in 2021-10-04 09:46:43.000000000 +0000 +++ vala-0.52.7/vapigen/vala-gen-introspect/Makefile.in 2021-10-30 08:23:56.000000000 +0000 @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.16.4 from Makefile.am. +# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. diff -Nru vala-0.52.6/.version vala-0.52.7/.version --- vala-0.52.6/.version 2021-10-04 09:46:48.000000000 +0000 +++ vala-0.52.7/.version 2021-10-30 08:24:02.000000000 +0000 @@ -1 +1 @@ -0.52.6 +0.52.7