vala/valaformalparameter.vala

   1 /* valaformalparameter.vala
   2  *
   3  * Copyright (C) 2006-2010  Jürg Billeter
   4  * Copyright (C) 2006-2008  Raffaele Sandrini
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19  *
  20  * Author:
  21  *      Jürg Billeter <j@bitron.ch>
  22  *      Raffaele Sandrini <raffaele@sandrini.ch>
  23  */
  24
  25 using GLib;
  26
  27 /**
  28  * Represents a formal parameter in method and callback signatures.
  29  */
  30 public class Vala.FormalParameter : Symbol {
  31         /**
  32          * The parameter type.
  33          */
  34         public DataType parameter_type {
  35                 get { return _data_type; }
  36                 set {
  37                         _data_type = value;
  38                         _data_type.parent_node = this;
  39                 }
  40         }
  41
  42         public ParameterDirection direction { get; set; default = ParameterDirection.IN; }
  43
  44         /**
  45          * Specifies whether the methods accepts an indefinite number of
  46          * parameters.
  47          */
  48         public bool ellipsis { get; set; }
  49
  50         /**
  51          * Specifies whether the methods accepts an indefinite number of
  52          * parameters.
  53          */
  54         public bool params_array { get; set; }
  55
  56         /**
  57          * Specifies the expression used when the caller doesn't supply an
  58          * argument for this parameter.
  59          */
  60         public Expression? default_expression {
  61                 get { return _default_expression; }
  62                 set {
  63                         _default_expression = value;
  64                         if (_default_expression != null) {
  65                                 _default_expression.parent_node = this;
  66                         }
  67                 }
  68         }
  69
  70         /**
  71          * Specifies whether the array length should be passed implicitly
  72          * if the parameter type is an array.
  73          */
  74         public bool no_array_length { get; set; }
  75
  76         /**
  77          * Specifies whether the array is null terminated.
  78          */
  79         public bool array_null_terminated { get; set; }
  80
  81         /**
  82          * Specifies a custom type for the array length.
  83          */
  84         public string? array_length_type { get; set; default = null; }
  85
  86         /**
  87          * Specifies the position of the parameter in the C function.
  88          */
  89         public double cparameter_position { get; set; }
  90
  91         /**
  92          * Specifies the position of the array length parameter in the C
  93          * function.
  94          */
  95         public double carray_length_parameter_position { get; set; }
  96
  97         /**
  98          * Specifies the position of the delegate target parameter in the C
  99          * function.
 100          */
 101         public double cdelegate_target_parameter_position { get; set; }
 102
 103         public double cdestroy_notify_parameter_position { get; set; }
 104
 105         /**
 106          * Specifies the type of the parameter in the C function.
 107          */
 108         public string? ctype { get; set; }
 109
 110         public bool captured { get; set; }
 111
 112         private DataType _data_type;
 113         private Expression? _default_expression;
 114
 115         /**
 116          * Creates a new formal parameter.
 117          *
 118          * @param name   parameter name
 119          * @param type   parameter type
 120          * @param source reference to source code
 121          * @return       newly created formal parameter
 122          */
 123         public FormalParameter (string name, DataType parameter_type, SourceReference? source_reference = null) {
 124                 base (name, source_reference);
 125                 this.parameter_type = parameter_type;
 126
 127                 access = SymbolAccessibility.PUBLIC;
 128         }
 129
 130         /**
 131          * Creates a new ellipsis parameter representing an indefinite number of
 132          * parameters.
 133          */
 134         public FormalParameter.with_ellipsis (SourceReference? source_reference = null) {
 135                 base (null, source_reference);
 136                 ellipsis = true;
 137
 138                 access = SymbolAccessibility.PUBLIC;
 139         }
 140
 141         public override void accept (CodeVisitor visitor) {
 142                 visitor.visit_formal_parameter (this);
 143         }
 144
 145         public override void accept_children (CodeVisitor visitor) {
 146                 if (!ellipsis) {
 147                         parameter_type.accept (visitor);
 148
 149                         if (default_expression != null) {
 150                                 default_expression.accept (visitor);
 151                         }
 152                 }
 153         }
 154
 155         public override void replace_type (DataType old_type, DataType new_type) {
 156                 if (parameter_type == old_type) {
 157                         parameter_type = new_type;
 158                 }
 159         }
 160
 161         public override void replace_expression (Expression old_node, Expression new_node) {
 162                 if (default_expression == old_node) {
 163                         default_expression = new_node;
 164                 }
 165         }
 166
 167         private void process_ccode_attribute (Attribute a) {
 168                 if (a.has_argument ("type")) {
 169                         ctype = a.get_string ("type");
 170                 }
 171                 if (a.has_argument ("pos")) {
 172                         cparameter_position = a.get_double ("pos");
 173                 }
 174                 if (a.has_argument ("array_length")) {
 175                         no_array_length = !a.get_bool ("array_length");
 176                 }
 177                 if (a.has_argument ("array_length_type")) {
 178                         array_length_type = a.get_string ("array_length_type");
 179                 }
 180                 if (a.has_argument ("array_null_terminated")) {
 181                         array_null_terminated = a.get_bool ("array_null_terminated");
 182                 }
 183                 if (a.has_argument ("array_length_pos")) {
 184                         carray_length_parameter_position = a.get_double ("array_length_pos");
 185                 }
 186                 if (a.has_argument ("delegate_target_pos")) {
 187                         cdelegate_target_parameter_position = a.get_double ("delegate_target_pos");
 188                 }
 189                 if (a.has_argument ("destroy_notify_pos")) {
 190                         cdestroy_notify_parameter_position = a.get_double ("destroy_notify_pos");
 191                 }
 192         }
 193
 194         /**
 195          * Process all associated attributes.
 196          */
 197         public void process_attributes () {
 198                 foreach (Attribute a in attributes) {
 199                         if (a.name == "CCode") {
 200                                 process_ccode_attribute (a);
 201                         }
 202                 }
 203         }
 204
 205         public FormalParameter copy () {
 206                 if (!ellipsis) {
 207                         var result = new FormalParameter (name, parameter_type, source_reference);
 208                         result.params_array = params_array;
 209                         result.direction = this.direction;
 210                         result.default_expression = this.default_expression;
 211                         return result;
 212                 } else {
 213                         return new FormalParameter.with_ellipsis ();
 214                 }
 215         }
 216
 217         public override bool check (SemanticAnalyzer analyzer) {
 218                 if (checked) {
 219                         return !error;
 220                 }
 221
 222                 checked = true;
 223
 224                 process_attributes ();
 225
 226                 var old_source_file = analyzer.current_source_file;
 227                 var old_symbol = analyzer.current_symbol;
 228
 229                 if (source_reference != null) {
 230                         analyzer.current_source_file = source_reference.file;
 231                 }
 232                 analyzer.current_symbol = parent_symbol;
 233
 234                 if (parameter_type != null) {
 235                         parameter_type.check (analyzer);
 236                 }
 237
 238                 if (!ellipsis) {
 239                         parameter_type.check (analyzer);
 240
 241                         if (params_array && !(parameter_type is ArrayType)) {
 242                                 error = true;
 243                                 Report.error (source_reference, "parameter array expected");
 244                                 return false;
 245                         }
 246
 247                         if (default_expression != null) {
 248                                 default_expression.check (analyzer);
 249                         }
 250                 }
 251
 252                 if (default_expression != null) {
 253                         if (default_expression is NullLiteral
 254                             && !parameter_type.nullable
 255                             && direction != ParameterDirection.OUT) {
 256                                 Report.warning (source_reference, "`null' incompatible with parameter type `%s`".printf (parameter_type.to_string ()));
 257                         }
 258                 }
 259
 260                 if (!ellipsis) {
 261                         // check whether parameter type is at least as accessible as the method
 262                         if (!analyzer.is_type_accessible (this, parameter_type)) {
 263                                 error = true;
 264                                 Report.error (source_reference, "parameter type `%s` is less accessible than method `%s`".printf (parameter_type.to_string (), parent_symbol.get_full_name ()));
 265                         }
 266                 }
 267
 268                 analyzer.current_source_file = old_source_file;
 269                 analyzer.current_symbol = old_symbol;
 270
 271                 return !error;
 272         }
 273 }
 274
 275 public enum Vala.ParameterDirection {
 276         IN,
 277         OUT,
 278         REF
 279 }
 280