vala/valaproperty.vala

   1 /* valaproperty.vala
   2  *
   3  * Copyright (C) 2006-2009  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  *      Raffaele Sandrini <raffaele@sandrini.ch>
  22  */
  23
  24 using GLib;
  25
  26 /**
  27  * Represents a property declaration in the source code.
  28  */
  29 public class Vala.Property : Member, Lockable {
  30         /**
  31          * The property type.
  32          */
  33         public DataType? property_type {
  34                 get { return _data_type; }
  35                 set {
  36                         _data_type = value;
  37                         if (value != null) {
  38                                 _data_type.parent_node = this;
  39                         }
  40                 }
  41         }
  42
  43         /**
  44          * The get accessor of this property if available.
  45          */
  46         public PropertyAccessor? get_accessor {
  47                 get { return _get_accessor; }
  48                 set {
  49                         _get_accessor = value;
  50                         if (value != null) {
  51                                 value.owner = scope;
  52                         }
  53                 }
  54         }
  55
  56         /**
  57          * The set/construct accessor of this property if available.
  58          */
  59         public PropertyAccessor? set_accessor {
  60                 get { return _set_accessor; }
  61                 set {
  62                         _set_accessor = value;
  63                         if (value != null) {
  64                                 value.owner = scope;
  65                         }
  66                 }
  67         }
  68
  69         /**
  70          * Represents the generated `this` parameter in this property.
  71          */
  72         public FormalParameter this_parameter { get; set; }
  73
  74         /**
  75          * Specifies whether a `notify` signal should be emitted on property
  76          * changes.
  77          */
  78         public bool notify { get; set; default = true; }
  79
  80         /**
  81          * Specifies whether the implementation of this property does not
  82          * provide getter/setter methods.
  83          */
  84         public bool no_accessor_method { get; set; }
  85
  86         /**
  87          * Specifies whether automatic accessor code generation should be
  88          * disabled.
  89          */
  90         public bool interface_only { get; set; }
  91
  92         /**
  93          * Specifies whether this property is abstract. Abstract properties have
  94          * no accessor bodies, may only be specified within abstract classes and
  95          * interfaces, and must be overriden by derived non-abstract classes.
  96          */
  97         public bool is_abstract { get; set; }
  98
  99         /**
 100          * Specifies whether this property is virtual. Virtual properties may be
 101          * overridden by derived classes.
 102          */
 103         public bool is_virtual { get; set; }
 104
 105         /**
 106          * Specifies whether this property overrides a virtual or abstract
 107          * property of a base type.
 108          */
 109         public bool overrides { get; set; }
 110
 111         /**
 112          * Reference the the Field that holds this property
 113          */
 114         public Field field { get; set; }
 115
 116         /**
 117          * Specifies whether this field may only be accessed with an instance of
 118          * the contained type.
 119          */
 120         public MemberBinding binding { get; set; default = MemberBinding.INSTANCE; }
 121
 122         /**
 123          * Specifies the virtual or abstract property this property overrides.
 124          * Reference must be weak as virtual properties set base_property to
 125          * themselves.
 126          */
 127         public Property base_property {
 128                 get {
 129                         find_base_properties ();
 130                         return _base_property;
 131                 }
 132         }
 133
 134         /**
 135          * Specifies the abstract interface property this property implements.
 136          */
 137         public Property base_interface_property {
 138                 get {
 139                         find_base_properties ();
 140                         return _base_interface_property;
 141                 }
 142         }
 143
 144         /**
 145          * Specifies the default value of this property.
 146          */
 147         public Expression default_expression { get; set; }
 148
 149         public bool no_array_length { get; set; }
 150
 151         public bool array_null_terminated { get; set; }
 152
 153         /**
 154          * Nickname of this property.
 155          */
 156         public string nick {
 157                 get {
 158                         if (_nick == null) {
 159                                 _nick = get_canonical_name ();
 160                         }
 161                         return _nick;
 162                 }
 163                 set { _nick = value; }
 164         }
 165
 166         /**
 167          * The long description of this property.
 168          */
 169         public string blurb {
 170                 get {
 171                         if (_blurb == null) {
 172                                 _blurb = get_canonical_name ();
 173                         }
 174                         return _blurb;
 175                 }
 176                 set { _blurb = value; }
 177         }
 178
 179         private bool lock_used = false;
 180
 181         private DataType _data_type;
 182
 183         private string? _nick;
 184         private string? _blurb;
 185
 186         private weak Property _base_property;
 187         private Property _base_interface_property;
 188         private bool base_properties_valid;
 189         PropertyAccessor? _get_accessor;
 190         PropertyAccessor? _set_accessor;
 191
 192         /**
 193          * Creates a new property.
 194          *
 195          * @param name         property name
 196          * @param type         property type
 197          * @param get_accessor get accessor
 198          * @param set_accessor set/construct accessor
 199          * @param source       reference to source code
 200          * @return             newly created property
 201          */
 202         public Property (string name, DataType? property_type, PropertyAccessor? get_accessor, PropertyAccessor? set_accessor, SourceReference? source_reference = null, Comment? comment = null) {
 203                 base (name, source_reference, comment);
 204                 this.property_type = property_type;
 205                 this.get_accessor = get_accessor;
 206                 this.set_accessor = set_accessor;
 207         }
 208
 209         public override void accept (CodeVisitor visitor) {
 210                 visitor.visit_member (this);
 211
 212                 visitor.visit_property (this);
 213         }
 214
 215         public override void accept_children (CodeVisitor visitor) {
 216                 property_type.accept (visitor);
 217
 218                 if (get_accessor != null) {
 219                         get_accessor.accept (visitor);
 220                 }
 221                 if (set_accessor != null) {
 222                         set_accessor.accept (visitor);
 223                 }
 224
 225                 if (default_expression != null) {
 226                         default_expression.accept (visitor);
 227                 }
 228         }
 229
 230         /**
 231          * Returns the C name of this property in upper case. Words are
 232          * separated by underscores. The upper case C name of the class is
 233          * prefix of the result.
 234          *
 235          * @return the upper case name to be used in C code
 236          */
 237         public string get_upper_case_cname () {
 238                 return "%s_%s".printf (parent_symbol.get_lower_case_cname (null), camel_case_to_lower_case (name)).up ();
 239         }
 240
 241         /**
 242          * Returns the string literal of this property to be used in C code.
 243          *
 244          * @return string literal to be used in C code
 245          */
 246         public CCodeConstant get_canonical_cconstant () {
 247                 return new CCodeConstant ("\"%s\"".printf (get_canonical_name ()));
 248         }
 249
 250         public string get_canonical_name () {
 251                 var str = new StringBuilder ();
 252
 253                 string i = name;
 254
 255                 while (i.len () > 0) {
 256                         unichar c = i.get_char ();
 257                         if (c == '_') {
 258                                 str.append_c ('-');
 259                         } else {
 260                                 str.append_unichar (c);
 261                         }
 262
 263                         i = i.next_char ();
 264                 }
 265
 266                 return str.str;
 267         }
 268
 269         void process_ccode_attribute (Attribute a) {
 270                 if (a.has_argument ("notify")) {
 271                         notify = a.get_bool ("notify");
 272                 }
 273                 if (a.has_argument ("array_length")) {
 274                         no_array_length = !a.get_bool ("array_length");
 275                 }
 276                 if (a.has_argument ("array_null_terminated")) {
 277                         array_null_terminated = a.get_bool ("array_null_terminated");
 278                 }
 279         }
 280
 281         /**
 282          * Process all associated attributes.
 283          */
 284         public void process_attributes () {
 285                 foreach (Attribute a in attributes) {
 286                         if (a.name == "CCode") {
 287                                 process_ccode_attribute (a);
 288                         } else if (a.name == "NoAccessorMethod") {
 289                                 no_accessor_method = true;
 290                         } else if (a.name == "Description") {
 291                                 if (a.has_argument ("nick")) {
 292                                         nick = a.get_string ("nick");
 293                                 }
 294                                 if (a.has_argument ("blurb")) {
 295                                         blurb = a.get_string ("blurb");
 296                                 }
 297                         }
 298                 }
 299         }
 300
 301         public bool get_lock_used () {
 302                 return lock_used;
 303         }
 304
 305         public void set_lock_used (bool used) {
 306                 lock_used = used;
 307         }
 308
 309         /**
 310          * Checks whether the accessors and type of the specified property
 311          * matches this property.
 312          *
 313          * @param prop a property
 314          * @return     true if the specified property is compatible to this
 315          *             property
 316          */
 317         public bool equals (Property prop2) {
 318                 if ((get_accessor == null && prop2.get_accessor != null) ||
 319                     (get_accessor != null && prop2.get_accessor == null)) {
 320                         return false;
 321                 }
 322
 323                 if ((set_accessor == null && prop2.set_accessor != null) ||
 324                     (set_accessor != null && prop2.set_accessor == null)) {
 325                         return false;
 326                 }
 327
 328                 if (get_accessor != null) {
 329                         // check accessor value_type instead of property_type
 330                         // due to possible ownership differences
 331                         if (!prop2.get_accessor.value_type.equals (get_accessor.value_type)) {
 332                                 return false;
 333                         }
 334                 }
 335
 336                 if (set_accessor != null) {
 337                         // check accessor value_type instead of property_type
 338                         // due to possible ownership differences
 339                         if (!prop2.set_accessor.value_type.equals (set_accessor.value_type)) {
 340                                 return false;
 341                         }
 342
 343                         if (set_accessor.writable != prop2.set_accessor.writable) {
 344                                 return false;
 345                         }
 346                         if (set_accessor.construction != prop2.set_accessor.construction) {
 347                                 return false;
 348                         }
 349                 }
 350
 351                 return true;
 352         }
 353
 354         public override void replace_type (DataType old_type, DataType new_type) {
 355                 if (property_type == old_type) {
 356                         property_type = new_type;
 357                 }
 358         }
 359
 360         private void find_base_properties () {
 361                 if (base_properties_valid) {
 362                         return;
 363                 }
 364
 365                 if (parent_symbol is Class) {
 366                         find_base_interface_property ((Class) parent_symbol);
 367                         if (is_virtual || overrides) {
 368                                 find_base_class_property ((Class) parent_symbol);
 369                         }
 370                 } else if (parent_symbol is Interface) {
 371                         if (is_virtual || is_abstract) {
 372                                 _base_interface_property = this;
 373                         }
 374                 }
 375
 376                 base_properties_valid = true;
 377         }
 378
 379         private void find_base_class_property (Class cl) {
 380                 var sym = cl.scope.lookup (name);
 381                 if (sym is Property) {
 382                         var base_property = (Property) sym;
 383                         if (base_property.is_abstract || base_property.is_virtual) {
 384                                 if (!equals (base_property)) {
 385                                         error = true;
 386                                         Report.error (source_reference, "Type and/or accessors of overriding property `%s' do not match overridden property `%s'.".printf (get_full_name (), base_property.get_full_name ()));
 387                                         return;
 388                                 }
 389
 390                                 _base_property = base_property;
 391                                 return;
 392                         }
 393                 }
 394
 395                 if (cl.base_class != null) {
 396                         find_base_class_property (cl.base_class);
 397                 }
 398         }
 399
 400         private void find_base_interface_property (Class cl) {
 401                 // FIXME report error if multiple possible base properties are found
 402                 foreach (DataType type in cl.get_base_types ()) {
 403                         if (type.data_type is Interface) {
 404                                 var sym = type.data_type.scope.lookup (name);
 405                                 if (sym is Property) {
 406                                         var base_property = (Property) sym;
 407                                         if (base_property.is_abstract) {
 408                                                 if (!equals (base_property)) {
 409                                                         error = true;
 410                                                         Report.error (source_reference, "Type and/or accessors of overriding property `%s' do not match overridden property `%s'.".printf (get_full_name (), base_property.get_full_name ()));
 411                                                         return;
 412                                                 }
 413
 414                                                 _base_interface_property = base_property;
 415                                                 return;
 416                                         }
 417                                 }
 418                         }
 419                 }
 420         }
 421
 422         public override bool check (SemanticAnalyzer analyzer) {
 423                 if (checked) {
 424                         return !error;
 425                 }
 426
 427                 checked = true;
 428
 429                 process_attributes ();
 430
 431                 var old_source_file = analyzer.current_source_file;
 432                 var old_symbol = analyzer.current_symbol;
 433
 434                 if (source_reference != null) {
 435                         analyzer.current_source_file = source_reference.file;
 436                 }
 437                 analyzer.current_symbol = this;
 438
 439                 property_type.check (analyzer);
 440
 441                 if (get_accessor != null) {
 442                         get_accessor.check (analyzer);
 443                 }
 444                 if (set_accessor != null) {
 445                         set_accessor.check (analyzer);
 446                 }
 447
 448                 if (default_expression != null) {
 449                         default_expression.check (analyzer);
 450                 }
 451
 452                 // check whether property type is at least as accessible as the property
 453                 if (!analyzer.is_type_accessible (this, property_type)) {
 454                         error = true;
 455                         Report.error (source_reference, "property type `%s` is less accessible than property `%s`".printf (property_type.to_string (), get_full_name ()));
 456                 }
 457
 458                 if (overrides && base_property == null) {
 459                         Report.error (source_reference, "%s: no suitable property found to override".printf (get_full_name ()));
 460                 }
 461
 462                 if (!external_package && !overrides && !hides && get_hidden_member () != null) {
 463                         Report.warning (source_reference, "%s hides inherited property `%s'. Use the `new' keyword if hiding was intentional".printf (get_full_name (), get_hidden_member ().get_full_name ()));
 464                 }
 465
 466                 /* construct properties must be public */
 467                 if (set_accessor != null && set_accessor.construction) {
 468                         if (access != SymbolAccessibility.PUBLIC) {
 469                                 error = true;
 470                                 Report.error (source_reference, "%s: construct properties must be public".printf (get_full_name ()));
 471                         }
 472                 }
 473
 474                 if (default_expression != null && !default_expression.error && !(default_expression.value_type.compatible (property_type))) {
 475                         error = true;
 476                         Report.error (default_expression.source_reference, "Expected initializer of type `%s' but got `%s'".printf (property_type.to_string (), default_expression.value_type.to_string ()));
 477                 }
 478
 479                 analyzer.current_source_file = old_source_file;
 480                 analyzer.current_symbol = old_symbol;
 481
 482                 return !error;
 483         }
 484 }