vala/valacodewriter.vala

   1 /* valacodewriter.vala
   2  *
   3  * Copyright (C) 2006-2009  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 Gee;
  26
  27 /**
  28  * Code visitor generating Vala API file for the public interface.
  29  */
  30 public class Vala.CodeWriter : CodeVisitor {
  31         private CodeContext context;
  32
  33         FileStream stream;
  34
  35         int indent;
  36         /* at begin of line */
  37         bool bol = true;
  38
  39         Scope current_scope;
  40
  41         bool dump_tree;
  42
  43         public CodeWriter (bool dump_tree = false) {
  44                 this.dump_tree = dump_tree;
  45         }
  46
  47         /**
  48          * Writes the public interface of the specified code context into the
  49          * specified file.
  50          *
  51          * @param context  a code context
  52          * @param filename a relative or absolute filename
  53          */
  54         public void write_file (CodeContext context, string filename) {
  55                 this.context = context;
  56
  57                 stream = FileStream.open (filename, "w");
  58
  59                 write_string ("/* %s generated by %s, do not modify. */".printf (Path.get_basename (filename), Environment.get_prgname ()));
  60                 write_newline ();
  61                 write_newline ();
  62
  63                 current_scope = context.root.scope;
  64
  65                 context.accept (this);
  66
  67                 current_scope = null;
  68
  69                 stream = null;
  70         }
  71
  72         public override void visit_namespace (Namespace ns) {
  73                 if (ns.external_package) {
  74                         return;
  75                 }
  76
  77                 if (ns.name == null)  {
  78                         ns.accept_children (this);
  79                         return;
  80                 }
  81
  82                 write_indent ();
  83                 write_string ("[CCode (cprefix = \"%s\", lower_case_cprefix = \"%s\")]".printf (ns.get_cprefix (), ns.get_lower_case_cprefix ()));
  84                 write_newline ();
  85
  86                 write_indent ();
  87                 write_string ("namespace ");
  88                 write_identifier (ns.name);
  89                 write_begin_block ();
  90
  91                 current_scope = ns.scope;
  92
  93                 visit_sorted (ns.get_namespaces ());
  94                 visit_sorted (ns.get_classes ());
  95                 visit_sorted (ns.get_interfaces ());
  96                 visit_sorted (ns.get_structs ());
  97                 visit_sorted (ns.get_enums ());
  98                 visit_sorted (ns.get_error_domains ());
  99                 visit_sorted (ns.get_delegates ());
 100                 visit_sorted (ns.get_fields ());
 101                 visit_sorted (ns.get_constants ());
 102                 visit_sorted (ns.get_methods ());
 103
 104                 current_scope = current_scope.parent_scope;
 105
 106                 write_end_block ();
 107                 write_newline ();
 108         }
 109
 110         public override void visit_class (Class cl) {
 111                 if (cl.external_package) {
 112                         return;
 113                 }
 114
 115                 if (!check_accessibility (cl)) {
 116                         return;
 117                 }
 118
 119                 if (cl.is_compact) {
 120                         write_indent ();
 121                         write_string ("[Compact]");
 122                         write_newline ();
 123                 }
 124
 125                 if (cl.is_immutable) {
 126                         write_indent ();
 127                         write_string ("[Immutable]");
 128                         write_newline ();
 129                 }
 130
 131                 write_indent ();
 132
 133                 write_string ("[CCode (");
 134
 135                 if (cl.is_reference_counting ()) {
 136                         if (cl.base_class == null || cl.base_class.get_ref_function () == null || cl.base_class.get_ref_function () != cl.get_ref_function ()) {
 137                                 write_string ("ref_function = \"%s\", ".printf (cl.get_ref_function ()));
 138                                 if (cl.ref_function_void) {
 139                                         write_string ("ref_function_void = true, ");
 140                                 }
 141                         }
 142                         if (cl.base_class == null || cl.base_class.get_unref_function () == null || cl.base_class.get_unref_function () != cl.get_unref_function ()) {
 143                                 write_string ("unref_function = \"%s\", ".printf (cl.get_unref_function ()));
 144                         }
 145                 } else {
 146                         if (cl.get_dup_function () != null) {
 147                                 write_string ("copy_function = \"%s\", ".printf (cl.get_dup_function ()));
 148                         }
 149                         if (cl.get_free_function () != cl.get_default_free_function ()) {
 150                                 write_string ("free_function = \"%s\", ".printf (cl.get_free_function ()));
 151                         }
 152                 }
 153
 154                 if (cl.get_cname () != cl.get_default_cname ()) {
 155                         write_string ("cname = \"%s\", ".printf (cl.get_cname ()));
 156                 }
 157
 158                 if (cl.type_check_function != null) {
 159                         write_string ("type_check_function = \"%s\", ".printf (cl.type_check_function ));
 160                 }
 161
 162                 if (cl.is_compact && cl.get_type_id () != "G_TYPE_POINTER") {
 163                         write_string ("type_id = \"%s\", ".printf (cl.get_type_id ()));
 164                 }
 165
 166                 if (cl.get_param_spec_function () != null
 167                     && (cl.base_class == null || cl.get_param_spec_function () != cl.base_class.get_param_spec_function ())) {
 168                         write_string ("param_spec_function = \"%s\", ".printf (cl.get_param_spec_function ()));
 169                 }
 170
 171                 bool first = true;
 172                 string cheaders = "";
 173                 foreach (string cheader in cl.get_cheader_filenames ()) {
 174                         if (first) {
 175                                 cheaders = cheader;
 176                                 first = false;
 177                         } else {
 178                                 cheaders = "%s,%s".printf (cheaders, cheader);
 179                         }
 180                 }
 181                 write_string ("cheader_filename = \"%s\")]".printf (cheaders));
 182                 write_newline ();
 183
 184                 write_indent ();
 185                 write_accessibility (cl);
 186                 if (cl.is_abstract) {
 187                         write_string ("abstract ");
 188                 }
 189                 write_string ("class ");
 190                 write_identifier (cl.name);
 191
 192                 var type_params = cl.get_type_parameters ();
 193                 if (type_params.size > 0) {
 194                         write_string ("<");
 195                         first = true;
 196                         foreach (TypeParameter type_param in type_params) {
 197                                 if (first) {
 198                                         first = false;
 199                                 } else {
 200                                         write_string (",");
 201                                 }
 202                                 write_identifier (type_param.name);
 203                         }
 204                         write_string (">");
 205                 }
 206
 207                 var base_types = cl.get_base_types ();
 208                 if (base_types.size > 0) {
 209                         write_string (" : ");
 210
 211                         first = true;
 212                         foreach (DataType base_type in base_types) {
 213                                 if (!first) {
 214                                         write_string (", ");
 215                                 } else {
 216                                         first = false;
 217                                 }
 218                                 write_type (base_type);
 219                         }
 220                 }
 221                 write_begin_block ();
 222
 223                 current_scope = cl.scope;
 224
 225                 visit_sorted (cl.get_classes ());
 226                 visit_sorted (cl.get_structs ());
 227                 visit_sorted (cl.get_enums ());
 228                 visit_sorted (cl.get_delegates ());
 229                 visit_sorted (cl.get_fields ());
 230                 visit_sorted (cl.get_constants ());
 231                 visit_sorted (cl.get_methods ());
 232                 visit_sorted (cl.get_properties ());
 233                 visit_sorted (cl.get_signals ());
 234
 235                 current_scope = current_scope.parent_scope;
 236
 237                 write_end_block ();
 238                 write_newline ();
 239         }
 240
 241         void visit_sorted (Gee.List<Symbol> symbols) {
 242                 var sorted_symbols = new Gee.ArrayList<Symbol> ();
 243                 foreach (Symbol sym in symbols) {
 244                         int left = 0;
 245                         int right = sorted_symbols.size - 1;
 246                         if (left > right || sym.name < sorted_symbols[left].name) {
 247                                 sorted_symbols.insert (0, sym);
 248                         } else if (sym.name > sorted_symbols[right].name) {
 249                                 sorted_symbols.add (sym);
 250                         } else {
 251                                 while (right - left > 1) {
 252                                         int i = (right + left) / 2;
 253                                         if (sym.name > sorted_symbols[i].name) {
 254                                                 left = i;
 255                                         } else {
 256                                                 right = i;
 257                                         }
 258                                 }
 259                                 sorted_symbols.insert (left + 1, sym);
 260                         }
 261                 }
 262                 foreach (Symbol sym in sorted_symbols) {
 263                         sym.accept (this);
 264                 }
 265         }
 266
 267         public override void visit_struct (Struct st) {
 268                 if (st.external_package) {
 269                         return;
 270                 }
 271
 272                 if (!check_accessibility (st)) {
 273                         return;
 274                 }
 275
 276                 write_indent ();
 277
 278                 write_string ("[CCode (");
 279
 280                 if (st.get_cname () != st.get_default_cname ()) {
 281                         write_string ("cname = \"%s\", ".printf (st.get_cname ()));
 282                 }
 283
 284                 if (!st.is_simple_type () && st.get_type_id () != "G_TYPE_POINTER") {
 285                         write_string ("type_id = \"%s\", ".printf (st.get_type_id ()));
 286                 }
 287
 288                 if (!st.use_const) {
 289                         write_string ("use_const = false, ");
 290                 }
 291
 292                 bool first = true;
 293                 string cheaders = "";
 294                 foreach (string cheader in st.get_cheader_filenames ()) {
 295                         if (first) {
 296                                 cheaders = cheader;
 297                                 first = false;
 298                         } else {
 299                                 cheaders = "%s,%s".printf (cheaders, cheader);
 300                         }
 301                 }
 302                 write_string ("cheader_filename = \"%s\")]".printf (cheaders));
 303                 write_newline ();
 304
 305                 if (st.is_simple_type ()) {
 306                         write_indent ();
 307                         write_string ("[SimpleType]");
 308                         write_newline ();
 309                 }
 310
 311                 if (st.is_integer_type ()) {
 312                         write_indent ();
 313                         write_string ("[IntegerType (rank = %d)]".printf (st.get_rank ()));
 314                         write_newline ();
 315                 }
 316
 317                 if (st.is_floating_type ()) {
 318                         write_indent ();
 319                         write_string ("[FloatingType (rank = %d)]".printf (st.get_rank ()));
 320                         write_newline ();
 321                 }
 322
 323                 write_indent ();
 324                 write_accessibility (st);
 325                 write_string ("struct ");
 326                 write_identifier (st.name);
 327
 328                 if (st.base_type != null) {
 329                         write_string (" : ");
 330                         write_type (st.base_type);
 331                 }
 332
 333                 write_begin_block ();
 334
 335                 current_scope = st.scope;
 336
 337                 foreach (Field field in st.get_fields ()) {
 338                         field.accept (this);
 339                 }
 340                 visit_sorted (st.get_constants ());
 341                 visit_sorted (st.get_methods ());
 342
 343                 current_scope = current_scope.parent_scope;
 344
 345                 write_end_block ();
 346                 write_newline ();
 347         }
 348
 349         public override void visit_interface (Interface iface) {
 350                 if (iface.external_package) {
 351                         return;
 352                 }
 353
 354                 if (!check_accessibility (iface)) {
 355                         return;
 356                 }
 357
 358                 write_indent ();
 359
 360                 bool first = true;
 361                 string cheaders = "";
 362                 foreach (string cheader in iface.get_cheader_filenames ()) {
 363                         if (first) {
 364                                 cheaders = cheader;
 365                                 first = false;
 366                         } else {
 367                                 cheaders = "%s,%s".printf (cheaders, cheader);
 368                         }
 369                 }
 370                 write_string ("[CCode (cheader_filename = \"%s\"".printf (cheaders));
 371                 if (iface.get_lower_case_csuffix () != iface.get_default_lower_case_csuffix ())
 372                         write_string (", lower_case_csuffix = \"%s\"".printf (iface.get_lower_case_csuffix ()));
 373
 374                 write_string (")]");
 375                 write_newline ();
 376
 377                 write_indent ();
 378                 write_accessibility (iface);
 379                 write_string ("interface ");
 380                 write_identifier (iface.name);
 381
 382                 var type_params = iface.get_type_parameters ();
 383                 if (type_params.size > 0) {
 384                         write_string ("<");
 385                         first = true;
 386                         foreach (TypeParameter type_param in type_params) {
 387                                 if (first) {
 388                                         first = false;
 389                                 } else {
 390                                         write_string (",");
 391                                 }
 392                                 write_identifier (type_param.name);
 393                         }
 394                         write_string (">");
 395                 }
 396
 397                 var prerequisites = iface.get_prerequisites ();
 398                 if (prerequisites.size > 0) {
 399                         write_string (" : ");
 400
 401                         first = true;
 402                         foreach (DataType prerequisite in prerequisites) {
 403                                 if (!first) {
 404                                         write_string (", ");
 405                                 } else {
 406                                         first = false;
 407                                 }
 408                                 write_type (prerequisite);
 409                         }
 410                 }
 411                 write_begin_block ();
 412
 413                 current_scope = iface.scope;
 414
 415                 visit_sorted (iface.get_classes ());
 416                 visit_sorted (iface.get_structs ());
 417                 visit_sorted (iface.get_enums ());
 418                 visit_sorted (iface.get_delegates ());
 419                 visit_sorted (iface.get_fields ());
 420                 visit_sorted (iface.get_methods ());
 421                 visit_sorted (iface.get_properties ());
 422                 visit_sorted (iface.get_signals ());
 423
 424                 current_scope = current_scope.parent_scope;
 425
 426                 write_end_block ();
 427                 write_newline ();
 428         }
 429
 430         public override void visit_enum (Enum en) {
 431                 if (en.external_package) {
 432                         return;
 433                 }
 434
 435                 if (!check_accessibility (en)) {
 436                         return;
 437                 }
 438
 439                 write_indent ();
 440
 441                 bool first = true;
 442                 string cheaders = "";
 443                 foreach (string cheader in en.get_cheader_filenames ()) {
 444                         if (first) {
 445                                 cheaders = cheader;
 446                                 first = false;
 447                         } else {
 448                                 cheaders = "%s,%s".printf (cheaders, cheader);
 449                         }
 450                 }
 451
 452                 write_string ("[CCode (cprefix = \"%s\", ".printf (en.get_cprefix ()));
 453
 454                 if (!en.has_type_id) {
 455                         write_string ("has_type_id = \"%d\", ".printf (en.has_type_id ? 1 : 0));
 456                 }
 457
 458                 write_string ("cheader_filename = \"%s\")]".printf (cheaders));
 459
 460                 if (en.is_flags) {
 461                         write_indent ();
 462                         write_string ("[Flags]");
 463                 }
 464
 465                 write_indent ();
 466                 write_accessibility (en);
 467                 write_string ("enum ");
 468                 write_identifier (en.name);
 469                 write_begin_block ();
 470
 471                 first = true;
 472                 foreach (EnumValue ev in en.get_values ()) {
 473                         if (first) {
 474                                 first = false;
 475                         } else {
 476                                 write_string (",");
 477                                 write_newline ();
 478                         }
 479
 480                         if (ev.get_cname () != ev.get_default_cname ()) {
 481                                 write_indent ();
 482                                 write_string ("[CCode (cname = \"%s\")]".printf (ev.get_cname ()));
 483                         }
 484                         write_indent ();
 485                         write_identifier (ev.name);
 486                 }
 487
 488                 if (!first) {
 489                         if (en.get_methods ().size > 0) {
 490                                 write_string (";");
 491                         }
 492                         write_newline ();
 493                 }
 494
 495                 current_scope = en.scope;
 496                 foreach (Method m in en.get_methods ()) {
 497                         m.accept (this);
 498                 }
 499                 current_scope = current_scope.parent_scope;
 500
 501                 write_end_block ();
 502                 write_newline ();
 503         }
 504
 505         public override void visit_error_domain (ErrorDomain edomain) {
 506                 if (edomain.external_package) {
 507                         return;
 508                 }
 509
 510                 if (!check_accessibility (edomain)) {
 511                         return;
 512                 }
 513
 514                 write_indent ();
 515
 516                 var first = true;
 517                 string cheaders = "";
 518                 foreach (string cheader in edomain.get_cheader_filenames ()) {
 519                         if (first) {
 520                                 cheaders = cheader;
 521                                 first = false;
 522                         } else {
 523                                 cheaders = "%s,%s".printf (cheaders, cheader);
 524                         }
 525                 }
 526                 write_string ("[CCode (cprefix = \"%s\", cheader_filename = \"%s\")]".printf (edomain.get_cprefix (), cheaders));
 527
 528                 write_indent ();
 529                 write_accessibility (edomain);
 530                 write_string ("errordomain ");
 531                 write_identifier (edomain.name);
 532                 write_begin_block ();
 533
 534                 edomain.accept_children (this);
 535
 536                 write_end_block ();
 537                 write_newline ();
 538         }
 539
 540         public override void visit_error_code (ErrorCode ecode) {
 541                 write_indent ();
 542                 write_identifier (ecode.name);
 543                 write_string (",");
 544                 write_newline ();
 545         }
 546
 547         public override void visit_constant (Constant c) {
 548                 if (c.external_package) {
 549                         return;
 550                 }
 551
 552                 if (!check_accessibility (c)) {
 553                         return;
 554                 }
 555
 556                 bool custom_cname = (c.get_cname () != c.get_default_cname ());
 557                 bool custom_cheaders = (c.parent_symbol is Namespace);
 558                 if (custom_cname || custom_cheaders) {
 559                         write_indent ();
 560                         write_string ("[CCode (");
 561
 562                         if (custom_cname) {
 563                                 write_string ("cname = \"%s\"".printf (c.get_cname ()));
 564                         }
 565
 566                         if (custom_cheaders) {
 567                                 if (custom_cname) {
 568                                         write_string (", ");
 569                                 }
 570
 571                                 bool first = true;
 572                                 string cheaders = "";
 573                                 foreach (string cheader in c.get_cheader_filenames ()) {
 574                                         if (first) {
 575                                                 cheaders = cheader;
 576                                                 first = false;
 577                                         } else {
 578                                                 cheaders = "%s,%s".printf (cheaders, cheader);
 579                                         }
 580                                 }
 581                                 write_string ("cheader_filename = \"%s\"".printf (cheaders));
 582                         }
 583
 584                         write_string (")]");
 585                 }
 586
 587                 write_indent ();
 588                 write_accessibility (c);
 589                 write_string ("const ");
 590
 591                 write_type (c.type_reference);
 592
 593                 write_string (" ");
 594                 write_identifier (c.name);
 595                 write_string (";");
 596                 write_newline ();
 597         }
 598
 599         public override void visit_field (Field f) {
 600                 if (f.external_package) {
 601                         return;
 602                 }
 603
 604                 if (!check_accessibility (f)) {
 605                         return;
 606                 }
 607
 608                 bool custom_cname = (f.get_cname () != f.get_default_cname ());
 609                 bool custom_ctype = (f.get_ctype () != null);
 610                 bool custom_cheaders = (f.parent_symbol is Namespace);
 611                 if (custom_cname || custom_ctype || custom_cheaders || (f.no_array_length && f.field_type is ArrayType)) {
 612                         write_indent ();
 613                         write_string ("[CCode (");
 614
 615                         if (custom_cname) {
 616                                 write_string ("cname = \"%s\"".printf (f.get_cname ()));
 617                         }
 618
 619                         if (custom_ctype) {
 620                                 if (custom_cname) {
 621                                         write_string (", ");
 622                                 }
 623
 624                                 write_string ("type = \"%s\"".printf (f.get_ctype ()));
 625                         }
 626
 627                         if (custom_cheaders) {
 628                                 if (custom_cname || custom_ctype) {
 629                                         write_string (", ");
 630                                 }
 631
 632                                 bool first = true;
 633                                 string cheaders = "";
 634                                 foreach (string cheader in f.get_cheader_filenames ()) {
 635                                         if (first) {
 636                                                 cheaders = cheader;
 637                                                 first = false;
 638                                         } else {
 639                                                 cheaders = "%s,%s".printf (cheaders, cheader);
 640                                         }
 641                                 }
 642                                 write_string ("cheader_filename = \"%s\"".printf (cheaders));
 643                         }
 644
 645                         if (f.no_array_length && f.field_type is ArrayType) {
 646                                 if (custom_cname || custom_ctype || custom_cheaders) {
 647                                         write_string (", ");
 648                                 }
 649
 650                                 write_string ("array_length = false");
 651                         }
 652
 653                         write_string (")]");
 654                 }
 655
 656                 write_indent ();
 657                 write_accessibility (f);
 658
 659                 if (f.binding == MemberBinding.STATIC) {
 660                         write_string ("static ");
 661                 } else if (f.binding == MemberBinding.CLASS) {
 662                         write_string ("class ");
 663                 }
 664
 665                 if (is_weak (f.field_type)) {
 666                         write_string ("weak ");
 667                 }
 668
 669                 write_type (f.field_type);
 670
 671                 write_string (" ");
 672                 write_identifier (f.name);
 673                 write_string (";");
 674                 write_newline ();
 675         }
 676
 677         private void write_error_domains (Gee.List<DataType> error_domains) {
 678                 if (error_domains.size > 0) {
 679                         write_string (" throws ");
 680
 681                         bool first = true;
 682                         foreach (DataType type in error_domains) {
 683                                 if (!first) {
 684                                         write_string (", ");
 685                                 } else {
 686                                         first = false;
 687                                 }
 688
 689                                 write_type (type);
 690                         }
 691                 }
 692         }
 693
 694         // equality comparison with 3 digit precision
 695         private bool float_equal (double d1, double d2) {
 696                 return ((int) (d1 * 1000)) == ((int) (d2 * 1000));
 697         }
 698
 699         private void write_params (Gee.List<FormalParameter> params) {
 700                 write_string ("(");
 701
 702                 int i = 1;
 703                 foreach (FormalParameter param in params) {
 704                         if (i > 1) {
 705                                 write_string (", ");
 706                         }
 707
 708                         if (param.ellipsis) {
 709                                 write_string ("...");
 710                                 continue;
 711                         }
 712
 713
 714                         var ccode_params = new StringBuilder ();
 715                         var separator = "";
 716
 717                         if (param.ctype != null) {
 718                                 ccode_params.append_printf ("%stype = \"%s\"", separator, param.ctype);
 719                                 separator = ", ";
 720                         }
 721                         if (param.no_array_length && param.parameter_type is ArrayType) {
 722                                 ccode_params.append_printf ("%sarray_length = false", separator);
 723                                 separator = ", ";
 724                         }
 725                         if (!float_equal (param.carray_length_parameter_position, i + 0.1)) {
 726                                 ccode_params.append_printf ("%sarray_length_pos = %g", separator, param.carray_length_parameter_position);
 727                                 separator = ", ";
 728                         }
 729                         if (!float_equal (param.cdelegate_target_parameter_position, i + 0.1)) {
 730                                 ccode_params.append_printf ("%sdelegate_target_pos = %g", separator, param.cdelegate_target_parameter_position);
 731                                 separator = ", ";
 732                         }
 733                         if (param.async_only) {
 734                                 ccode_params.append_printf ("%sasync_only = true", separator);
 735                                 separator = ", ";
 736                         }
 737
 738                         if (ccode_params.len > 0) {
 739                                 write_string ("[CCode (%s)] ".printf (ccode_params.str));
 740                         }
 741
 742                         if (param.params_array) {
 743                                 write_string ("params ");
 744                         }
 745
 746                         if (param.direction == ParameterDirection.IN) {
 747                                 if (param.parameter_type.value_owned) {
 748                                         write_string ("owned ");
 749                                 }
 750                         } else {
 751                                 if (param.direction == ParameterDirection.REF) {
 752                                         write_string ("ref ");
 753                                 } else if (param.direction == ParameterDirection.OUT) {
 754                                         write_string ("out ");
 755                                 }
 756                                 if (is_weak (param.parameter_type)) {
 757                                         write_string ("unowned ");
 758                                 }
 759                         }
 760
 761                         write_type (param.parameter_type);
 762
 763                         write_string (" ");
 764                         write_identifier (param.name);
 765
 766                         if (param.default_expression != null) {
 767                                 write_string (" = ");
 768                                 write_string (param.default_expression.to_string ());
 769                         }
 770
 771                         i++;
 772                 }
 773
 774                 write_string (")");
 775         }
 776
 777         public override void visit_delegate (Delegate cb) {
 778                 if (cb.external_package) {
 779                         return;
 780                 }
 781
 782                 if (!check_accessibility (cb)) {
 783                         return;
 784                 }
 785
 786                 write_indent ();
 787
 788                 var first = true;
 789                 string cheaders = "";
 790                 foreach (string cheader in cb.get_cheader_filenames ()) {
 791                         if (first) {
 792                                 cheaders = cheader;
 793                                 first = false;
 794                         } else {
 795                                 cheaders = "%s,%s".printf (cheaders, cheader);
 796                         }
 797                 }
 798                 write_string ("[CCode (cheader_filename = \"%s\")]".printf (cheaders));
 799
 800                 write_indent ();
 801
 802                 write_accessibility (cb);
 803                 if (!cb.has_target) {
 804                         write_string ("static ");
 805                 }
 806                 write_string ("delegate ");
 807
 808                 write_return_type (cb.return_type);
 809
 810                 write_string (" ");
 811                 write_identifier (cb.name);
 812
 813                 write_string (" ");
 814
 815                 write_params (cb.get_parameters ());
 816
 817                 write_string (";");
 818
 819                 write_newline ();
 820         }
 821
 822         public override void visit_method (Method m) {
 823                 if (m.external_package) {
 824                         return;
 825                 }
 826
 827                 // don't write interface implementation unless it's an abstract or virtual method
 828                 if (!check_accessibility (m) || (m.base_interface_method != null && !m.is_abstract && !m.is_virtual)) {
 829                         if (!dump_tree) {
 830                                 return;
 831                         }
 832                 }
 833
 834                 if (m.get_attribute ("NoWrapper") != null) {
 835                         write_indent ();
 836                         write_string ("[NoWrapper]");
 837                 }
 838                 if (m.returns_modified_pointer) {
 839                         write_indent ();
 840                         write_string ("[ReturnsModifiedPointer]");
 841                 }
 842
 843                 var ccode_params = new StringBuilder ();
 844                 var separator = "";
 845
 846                 if (m.get_cname () != m.get_default_cname ()) {
 847                         ccode_params.append_printf ("%scname = \"%s\"", separator, m.get_cname ());
 848                         separator = ", ";
 849                 }
 850                 if (m.parent_symbol is Namespace) {
 851                         bool first = true;
 852                         string cheaders = "";
 853                         foreach (string cheader in m.get_cheader_filenames ()) {
 854                                 if (first) {
 855                                         cheaders = cheader;
 856                                         first = false;
 857                                 } else {
 858                                         cheaders = "%s,%s".printf (cheaders, cheader);
 859                                 }
 860                         }
 861                         ccode_params.append_printf ("%scheader_filename = \"%s\"", separator, cheaders);
 862                         separator = ", ";
 863                 }
 864                 if (!float_equal (m.cinstance_parameter_position, 0)) {
 865                         ccode_params.append_printf ("%sinstance_pos = %g", separator, m.cinstance_parameter_position);
 866                         separator = ", ";
 867                 }
 868                 if (m.no_array_length && m.return_type is ArrayType) {
 869                         ccode_params.append_printf ("%sarray_length = false", separator);
 870                         separator = ", ";
 871                 }
 872                 if (!float_equal (m.carray_length_parameter_position, -3)) {
 873                         ccode_params.append_printf ("%sarray_length_pos = %g", separator, m.carray_length_parameter_position);
 874                         separator = ", ";
 875                 }
 876                 if (m.array_null_terminated && m.return_type is ArrayType) {
 877                         ccode_params.append_printf ("%sarray_null_terminated = true", separator);
 878                         separator = ", ";
 879                 }
 880                 if (!float_equal (m.cdelegate_target_parameter_position, -3)) {
 881                         ccode_params.append_printf ("%sdelegate_target_pos = %g", separator, m.cdelegate_target_parameter_position);
 882                         separator = ", ";
 883                 }
 884                 if (m.vfunc_name != m.name) {
 885                         ccode_params.append_printf ("%svfunc_name = \"%s\"", separator, m.vfunc_name);
 886                         separator = ", ";
 887                 }
 888                 if (m.sentinel != m.DEFAULT_SENTINEL) {
 889                         ccode_params.append_printf ("%ssentinel = \"%s\"", separator, m.sentinel);
 890                         separator = ", ";
 891                 }
 892                 if (m is CreationMethod && ((CreationMethod)m).custom_return_type_cname != null) {
 893                         ccode_params.append_printf ("%stype = \"%s\"", separator, ((CreationMethod)m).custom_return_type_cname);
 894                         separator = ", ";
 895                 }
 896                 if (m is CreationMethod && !m.has_construct_function) {
 897                         ccode_params.append_printf ("%shas_construct_function = false", separator);
 898                         separator = ", ";
 899                 }
 900
 901                 if (ccode_params.len > 0) {
 902                         write_indent ();
 903                         write_string ("[CCode (%s)]".printf (ccode_params.str));
 904                 }
 905
 906                 write_indent ();
 907                 write_accessibility (m);
 908
 909                 if (m is CreationMethod) {
 910                         var datatype = (TypeSymbol) m.parent_symbol;
 911                         write_identifier (datatype.name);
 912                         if (m.name != "new") {
 913                                 write_string (".");
 914                                 write_identifier (m.name);
 915                         }
 916                         write_string (" ");
 917                 } else if (m.binding == MemberBinding.STATIC) {
 918                         write_string ("static ");
 919                 } else if (m.binding == MemberBinding.CLASS) {
 920                         write_string ("class ");
 921                 } else if (m.is_abstract) {
 922                         write_string ("abstract ");
 923                 } else if (m.is_virtual) {
 924                         write_string ("virtual ");
 925                 } else if (m.overrides) {
 926                         write_string ("override ");
 927                 }
 928
 929                 if (!(m is CreationMethod)) {
 930                         write_return_type (m.return_type);
 931                         write_string (" ");
 932
 933                         write_identifier (m.name);
 934                         write_string (" ");
 935                 }
 936
 937                 write_params (m.get_parameters ());
 938                 write_error_domains (m.get_error_types ());
 939
 940                 write_code_block (m.body);
 941
 942                 write_newline ();
 943         }
 944
 945         public override void visit_creation_method (CreationMethod m) {
 946                 visit_method (m);
 947         }
 948
 949         public override void visit_property (Property prop) {
 950                 if (!check_accessibility (prop) || (prop.base_interface_property != null && !prop.is_abstract && !prop.is_virtual)) {
 951                         return;
 952                 }
 953
 954                 if (prop.no_accessor_method) {
 955                         write_indent ();
 956                         write_string ("[NoAccessorMethod]");
 957                 }
 958
 959                 write_indent ();
 960                 write_accessibility (prop);
 961
 962                 if (prop.binding == MemberBinding.STATIC) {
 963                         write_string ("static ");
 964                 } else  if (prop.is_abstract) {
 965                         write_string ("abstract ");
 966                 } else if (prop.is_virtual) {
 967                         write_string ("virtual ");
 968                 } else if (prop.overrides) {
 969                         write_string ("override ");
 970                 }
 971
 972                 write_type (prop.property_type);
 973
 974                 write_string (" ");
 975                 write_identifier (prop.name);
 976                 write_string (" {");
 977                 if (prop.get_accessor != null) {
 978                         if (prop.get_accessor.value_type.is_disposable ()) {
 979                                 write_string (" owned");
 980                         }
 981
 982                         write_string (" get");
 983                         write_code_block (prop.get_accessor.body);
 984                 }
 985                 if (prop.set_accessor != null) {
 986                         if (prop.set_accessor.value_type.value_owned) {
 987                                 write_string ("owned ");
 988                         }
 989
 990                         if (prop.set_accessor.writable) {
 991                                 write_string (" set");
 992                         }
 993                         if (prop.set_accessor.construction) {
 994                                 write_string (" construct");
 995                         }
 996                         write_code_block (prop.set_accessor.body);
 997                 }
 998                 write_string (" }");
 999                 write_newline ();
1000         }
1001
1002         public override void visit_signal (Signal sig) {
1003                 if (!check_accessibility (sig)) {
1004                         return;
1005                 }
1006
1007                 if (sig.has_emitter) {
1008                         write_indent ();
1009                         write_string ("[HasEmitter]");
1010                 }
1011
1012                 write_indent ();
1013                 write_accessibility (sig);
1014
1015                 if (sig.is_virtual) {
1016                         write_string ("virtual ");
1017                 }
1018
1019                 write_string ("signal ");
1020
1021                 write_return_type (sig.return_type);
1022
1023                 write_string (" ");
1024                 write_identifier (sig.name);
1025
1026                 write_string (" ");
1027
1028                 write_params (sig.get_parameters ());
1029
1030                 write_string (";");
1031
1032                 write_newline ();
1033         }
1034
1035         public override void visit_block (Block b) {
1036                 write_begin_block ();
1037
1038                 foreach (Statement stmt in b.get_statements ()) {
1039                         stmt.accept (this);
1040                 }
1041
1042                 write_end_block ();
1043         }
1044
1045         public override void visit_empty_statement (EmptyStatement stmt) {
1046         }
1047
1048         public override void visit_declaration_statement (DeclarationStatement stmt) {
1049                 write_indent ();
1050                 stmt.declaration.accept (this);
1051                 write_string (";");
1052                 write_newline ();
1053         }
1054
1055         public override void visit_local_variable (LocalVariable local) {
1056                 write_type (local.variable_type);
1057                 write_string (" ");
1058                 write_identifier (local.name);
1059                 if (local.initializer != null) {
1060                         write_string (" = ");
1061                         local.initializer.accept (this);
1062                 }
1063         }
1064
1065         public override void visit_initializer_list (InitializerList list) {
1066                 write_string ("{");
1067
1068                 bool first = true;
1069                 foreach (Expression initializer in list.get_initializers ()) {
1070                         if (!first) {
1071                                 write_string (", ");
1072                         } else {
1073                                 write_string (" ");
1074                         }
1075                         first = false;
1076                         initializer.accept (this);
1077                 }
1078                 write_string (" }");
1079         }
1080
1081         public override void visit_expression_statement (ExpressionStatement stmt) {
1082                 write_indent ();
1083                 stmt.expression.accept (this);
1084                 write_string (";");
1085                 write_newline ();
1086         }
1087
1088         public override void visit_if_statement (IfStatement stmt) {
1089                 write_indent ();
1090                 write_string ("if (");
1091                 stmt.condition.accept (this);
1092                 write_string (")");
1093                 stmt.true_statement.accept (this);
1094                 if (stmt.false_statement != null) {
1095                         write_string (" else");
1096                         stmt.false_statement.accept (this);
1097                 }
1098                 write_newline ();
1099         }
1100
1101         public override void visit_switch_statement (SwitchStatement stmt) {
1102                 write_indent ();
1103                 write_string ("switch (");
1104                 stmt.expression.accept (this);
1105                 write_string (") {");
1106                 write_newline ();
1107
1108                 foreach (SwitchSection section in stmt.get_sections ()) {
1109                         section.accept (this);
1110                 }
1111
1112                 write_indent ();
1113                 write_string ("}");
1114                 write_newline ();
1115         }
1116
1117         public override void visit_switch_section (SwitchSection section) {
1118                 foreach (SwitchLabel label in section.get_labels ()) {
1119                         label.accept (this);
1120                 }
1121
1122                 visit_block (section);
1123         }
1124
1125         public override void visit_switch_label (SwitchLabel label) {
1126                 if (label.expression != null) {
1127                         write_indent ();
1128                         write_string ("case ");
1129                         label.expression.accept (this);
1130                         write_string (":");
1131                         write_newline ();
1132                 } else {
1133                         write_indent ();
1134                         write_string ("default:");
1135                         write_newline ();
1136                 }
1137         }
1138
1139         public override void visit_while_statement (WhileStatement stmt) {
1140                 write_indent ();
1141                 write_string ("while (");
1142                 stmt.condition.accept (this);
1143                 write_string (")");
1144                 stmt.body.accept (this);
1145                 write_newline ();
1146         }
1147
1148         public override void visit_do_statement (DoStatement stmt) {
1149                 write_indent ();
1150                 write_string ("do");
1151                 stmt.body.accept (this);
1152                 write_string ("while (");
1153                 stmt.condition.accept (this);
1154                 write_string (");");
1155                 write_newline ();
1156         }
1157
1158         public override void visit_for_statement (ForStatement stmt) {
1159                 write_indent ();
1160                 write_string ("for (");
1161
1162                 bool first = true;
1163                 foreach (Expression initializer in stmt.get_initializer ()) {
1164                         if (!first) {
1165                                 write_string (", ");
1166                         }
1167                         first = false;
1168                         initializer.accept (this);
1169                 }
1170                 write_string ("; ");
1171
1172                 stmt.condition.accept (this);
1173                 write_string ("; ");
1174
1175                 first = true;
1176                 foreach (Expression iterator in stmt.get_iterator ()) {
1177                         if (!first) {
1178                                 write_string (", ");
1179                         }
1180                         first = false;
1181                         iterator.accept (this);
1182                 }
1183
1184                 write_string (")");
1185                 stmt.body.accept (this);
1186                 write_newline ();
1187         }
1188
1189         public override void visit_foreach_statement (ForeachStatement stmt) {
1190         }
1191
1192         public override void visit_break_statement (BreakStatement stmt) {
1193                 write_indent ();
1194                 write_string ("break;");
1195                 write_newline ();
1196         }
1197
1198         public override void visit_continue_statement (ContinueStatement stmt) {
1199                 write_indent ();
1200                 write_string ("continue;");
1201                 write_newline ();
1202         }
1203
1204         public override void visit_return_statement (ReturnStatement stmt) {
1205                 write_indent ();
1206                 write_string ("return");
1207                 if (stmt.return_expression != null) {
1208                         write_string (" ");
1209                         stmt.return_expression.accept (this);
1210                 }
1211                 write_string (";");
1212                 write_newline ();
1213         }
1214
1215         public override void visit_yield_statement (YieldStatement y) {
1216                 write_indent ();
1217                 write_string ("yield");
1218                 if (y.yield_expression != null) {
1219                         write_string (" ");
1220                         y.yield_expression.accept (this);
1221                 }
1222                 write_string (";");
1223                 write_newline ();
1224         }
1225
1226         public override void visit_throw_statement (ThrowStatement stmt) {
1227                 write_indent ();
1228                 write_string ("throw");
1229                 if (stmt.error_expression != null) {
1230                         write_string (" ");
1231                         stmt.error_expression.accept (this);
1232                 }
1233                 write_string (";");
1234                 write_newline ();
1235         }
1236
1237         public override void visit_try_statement (TryStatement stmt) {
1238                 write_indent ();
1239                 write_string ("try");
1240                 stmt.body.accept (this);
1241                 write_newline ();
1242         }
1243
1244         public override void visit_catch_clause (CatchClause clause) {
1245         }
1246
1247         public override void visit_lock_statement (LockStatement stmt) {
1248         }
1249
1250         public override void visit_delete_statement (DeleteStatement stmt) {
1251         }
1252
1253         public override void visit_array_creation_expression (ArrayCreationExpression expr) {
1254                 write_string ("new ");
1255                 write_type (expr.element_type);
1256                 write_string ("[");
1257
1258                 bool first = true;
1259                 foreach (Expression size in expr.get_sizes ()) {
1260                         if (!first) {
1261                                 write_string (", ");
1262                         }
1263                         first = false;
1264
1265                         size.accept (this);
1266                 }
1267
1268                 write_string ("]");
1269
1270                 if (expr.initializer_list != null) {
1271                         write_string (" ");
1272                         expr.initializer_list.accept (this);
1273                 }
1274         }
1275
1276         public override void visit_boolean_literal (BooleanLiteral lit) {
1277                 write_string (lit.value.to_string ());
1278         }
1279
1280         public override void visit_character_literal (CharacterLiteral lit) {
1281                 write_string (lit.value);
1282         }
1283
1284         public override void visit_integer_literal (IntegerLiteral lit) {
1285                 write_string (lit.value);
1286         }
1287
1288         public override void visit_real_literal (RealLiteral lit) {
1289                 write_string (lit.value);
1290         }
1291
1292         public override void visit_string_literal (StringLiteral lit) {
1293                 write_string (lit.value);
1294         }
1295
1296         public override void visit_null_literal (NullLiteral lit) {
1297                 write_string ("null");
1298         }
1299
1300         public override void visit_member_access (MemberAccess expr) {
1301                 if (expr.inner != null) {
1302                         expr.inner.accept (this);
1303                         write_string (".");
1304                 }
1305                 write_identifier (expr.member_name);
1306         }
1307
1308         public override void visit_method_call (MethodCall expr) {
1309                 expr.call.accept (this);
1310                 write_string (" (");
1311
1312                 bool first = true;
1313                 foreach (Expression arg in expr.get_argument_list ()) {
1314                         if (!first) {
1315                                 write_string (", ");
1316                         }
1317                         first = false;
1318
1319                         arg.accept (this);
1320                 }
1321
1322                 write_string (")");
1323         }
1324
1325         public override void visit_element_access (ElementAccess expr) {
1326                 expr.container.accept (this);
1327                 write_string ("[");
1328
1329                 bool first = true;
1330                 foreach (Expression index in expr.get_indices ()) {
1331                         if (!first) {
1332                                 write_string (", ");
1333                         }
1334                         first = false;
1335
1336                         index.accept (this);
1337                 }
1338
1339                 write_string ("]");
1340         }
1341
1342         public override void visit_base_access (BaseAccess expr) {
1343                 write_string ("base");
1344         }
1345
1346         public override void visit_postfix_expression (PostfixExpression expr) {
1347                 expr.inner.accept (this);
1348                 if (expr.increment) {
1349                         write_string ("++");
1350                 } else {
1351                         write_string ("--");
1352                 }
1353         }
1354
1355         public override void visit_object_creation_expression (ObjectCreationExpression expr) {
1356                 write_string ("new ");
1357                 write_type (expr.type_reference);
1358                 write_string (" (");
1359
1360                 bool first = true;
1361                 foreach (Expression arg in expr.get_argument_list ()) {
1362                         if (!first) {
1363                                 write_string (", ");
1364                         }
1365                         first = false;
1366
1367                         arg.accept (this);
1368                 }
1369
1370                 write_string (")");
1371         }
1372
1373         public override void visit_sizeof_expression (SizeofExpression expr) {
1374                 write_string ("sizeof (");
1375                 write_type (expr.type_reference);
1376                 write_string (")");
1377         }
1378
1379         public override void visit_typeof_expression (TypeofExpression expr) {
1380                 write_string ("typeof (");
1381                 write_type (expr.type_reference);
1382                 write_string (")");
1383         }
1384
1385         public override void visit_unary_expression (UnaryExpression expr) {
1386                 switch (expr.operator) {
1387                 case UnaryOperator.PLUS:
1388                         write_string ("+");
1389                         break;
1390                 case UnaryOperator.MINUS:
1391                         write_string ("-");
1392                         break;
1393                 case UnaryOperator.LOGICAL_NEGATION:
1394                         write_string ("!");
1395                         break;
1396                 case UnaryOperator.BITWISE_COMPLEMENT:
1397                         write_string ("~");
1398                         break;
1399                 case UnaryOperator.INCREMENT:
1400                         write_string ("++");
1401                         break;
1402                 case UnaryOperator.DECREMENT:
1403                         write_string ("--");
1404                         break;
1405                 case UnaryOperator.REF:
1406                         write_string ("ref ");
1407                         break;
1408                 case UnaryOperator.OUT:
1409                         write_string ("out ");
1410                         break;
1411                 default:
1412                         assert_not_reached ();
1413                 }
1414                 expr.inner.accept (this);
1415         }
1416
1417         public override void visit_cast_expression (CastExpression expr) {
1418                 if (!expr.is_silent_cast) {
1419                         write_string ("(");
1420                         write_type (expr.type_reference);
1421                         write_string (") ");
1422                 }
1423
1424                 expr.inner.accept (this);
1425
1426                 if (expr.is_silent_cast) {
1427                         write_string (" as ");
1428                         write_type (expr.type_reference);
1429                 }
1430         }
1431
1432         public override void visit_pointer_indirection (PointerIndirection expr) {
1433                 write_string ("*");
1434                 expr.inner.accept (this);
1435         }
1436
1437         public override void visit_addressof_expression (AddressofExpression expr) {
1438                 write_string ("&");
1439                 expr.inner.accept (this);
1440         }
1441
1442         public override void visit_reference_transfer_expression (ReferenceTransferExpression expr) {
1443                 write_string ("(owned) ");
1444                 expr.inner.accept (this);
1445         }
1446
1447         public override void visit_binary_expression (BinaryExpression expr) {
1448                 expr.left.accept (this);
1449
1450                 switch (expr.operator) {
1451                 case BinaryOperator.PLUS:
1452                         write_string (" + ");
1453                         break;
1454                 case BinaryOperator.MINUS:
1455                         write_string (" - ");
1456                         break;
1457                 case BinaryOperator.MUL:
1458                         write_string (" * ");
1459                         break;
1460                 case BinaryOperator.DIV:
1461                         write_string (" / ");
1462                         break;
1463                 case BinaryOperator.MOD:
1464                         write_string (" % ");
1465                         break;
1466                 case BinaryOperator.SHIFT_LEFT:
1467                         write_string (" << ");
1468                         break;
1469                 case BinaryOperator.SHIFT_RIGHT:
1470                         write_string (" >> ");
1471                         break;
1472                 case BinaryOperator.LESS_THAN:
1473                         write_string (" < ");
1474                         break;
1475                 case BinaryOperator.GREATER_THAN:
1476                         write_string (" > ");
1477                         break;
1478                 case BinaryOperator.LESS_THAN_OR_EQUAL:
1479                         write_string (" <= ");
1480                         break;
1481                 case BinaryOperator.GREATER_THAN_OR_EQUAL:
1482                         write_string (" >= ");
1483                         break;
1484                 case BinaryOperator.EQUALITY:
1485                         write_string (" == ");
1486                         break;
1487                 case BinaryOperator.INEQUALITY:
1488                         write_string (" != ");
1489                         break;
1490                 case BinaryOperator.BITWISE_AND:
1491                         write_string (" & ");
1492                         break;
1493                 case BinaryOperator.BITWISE_OR:
1494                         write_string (" | ");
1495                         break;
1496                 case BinaryOperator.BITWISE_XOR:
1497                         write_string (" ^ ");
1498                         break;
1499                 case BinaryOperator.AND:
1500                         write_string (" && ");
1501                         break;
1502                 case BinaryOperator.OR:
1503                         write_string (" || ");
1504                         break;
1505                 case BinaryOperator.IN:
1506                         write_string (" in ");
1507                         break;
1508                 default:
1509                         assert_not_reached ();
1510                 }
1511
1512                 expr.right.accept (this);
1513         }
1514
1515         public override void visit_type_check (TypeCheck expr) {
1516                 expr.expression.accept (this);
1517                 write_string (" is ");
1518                 write_type (expr.type_reference);
1519         }
1520
1521         public override void visit_conditional_expression (ConditionalExpression expr) {
1522                 expr.condition.accept (this);
1523                 write_string ("?");
1524                 expr.true_expression.accept (this);
1525                 write_string (":");
1526                 expr.false_expression.accept (this);
1527         }
1528
1529         public override void visit_lambda_expression (LambdaExpression expr) {
1530         }
1531
1532         public override void visit_assignment (Assignment a) {
1533                 a.left.accept (this);
1534                 write_string (" = ");
1535                 a.right.accept (this);
1536         }
1537
1538         private void write_indent () {
1539                 int i;
1540
1541                 if (!bol) {
1542                         stream.putc ('\n');
1543                 }
1544
1545                 for (i = 0; i < indent; i++) {
1546                         stream.putc ('\t');
1547                 }
1548
1549                 bol = false;
1550         }
1551
1552         private void write_identifier (string s) {
1553                 if (s == "base" || s == "break" || s == "class" ||
1554                     s == "construct" || s == "delegate" || s == "delete" ||
1555                     s == "do" || s == "dynamic" || s == "foreach" || s == "in" ||
1556                     s == "interface" || s == "lock" || s == "namespace" ||
1557                     s == "new" || s == "out" || s == "ref" ||
1558                     s == "signal" || s.get_char ().isdigit ()) {
1559                         stream.putc ('@');
1560                 }
1561                 write_string (s);
1562         }
1563
1564         private void write_return_type (DataType type) {
1565                 if (is_weak (type)) {
1566                         write_string ("unowned ");
1567                 }
1568
1569                 write_type (type);
1570         }
1571
1572         private bool is_weak (DataType type) {
1573                 if (type.value_owned) {
1574                         return false;
1575                 } else if (type is VoidType || type is PointerType) {
1576                         return false;
1577                 } else if (type is ValueType) {
1578                         if (type.nullable) {
1579                                 // nullable structs are heap allocated
1580                                 return true;
1581                         }
1582
1583                         // TODO return true for structs with destroy
1584                         return false;
1585                 }
1586
1587                 return true;
1588         }
1589
1590         private void write_type (DataType type) {
1591                 write_string (type.to_qualified_string (current_scope));
1592         }
1593
1594         private void write_string (string s) {
1595                 stream.printf ("%s", s);
1596                 bol = false;
1597         }
1598
1599         private void write_newline () {
1600                 stream.putc ('\n');
1601                 bol = true;
1602         }
1603
1604         void write_code_block (Block? block) {
1605                 if (block == null || !dump_tree) {
1606                         write_string (";");
1607                         return;
1608                 }
1609
1610                 block.accept (this);
1611         }
1612
1613         private void write_begin_block () {
1614                 if (!bol) {
1615                         stream.putc (' ');
1616                 } else {
1617                         write_indent ();
1618                 }
1619                 stream.putc ('{');
1620                 write_newline ();
1621                 indent++;
1622         }
1623
1624         private void write_end_block () {
1625                 indent--;
1626                 write_indent ();
1627                 stream.printf ("}");
1628         }
1629
1630         private bool check_accessibility (Symbol sym) {
1631                 if (dump_tree ||
1632                     sym.access == SymbolAccessibility.PUBLIC ||
1633                     sym.access == SymbolAccessibility.PROTECTED) {
1634                         return true;
1635                 }
1636
1637                 return false;
1638         }
1639
1640         private void write_accessibility (Symbol sym) {
1641                 if (sym.access == SymbolAccessibility.PUBLIC) {
1642                         write_string ("public ");
1643                 } else if (sym.access == SymbolAccessibility.PROTECTED) {
1644                         write_string ("protected ");
1645                 } else if (sym.access == SymbolAccessibility.INTERNAL) {
1646                         write_string ("internal ");
1647                 } else if (sym.access == SymbolAccessibility.PRIVATE) {
1648                         write_string ("private ");
1649                 }
1650         }
1651 }