vala/valafield.vala

   1 /* valafield.vala
   2  *
   3  * Copyright (C) 2006-2010  Jürg Billeter
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Jürg Billeter <j@bitron.ch>
  21  */
  22
  23 using GLib;
  24
  25 /**
  26  * Represents a type or namespace field.
  27  */
  28 public class Vala.Field : Variable, Lockable {
  29         /**
  30          * Specifies whether this field may only be accessed with an instance of
  31          * the contained type.
  32          */
  33         public MemberBinding binding { get; set; default = MemberBinding.INSTANCE; }
  34
  35         /**
  36          * Specifies whether the field is volatile. Volatile fields are
  37          * necessary to allow multi-threaded access.
  38          */
  39         public bool is_volatile { get; set; }
  40
  41         private bool lock_used = false;
  42
  43         /**
  44          * Creates a new field.
  45          *
  46          * @param name              field name
  47          * @param variable_type     field type
  48          * @param initializer       initializer expression
  49          * @param source_reference  reference to source code
  50          * @return                  newly created field
  51          */
  52         public Field (string name, DataType variable_type, Expression? initializer, SourceReference? source_reference = null, Comment? comment = null) {
  53                 base (variable_type, name, initializer, source_reference, comment);
  54         }
  55
  56         public override void accept (CodeVisitor visitor) {
  57                 visitor.visit_field (this);
  58         }
  59
  60         public override void accept_children (CodeVisitor visitor) {
  61                 variable_type.accept (visitor);
  62
  63                 if (initializer != null) {
  64                         initializer.accept (visitor);
  65                 }
  66         }
  67
  68         public bool get_lock_used () {
  69                 return lock_used;
  70         }
  71
  72         public void set_lock_used (bool used) {
  73                 lock_used = used;
  74         }
  75
  76         public override void replace_expression (Expression old_node, Expression new_node) {
  77                 if (initializer == old_node) {
  78                         initializer = new_node;
  79                 }
  80         }
  81
  82         public override void replace_type (DataType old_type, DataType new_type) {
  83                 if (variable_type == old_type) {
  84                         variable_type = new_type;
  85                 }
  86         }
  87
  88         public override bool check (CodeContext context) {
  89                 if (checked) {
  90                         return !error;
  91                 }
  92
  93                 checked = true;
  94
  95                 var old_source_file = context.analyzer.current_source_file;
  96                 var old_symbol = context.analyzer.current_symbol;
  97
  98                 if (source_reference != null) {
  99                         context.analyzer.current_source_file = source_reference.file;
 100                 }
 101                 context.analyzer.current_symbol = this;
 102
 103                 if (variable_type is VoidType) {
 104                         error = true;
 105                         Report.error (source_reference, "'void' not supported as field type");
 106                         return false;
 107                 }
 108
 109                 variable_type.check (context);
 110
 111                 // check whether field type is at least as accessible as the field
 112                 if (!context.analyzer.is_type_accessible (this, variable_type)) {
 113                         error = true;
 114                         Report.error (source_reference, "field type `%s` is less accessible than field `%s`".printf (variable_type.to_string (), get_full_name ()));
 115                         return false;
 116                 }
 117
 118                 if (initializer != null) {
 119                         initializer.target_type = variable_type;
 120
 121                         if (!initializer.check (context)) {
 122                                 error = true;
 123                                 return false;
 124                         }
 125
 126                         if (initializer.value_type == null) {
 127                                 error = true;
 128                                 Report.error (source_reference, "expression type not allowed as initializer");
 129                                 return false;
 130                         }
 131
 132                         if (!initializer.value_type.compatible (variable_type)) {
 133                                 error = true;
 134                                 Report.error (source_reference, "Cannot convert from `%s' to `%s'".printf (initializer.value_type.to_string (), variable_type.to_string ()));
 135                                 return false;
 136                         }
 137
 138                         if (initializer.value_type.is_disposable ()) {
 139                                 /* rhs transfers ownership of the expression */
 140                                 if (!(variable_type is PointerType) && !variable_type.value_owned) {
 141                                         /* lhs doesn't own the value */
 142                                         error = true;
 143                                         Report.error (source_reference, "Invalid assignment from owned expression to unowned variable");
 144                                         return false;
 145                                 }
 146                         }
 147
 148                         if (parent_symbol is Namespace && !initializer.is_constant ()) {
 149                                 error = true;
 150                                 Report.error (source_reference, "Non-constant field initializers not supported in this context");
 151                                 return false;
 152                         }
 153
 154                         if (parent_symbol is Namespace && initializer.is_constant () && initializer.is_non_null ()) {
 155                                 if (variable_type.is_disposable () && variable_type.value_owned) {
 156                                         error = true;
 157                                         Report.error (source_reference, "Owned namespace fields can only be initialized in a function or method");
 158                                         return false;
 159                                 }
 160                         }
 161
 162                         if (binding == MemberBinding.STATIC && parent_symbol is Class && ((Class)parent_symbol).is_compact && !initializer.is_constant ()) {
 163                                 error = true;
 164                                 Report.error (source_reference, "Static fields in compact classes cannot have non-constant initializers");
 165                                 return false;
 166                         }
 167
 168                         if (external) {
 169                                 error = true;
 170                                 Report.error (source_reference, "External fields cannot use initializers");
 171                         }
 172                 }
 173
 174                 if (binding == MemberBinding.INSTANCE && parent_symbol is Interface) {
 175                         error = true;
 176                         Report.error (source_reference, "Interfaces may not have instance fields");
 177                         return false;
 178                 }
 179
 180                 bool field_in_header = !is_internal_symbol ();
 181                 if (parent_symbol is Class) {
 182                         var cl = (Class) parent_symbol;
 183                         if (cl.is_compact && !cl.is_internal_symbol ()) {
 184                                 // compact classes don't have priv structs
 185                                 field_in_header = true;
 186                         }
 187                 }
 188
 189                 if (!external_package && !hides && get_hidden_member () != null) {
 190                         Report.warning (source_reference, "%s hides inherited field `%s'. Use the `new' keyword if hiding was intentional".printf (get_full_name (), get_hidden_member ().get_full_name ()));
 191                 }
 192
 193                 context.analyzer.current_source_file = old_source_file;
 194                 context.analyzer.current_symbol = old_symbol;
 195
 196                 return !error;
 197         }
 198 }