[vala/wip/issue/327: 18/41] First version, seems to work

[Rico Tzschichholz <ricotz src gnome org>]

commit 8163d63480d45368650873fecfe5a055583e157e
Author: Nick Schrader <nick schrader mailbox org>
Date:   Fri Mar 27 20:53:59 2020 -0300

    First version, seems to work

 codegen/valaccodememberaccessmodule.vala |  3 +++
 vala/valamemberaccess.vala               | 22 +++++++++++++++++++---
 vala/valasemanticanalyzer.vala           | 14 ++++++++++----
 3 files changed, 32 insertions(+), 7 deletions(-)
---
diff --git a/codegen/valaccodememberaccessmodule.vala b/codegen/valaccodememberaccessmodule.vala
index 32e7cf54f..53b328bd0 100644
--- a/codegen/valaccodememberaccessmodule.vala
+++ b/codegen/valaccodememberaccessmodule.vala
@@ -589,6 +589,9 @@ public abstract class Vala.CCodeMemberAccessModule : CCodeControlFlowModule {
 
        /* Returns lvalue access to the given field */
        public override TargetValue get_field_cvalue (Field field, TargetValue? instance) {
+               if (field.name == "field")
+                       stdout.printf("Field name: %s\n", field.name);
+
                var value_type = field.variable_type.copy ();
 
                var result = new GLibValue (value_type);
diff --git a/vala/valamemberaccess.vala b/vala/valamemberaccess.vala
index 0be1e0226..aa54874da 100644
--- a/vala/valamemberaccess.vala
+++ b/vala/valamemberaccess.vala
@@ -225,6 +225,7 @@ public class Vala.MemberAccess : Expression {
                bool may_access_klass_members = false;
 
                symbol_reference = null;
+               var is_with = false;
 
                if (qualified) {
                        base_symbol = context.root;
@@ -284,6 +285,7 @@ public class Vala.MemberAccess : Expression {
                                }
 
                                symbol_reference = SemanticAnalyzer.symbol_lookup_inherited (sym, 
member_name);
+                               stdout.printf("symbol_reference: %s\n", symbol_reference != null ? 
symbol_reference.name : "(null)");
 
                                if (symbol_reference == null && sym is TypeSymbol && 
may_access_instance_members) {
                                        // used for generated to_string methods in enums
@@ -309,6 +311,17 @@ public class Vala.MemberAccess : Expression {
                                        }
                                }
 
+                               if (symbol_reference == null && sym is WithStatement) {
+                                       unowned WithStatement w = (WithStatement) sym;
+                                       var e = w.expression;
+                                       base_symbol = e.value_type.type_symbol;
+                                       symbol_reference = e.value_type.get_member (member_name);
+                                       may_access_instance_members = true;
+                                       may_access_klass_members = true;
+                                       is_with = true;
+                                       inner = e;
+                               }
+
                                var x = "null";
                                if (sym != null)
                                        x = Type.from_instance(sym).name();
@@ -373,6 +386,7 @@ public class Vala.MemberAccess : Expression {
 
                                if (symbol_reference == null && (base_symbol is Namespace || base_symbol is 
TypeSymbol)) {
                                        symbol_reference = base_symbol.scope.lookup (member_name);
+                                       stdout.printf("Inner symbol_reference %s, synmol_reference_name 
%s\n", Type.from_instance(symbol_reference).name(), symbol_reference.name);
                                        if (inner is BaseAccess) {
                                                // inner expression is base access
                                                // access to instance members of the base type possible
@@ -871,7 +885,7 @@ public class Vala.MemberAccess : Expression {
                        }
                } else {
                        // implicit this access
-                       if (instance && inner == null) {
+                       if (instance && inner == null && !is_with) {
                                inner = new MemberAccess (null, "this", source_reference);
                                inner.value_type = this_parameter.variable_type.copy ();
                                inner.value_type.value_owned = false;
@@ -924,11 +938,13 @@ public class Vala.MemberAccess : Expression {
                                }
                        } else if (symbol_reference is Property
                            && instance && symbol_reference.parent_symbol != null) {
-                               inner.target_type = SemanticAnalyzer.get_data_type_for_symbol 
(symbol_reference.parent_symbol);
+                                       if (inner != null)
+                                               inner.target_type = SemanticAnalyzer.get_data_type_for_symbol 
(symbol_reference.parent_symbol);
                        } else if ((symbol_reference is Field || symbol_reference is Signal)
                            && instance && symbol_reference.parent_symbol != null) {
                                var parent_type = SemanticAnalyzer.get_data_type_for_symbol 
(symbol_reference.parent_symbol);
-                               inner.target_type = parent_type.get_actual_type (inner.value_type, null, 
this);
+                               if (inner != null)
+                                       inner.target_type = parent_type.get_actual_type (inner.value_type, 
null, this);
                        }
                }
 
diff --git a/vala/valasemanticanalyzer.vala b/vala/valasemanticanalyzer.vala
index b17dce3e8..cf76c0280 100644
--- a/vala/valasemanticanalyzer.vala
+++ b/vala/valasemanticanalyzer.vala
@@ -318,11 +318,17 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                        return result;
                }
 
-               if (sym is WithStatement) {
+               /*if (sym is WithStatement) {
                        unowned WithStatement w = (WithStatement) sym;
-                       stdout.printf("Resolved with statement\n");
-                       return w.expression.symbol_reference;
-               } else if (sym is Class) {
+                       var lv = w.expression;
+                       var base_symbol = lv.value_type.type_symbol;
+                       var symbol_reference = lv.value_type.get_member (name);
+                       //  var vt = get_value_type_for_symbol(real_sym);
+                       //  var vt_sym = x.symbol;
+                       //  stdout.printf("Resolved with statement: %s, value type: %s, value type symbol: 
%s\n", Type.from_instance(real_sym).name(), Type.from_instance(vt).name(), Type.from_instance(vt_sym).name());
+                       //  return symbol_lookup_inherited(vt_sym, name);
+                       return symbol_reference;
+               } else */ if (sym is Class) {
                        unowned Class cl = (Class) sym;
                        // first check interfaces without prerequisites
                        // (prerequisites can be assumed to be met already)