Line data    Source code

       1              : /* valagenerictype.vala
       2              :  *
       3              :  * Copyright (C) 2008-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              : 
      25              : /**
      26              :  * The type of a generic type parameter.
      27              :  */
      28      2266328 : public class Vala.GenericType : DataType {
      29              :         /**
      30              :          * The referred generic type parameter.
      31              :          */
      32              :         public weak TypeParameter type_parameter {
      33      1173706 :                 get {
      34      1173706 :                         return (TypeParameter) type_symbol;
      35              :                 }
      36              :         }
      37              : 
      38      2264791 :         GenericDupField? dup_field;
      39      2264791 :         GenericDestroyField? destroy_field;
      40              : 
      41      6794373 :         public GenericType (TypeParameter type_parameter, SourceReference? source_reference = null) {
      42      2264791 :                 base.with_symbol (type_parameter, source_reference);
      43              :         }
      44              : 
      45       760488 :         public override DataType copy () {
      46       760488 :                 var result = new GenericType (type_parameter);
      47       760488 :                 result.source_reference = source_reference;
      48       760488 :                 result.value_owned = value_owned;
      49       760488 :                 result.nullable = nullable;
      50       760488 :                 result.floating_reference = floating_reference;
      51              : 
      52       760488 :                 return result;
      53              :         }
      54              : 
      55       132514 :         public override DataType get_actual_type (DataType? derived_instance_type, List<DataType>? method_type_arguments, CodeNode? node_reference) {
      56       132514 :                 var result = this.copy ();
      57              : 
      58       132514 :                 if (derived_instance_type == null && method_type_arguments == null) {
      59              :                         return result;
      60              :                 }
      61              : 
      62       132514 :                 result = SemanticAnalyzer.get_actual_type (derived_instance_type, method_type_arguments, (GenericType) result, node_reference);
      63       132514 :                 if (!result.is_non_null_simple_type ()) {
      64       131715 :                         result.nullable = result.nullable || nullable;
      65              :                 }
      66              : 
      67              :                 return result;
      68              :         }
      69              : 
      70          101 :         public override DataType? infer_type_argument (TypeParameter type_param, DataType value_type) {
      71          101 :                 if (type_parameter == type_param) {
      72           96 :                         var ret = value_type.copy ();
      73           96 :                         ret.value_owned = true;
      74           96 :                         return ret;
      75              :                 }
      76              : 
      77          101 :                 return null;
      78              :         }
      79              : 
      80           37 :         public override string to_qualified_string (Scope? scope = null) {
      81           37 :                 return "%s%s".printf (type_parameter.name, nullable ? "?" : "");
      82              :         }
      83              : 
      84           32 :         public override Symbol? get_member (string member_name) {
      85           32 :                 if (member_name == "dup") {
      86           32 :                         return get_dup_field ();
      87           16 :                 } else if (member_name == "destroy") {
      88           32 :                         return get_destroy_field ();
      89              :                 }
      90           32 :                 return null;
      91              :         }
      92              : 
      93           16 :         unowned GenericDupField get_dup_field () {
      94           16 :                 if (dup_field == null) {
      95           16 :                         dup_field = new GenericDupField (source_reference);
      96           16 :                         dup_field.access = SymbolAccessibility.PUBLIC;
      97              :                 }
      98           16 :                 return dup_field;
      99              :         }
     100              : 
     101           16 :         unowned GenericDestroyField get_destroy_field () {
     102           16 :                 if (destroy_field == null) {
     103           16 :                         destroy_field = new GenericDestroyField (source_reference);
     104           16 :                         destroy_field.access = SymbolAccessibility.PUBLIC;
     105              :                 }
     106           16 :                 return destroy_field;
     107              :         }
     108              : }