vala/valalambdaexpression.vala

   1 /* valalambdaexpression.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  */
  22
  23 using GLib;
  24 using Gee;
  25
  26 /**
  27  * Represents a lambda expression in the source code. Lambda expressions are
  28  * anonymous methods with implicitly typed parameters.
  29  */
  30 public class Vala.LambdaExpression : Expression {
  31         /**
  32          * The expression body of this lambda expression. Only one of
  33          * expression_body or statement_body may be set.
  34          */
  35         public Expression expression_body { get; set; }
  36
  37         /**
  38          * The statement body of this lambda expression. Only one of
  39          * expression_body or statement_body may be set.
  40          */
  41         public Block statement_body { get; set; }
  42
  43         /**
  44          * The generated method.
  45          */
  46         public Method method { get; set; }
  47
  48         private Gee.List<string> parameters = new ArrayList<string> ();
  49
  50         /**
  51          * Creates a new lambda expression.
  52          *
  53          * @param expression_body  expression body
  54          * @param source_reference reference to source code
  55          * @return                 newly created lambda expression
  56          */
  57         public LambdaExpression (Expression expression_body, SourceReference source_reference) {
  58                 this.source_reference = source_reference;
  59                 this.expression_body = expression_body;
  60         }
  61
  62         /**
  63          * Creates a new lambda expression with statement body.
  64          *
  65          * @param statement_body   statement body
  66          * @param source_reference reference to source code
  67          * @return                 newly created lambda expression
  68          */
  69         public LambdaExpression.with_statement_body (Block statement_body, SourceReference source_reference) {
  70                 this.statement_body = statement_body;
  71                 this.source_reference = source_reference;
  72         }
  73
  74         /**
  75          * Appends implicitly typed parameter.
  76          *
  77          * @param param parameter name
  78          */
  79         public void add_parameter (string param) {
  80                 parameters.add (param);
  81         }
  82
  83         /**
  84          * Returns copy of parameter list.
  85          *
  86          * @return parameter list
  87          */
  88         public Gee.List<string> get_parameters () {
  89                 return new ReadOnlyList<string> (parameters);
  90         }
  91
  92         public override void accept (CodeVisitor visitor) {
  93                 visitor.visit_lambda_expression (this);
  94
  95                 visitor.visit_expression (this);
  96         }
  97
  98         public override void accept_children (CodeVisitor visitor) {
  99                 if (method == null) {
 100                         if (expression_body != null) {
 101                                 expression_body.accept (visitor);
 102                                 visitor.visit_end_full_expression (expression_body);
 103                         } else if (statement_body != null) {
 104                                 statement_body.accept (visitor);
 105                         }
 106                 } else {
 107                         method.accept (visitor);
 108                 }
 109         }
 110
 111         public override bool is_pure () {
 112                 return false;
 113         }
 114
 115         string get_lambda_name (SemanticAnalyzer analyzer) {
 116                 var result = "__lambda%d".printf (analyzer.next_lambda_id);
 117
 118                 analyzer.next_lambda_id++;
 119
 120                 return result;
 121         }
 122
 123         public override bool check (SemanticAnalyzer analyzer) {
 124                 if (checked) {
 125                         return !error;
 126                 }
 127
 128                 checked = true;
 129
 130                 if (!(target_type is DelegateType)) {
 131                         error = true;
 132                         Report.error (source_reference, "lambda expression not allowed in this context");
 133                         return false;
 134                 }
 135
 136                 var cb = (Delegate) ((DelegateType) target_type).delegate_symbol;
 137                 method = new Method (get_lambda_name (analyzer), cb.return_type);
 138                 if (!cb.has_target || !analyzer.is_in_instance_method ()) {
 139                         method.binding = MemberBinding.STATIC;
 140                 }
 141                 method.owner = analyzer.current_symbol.scope;
 142
 143                 var lambda_params = get_parameters ();
 144                 Iterator<string> lambda_param_it = lambda_params.iterator ();
 145                 foreach (FormalParameter cb_param in cb.get_parameters ()) {
 146                         if (!lambda_param_it.next ()) {
 147                                 /* lambda expressions are allowed to have less parameters */
 148                                 break;
 149                         }
 150
 151                         string lambda_param = lambda_param_it.get ();
 152
 153                         var param = new FormalParameter (lambda_param, cb_param.parameter_type);
 154
 155                         method.add_parameter (param);
 156                 }
 157
 158                 if (lambda_param_it.next ()) {
 159                         /* lambda expressions may not expect more parameters */
 160                         error = true;
 161                         Report.error (source_reference, "lambda expression: too many parameters");
 162                         return false;
 163                 }
 164
 165                 foreach (var error_type in cb.get_error_types ()) {
 166                         method.add_error_type (error_type.copy ());
 167                 }
 168
 169                 if (expression_body != null) {
 170                         var block = new Block (source_reference);
 171                         block.scope.parent_scope = method.scope;
 172
 173                         if (method.return_type.data_type != null) {
 174                                 block.add_statement (new ReturnStatement (expression_body, source_reference));
 175                         } else {
 176                                 block.add_statement (new ExpressionStatement (expression_body, source_reference));
 177                         }
 178
 179                         method.body = block;
 180                 } else {
 181                         method.body = statement_body;
 182                 }
 183                 method.body.owner = method.scope;
 184
 185                 /* lambda expressions should be usable like MemberAccess of a method */
 186                 symbol_reference = method;
 187
 188                 if (method == null) {
 189                         if (expression_body != null) {
 190                                 expression_body.check (analyzer);
 191                         } else if (statement_body != null) {
 192                                 statement_body.check (analyzer);
 193                         }
 194                 } else {
 195                         method.check (analyzer);
 196                 }
 197
 198                 value_type = new MethodType (method);
 199
 200                 return !error;
 201         }
 202 }