gcc/d/dmd/json.d

   1 /**
   2  * Code for generating .json descriptions of the module when passing the `-X` flag to dmd.
   3  *
   4  * Copyright:   Copyright (C) 1999-2022 by The D Language Foundation, All Rights Reserved
   5  * Authors:     $(LINK2 https://www.digitalmars.com, Walter Bright)
   6  * License:     $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
   7  * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/json.d, _json.d)
   8  * Documentation:  https://dlang.org/phobos/dmd_json.html
   9  * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/json.d
  10  */
  11
  12 module dmd.json;
  13
  14 import core.stdc.stdio;
  15 import core.stdc.string;
  16 import dmd.aggregate;
  17 import dmd.arraytypes;
  18 import dmd.astenums;
  19 import dmd.attrib;
  20 import dmd.cond;
  21 import dmd.dclass;
  22 import dmd.declaration;
  23 import dmd.denum;
  24 import dmd.dimport;
  25 import dmd.dmodule;
  26 import dmd.dsymbol;
  27 import dmd.dtemplate;
  28 import dmd.errors;
  29 import dmd.expression;
  30 import dmd.func;
  31 import dmd.globals;
  32 import dmd.hdrgen;
  33 import dmd.id;
  34 import dmd.identifier;
  35 import dmd.mtype;
  36 import dmd.common.outbuffer;
  37 import dmd.root.rootobject;
  38 import dmd.root.string;
  39 import dmd.target;
  40 import dmd.visitor;
  41
  42 version(Windows) {
  43     extern (C) char* getcwd(char* buffer, size_t maxlen);
  44 } else {
  45     import core.sys.posix.unistd : getcwd;
  46 }
  47
  48 private extern (C++) final class ToJsonVisitor : Visitor
  49 {
  50     alias visit = Visitor.visit;
  51 public:
  52     OutBuffer* buf;
  53     int indentLevel;
  54     const(char)[] filename;
  55
  56     extern (D) this(OutBuffer* buf)
  57     {
  58         this.buf = buf;
  59     }
  60
  61
  62     void indent()
  63     {
  64         if (buf.length >= 1 && (*buf)[buf.length - 1] == '\n')
  65             for (int i = 0; i < indentLevel; i++)
  66                 buf.writeByte(' ');
  67     }
  68
  69     void removeComma()
  70     {
  71         if (buf.length >= 2 && (*buf)[buf.length - 2] == ',' && ((*buf)[buf.length - 1] == '\n' || (*buf)[buf.length - 1] == ' '))
  72             buf.setsize(buf.length - 2);
  73     }
  74
  75     void comma()
  76     {
  77         if (indentLevel > 0)
  78             buf.writestring(",\n");
  79     }
  80
  81     void stringStart()
  82     {
  83         buf.writeByte('\"');
  84     }
  85
  86     void stringEnd()
  87     {
  88         buf.writeByte('\"');
  89     }
  90
  91     extern(D) void stringPart(const char[] s)
  92     {
  93         foreach (char c; s)
  94         {
  95             switch (c)
  96             {
  97             case '\n':
  98                 buf.writestring("\\n");
  99                 break;
 100             case '\r':
 101                 buf.writestring("\\r");
 102                 break;
 103             case '\t':
 104                 buf.writestring("\\t");
 105                 break;
 106             case '\"':
 107                 buf.writestring("\\\"");
 108                 break;
 109             case '\\':
 110                 buf.writestring("\\\\");
 111                 break;
 112             case '\b':
 113                 buf.writestring("\\b");
 114                 break;
 115             case '\f':
 116                 buf.writestring("\\f");
 117                 break;
 118             default:
 119                 if (c < 0x20)
 120                     buf.printf("\\u%04x", c);
 121                 else
 122                 {
 123                     // Note that UTF-8 chars pass through here just fine
 124                     buf.writeByte(c);
 125                 }
 126                 break;
 127             }
 128         }
 129     }
 130
 131     // Json value functions
 132     /*********************************
 133      * Encode string into buf, and wrap it in double quotes.
 134      */
 135     extern(D) void value(const char[] s)
 136     {
 137         stringStart();
 138         stringPart(s);
 139         stringEnd();
 140     }
 141
 142     void value(int value)
 143     {
 144         if (value < 0)
 145         {
 146             buf.writeByte('-');
 147             value = -value;
 148         }
 149         buf.print(value);
 150     }
 151
 152     void valueBool(bool value)
 153     {
 154         buf.writestring(value ? "true" : "false");
 155     }
 156
 157     /*********************************
 158      * Item is an intented value and a comma, for use in arrays
 159      */
 160     extern(D) void item(const char[] s)
 161     {
 162         indent();
 163         value(s);
 164         comma();
 165     }
 166
 167     void item(int i)
 168     {
 169         indent();
 170         value(i);
 171         comma();
 172     }
 173
 174     void itemBool(const bool b)
 175     {
 176         indent();
 177         valueBool(b);
 178         comma();
 179     }
 180
 181     // Json array functions
 182     void arrayStart()
 183     {
 184         indent();
 185         buf.writestring("[\n");
 186         indentLevel++;
 187     }
 188
 189     void arrayEnd()
 190     {
 191         indentLevel--;
 192         removeComma();
 193         if (buf.length >= 2 && (*buf)[buf.length - 2] == '[' && (*buf)[buf.length - 1] == '\n')
 194             buf.setsize(buf.length - 1);
 195         else if (!(buf.length >= 1 && (*buf)[buf.length - 1] == '['))
 196         {
 197             buf.writestring("\n");
 198             indent();
 199         }
 200         buf.writestring("]");
 201         comma();
 202     }
 203
 204     // Json object functions
 205     void objectStart()
 206     {
 207         indent();
 208         buf.writestring("{\n");
 209         indentLevel++;
 210     }
 211
 212     void objectEnd()
 213     {
 214         indentLevel--;
 215         removeComma();
 216         if (buf.length >= 2 && (*buf)[buf.length - 2] == '{' && (*buf)[buf.length - 1] == '\n')
 217             buf.setsize(buf.length - 1);
 218         else
 219         {
 220             buf.writestring("\n");
 221             indent();
 222         }
 223         buf.writestring("}");
 224         comma();
 225     }
 226
 227     // Json object property functions
 228     extern(D) void propertyStart(const char[] name)
 229     {
 230         indent();
 231         value(name);
 232         buf.writestring(" : ");
 233     }
 234
 235     /**
 236     Write the given string object property only if `s` is not null.
 237
 238     Params:
 239      name = the name of the object property
 240      s = the string value of the object property
 241     */
 242     extern(D) void property(const char[] name, const char[] s)
 243     {
 244         if (s is null)
 245             return;
 246         propertyStart(name);
 247         value(s);
 248         comma();
 249     }
 250
 251     /**
 252     Write the given string object property.
 253
 254     Params:
 255      name = the name of the object property
 256      s = the string value of the object property
 257     */
 258     extern(D) void requiredProperty(const char[] name, const char[] s)
 259     {
 260         propertyStart(name);
 261         if (s is null)
 262             buf.writestring("null");
 263         else
 264             value(s);
 265         comma();
 266     }
 267
 268     extern(D) void property(const char[] name, int i)
 269     {
 270         propertyStart(name);
 271         value(i);
 272         comma();
 273     }
 274
 275     extern(D) void propertyBool(const char[] name, const bool b)
 276     {
 277         propertyStart(name);
 278         valueBool(b);
 279         comma();
 280     }
 281
 282     extern(D) void property(const char[] name, TRUST trust)
 283     {
 284         final switch (trust)
 285         {
 286         case TRUST.default_:
 287             // Should not be printed
 288             //property(name, "default");
 289             break;
 290         case TRUST.system:  return property(name, "system");
 291         case TRUST.trusted: return property(name, "trusted");
 292         case TRUST.safe:    return property(name, "safe");
 293         }
 294     }
 295
 296     extern(D) void property(const char[] name, PURE purity)
 297     {
 298         final switch (purity)
 299         {
 300         case PURE.impure:
 301             // Should not be printed
 302             //property(name, "impure");
 303             break;
 304         case PURE.weak:     return property(name, "weak");
 305         case PURE.const_:   return property(name, "strong");
 306         case PURE.fwdref:   return property(name, "fwdref");
 307         }
 308     }
 309
 310     extern(D) void property(const char[] name, const LINK linkage)
 311     {
 312         final switch (linkage)
 313         {
 314         case LINK.default_:
 315             // Should not be printed
 316             //property(name, "default");
 317             break;
 318         case LINK.d:
 319             // Should not be printed
 320             //property(name, "d");
 321             break;
 322         case LINK.system:   return property(name, "system");
 323         case LINK.c:        return property(name, "c");
 324         case LINK.cpp:      return property(name, "cpp");
 325         case LINK.windows:  return property(name, "windows");
 326         case LINK.objc:     return property(name, "objc");
 327         }
 328     }
 329
 330     extern(D) void propertyStorageClass(const char[] name, StorageClass stc)
 331     {
 332         stc &= STC.visibleStorageClasses;
 333         if (stc)
 334         {
 335             propertyStart(name);
 336             arrayStart();
 337             while (stc)
 338             {
 339                 auto p = stcToString(stc);
 340                 assert(p.length);
 341                 item(p);
 342             }
 343             arrayEnd();
 344         }
 345     }
 346
 347     extern(D) void property(const char[] linename, const char[] charname, const ref Loc loc)
 348     {
 349         if (loc.isValid())
 350         {
 351             if (auto filename = loc.filename.toDString)
 352             {
 353                 if (filename != this.filename)
 354                 {
 355                     this.filename = filename;
 356                     property("file", filename);
 357                 }
 358             }
 359             if (loc.linnum)
 360             {
 361                 property(linename, loc.linnum);
 362                 if (loc.charnum)
 363                     property(charname, loc.charnum);
 364             }
 365         }
 366     }
 367
 368     extern(D) void property(const char[] name, Type type)
 369     {
 370         if (type)
 371         {
 372             property(name, type.toString());
 373         }
 374     }
 375
 376     extern(D) void property(const char[] name, const char[] deconame, Type type)
 377     {
 378         if (type)
 379         {
 380             if (type.deco)
 381                 property(deconame, type.deco.toDString);
 382             else
 383                 property(name, type.toString());
 384         }
 385     }
 386
 387     extern(D) void property(const char[] name, Parameters* parameters)
 388     {
 389         if (parameters is null || parameters.dim == 0)
 390             return;
 391         propertyStart(name);
 392         arrayStart();
 393         if (parameters)
 394         {
 395             for (size_t i = 0; i < parameters.dim; i++)
 396             {
 397                 Parameter p = (*parameters)[i];
 398                 objectStart();
 399                 if (p.ident)
 400                     property("name", p.ident.toString());
 401                 property("type", "deco", p.type);
 402                 propertyStorageClass("storageClass", p.storageClass);
 403                 if (p.defaultArg)
 404                     property("default", p.defaultArg.toString());
 405                 objectEnd();
 406             }
 407         }
 408         arrayEnd();
 409     }
 410
 411     /* ========================================================================== */
 412     void jsonProperties(Dsymbol s)
 413     {
 414         if (s.isModule())
 415             return;
 416         if (!s.isTemplateDeclaration()) // TemplateDeclaration::kind() acts weird sometimes
 417         {
 418             property("name", s.toString());
 419             if (s.isStaticCtorDeclaration())
 420             {
 421                 property("kind", s.isSharedStaticCtorDeclaration()
 422                          ? "shared static constructor" : "static constructor");
 423             }
 424             else if (s.isStaticDtorDeclaration())
 425             {
 426                 property("kind", s.isSharedStaticDtorDeclaration()
 427                          ? "shared static destructor" : "static destructor");
 428             }
 429             else
 430                 property("kind", s.kind.toDString);
 431         }
 432         // TODO: How about package(names)?
 433         property("protection", visibilityToString(s.visible().kind));
 434         if (EnumMember em = s.isEnumMember())
 435         {
 436             if (em.origValue)
 437                 property("value", em.origValue.toString());
 438         }
 439         property("comment", s.comment.toDString);
 440         property("line", "char", s.loc);
 441     }
 442
 443     void jsonProperties(Declaration d)
 444     {
 445         if (d.storage_class & STC.local)
 446             return;
 447         jsonProperties(cast(Dsymbol)d);
 448         propertyStorageClass("storageClass", d.storage_class);
 449         property("linkage", d.linkage);
 450         property("type", "deco", d.type);
 451         // Emit originalType if it differs from type
 452         if (d.type != d.originalType && d.originalType)
 453         {
 454             auto ostr = d.originalType.toString();
 455             if (d.type)
 456             {
 457                 auto tstr = d.type.toString();
 458                 if (ostr != tstr)
 459                 {
 460                     //printf("tstr = %s, ostr = %s\n", tstr, ostr);
 461                     property("originalType", ostr);
 462                 }
 463             }
 464             else
 465                 property("originalType", ostr);
 466         }
 467     }
 468
 469     void jsonProperties(TemplateDeclaration td)
 470     {
 471         jsonProperties(cast(Dsymbol)td);
 472         if (td.onemember && td.onemember.isCtorDeclaration())
 473             property("name", "this"); // __ctor -> this
 474         else
 475             property("name", td.ident.toString()); // Foo(T) -> Foo
 476     }
 477
 478     /* ========================================================================== */
 479     override void visit(Dsymbol s)
 480     {
 481     }
 482
 483     override void visit(Module s)
 484     {
 485         objectStart();
 486         if (s.md)
 487             property("name", s.md.toString());
 488         property("kind", s.kind.toDString);
 489         filename = s.srcfile.toString();
 490         property("file", filename);
 491         property("comment", s.comment.toDString);
 492         propertyStart("members");
 493         arrayStart();
 494         for (size_t i = 0; i < s.members.dim; i++)
 495         {
 496             (*s.members)[i].accept(this);
 497         }
 498         arrayEnd();
 499         objectEnd();
 500     }
 501
 502     override void visit(Import s)
 503     {
 504         if (s.id == Id.object)
 505             return;
 506         objectStart();
 507         propertyStart("name");
 508         stringStart();
 509         foreach (const pid; s.packages){
 510             stringPart(pid.toString());
 511             buf.writeByte('.');
 512         }
 513         stringPart(s.id.toString());
 514         stringEnd();
 515         comma();
 516         property("kind", s.kind.toDString);
 517         property("comment", s.comment.toDString);
 518         property("line", "char", s.loc);
 519         if (s.visible().kind != Visibility.Kind.public_)
 520             property("protection", visibilityToString(s.visible().kind));
 521         if (s.aliasId)
 522             property("alias", s.aliasId.toString());
 523         bool hasRenamed = false;
 524         bool hasSelective = false;
 525         for (size_t i = 0; i < s.aliases.dim; i++)
 526         {
 527             // avoid empty "renamed" and "selective" sections
 528             if (hasRenamed && hasSelective)
 529                 break;
 530             else if (s.aliases[i])
 531                 hasRenamed = true;
 532             else
 533                 hasSelective = true;
 534         }
 535         if (hasRenamed)
 536         {
 537             // import foo : alias1 = target1;
 538             propertyStart("renamed");
 539             objectStart();
 540             for (size_t i = 0; i < s.aliases.dim; i++)
 541             {
 542                 const name = s.names[i];
 543                 const _alias = s.aliases[i];
 544                 if (_alias)
 545                     property(_alias.toString(), name.toString());
 546             }
 547             objectEnd();
 548         }
 549         if (hasSelective)
 550         {
 551             // import foo : target1;
 552             propertyStart("selective");
 553             arrayStart();
 554             foreach (i, name; s.names)
 555             {
 556                 if (!s.aliases[i])
 557                     item(name.toString());
 558             }
 559             arrayEnd();
 560         }
 561         objectEnd();
 562     }
 563
 564     override void visit(AttribDeclaration d)
 565     {
 566         Dsymbols* ds = d.include(null);
 567         if (ds)
 568         {
 569             for (size_t i = 0; i < ds.dim; i++)
 570             {
 571                 Dsymbol s = (*ds)[i];
 572                 s.accept(this);
 573             }
 574         }
 575     }
 576
 577     override void visit(ConditionalDeclaration d)
 578     {
 579         if (d.condition.inc != Include.notComputed)
 580         {
 581             visit(cast(AttribDeclaration)d);
 582             return; // Don't visit the if/else bodies again below
 583         }
 584         Dsymbols* ds = d.decl ? d.decl : d.elsedecl;
 585         for (size_t i = 0; i < ds.dim; i++)
 586         {
 587             Dsymbol s = (*ds)[i];
 588             s.accept(this);
 589         }
 590     }
 591
 592     override void visit(TypeInfoDeclaration d)
 593     {
 594     }
 595
 596     override void visit(PostBlitDeclaration d)
 597     {
 598     }
 599
 600     override void visit(Declaration d)
 601     {
 602         objectStart();
 603         //property("unknown", "declaration");
 604         jsonProperties(d);
 605         objectEnd();
 606     }
 607
 608     override void visit(AggregateDeclaration d)
 609     {
 610         objectStart();
 611         jsonProperties(d);
 612         ClassDeclaration cd = d.isClassDeclaration();
 613         if (cd)
 614         {
 615             if (cd.baseClass && cd.baseClass.ident != Id.Object)
 616             {
 617                 property("base", cd.baseClass.toPrettyChars(true).toDString);
 618             }
 619             if (cd.interfaces.length)
 620             {
 621                 propertyStart("interfaces");
 622                 arrayStart();
 623                 foreach (b; cd.interfaces)
 624                 {
 625                     item(b.sym.toPrettyChars(true).toDString);
 626                 }
 627                 arrayEnd();
 628             }
 629         }
 630         if (d.members)
 631         {
 632             propertyStart("members");
 633             arrayStart();
 634             for (size_t i = 0; i < d.members.dim; i++)
 635             {
 636                 Dsymbol s = (*d.members)[i];
 637                 s.accept(this);
 638             }
 639             arrayEnd();
 640         }
 641         objectEnd();
 642     }
 643
 644     override void visit(FuncDeclaration d)
 645     {
 646         objectStart();
 647         jsonProperties(d);
 648         TypeFunction tf = cast(TypeFunction)d.type;
 649         if (tf && tf.ty == Tfunction)
 650             property("parameters", tf.parameterList.parameters);
 651         property("endline", "endchar", d.endloc);
 652         if (d.foverrides.dim)
 653         {
 654             propertyStart("overrides");
 655             arrayStart();
 656             for (size_t i = 0; i < d.foverrides.dim; i++)
 657             {
 658                 FuncDeclaration fd = d.foverrides[i];
 659                 item(fd.toPrettyChars().toDString);
 660             }
 661             arrayEnd();
 662         }
 663         if (d.fdrequire)
 664         {
 665             propertyStart("in");
 666             d.fdrequire.accept(this);
 667         }
 668         if (d.fdensure)
 669         {
 670             propertyStart("out");
 671             d.fdensure.accept(this);
 672         }
 673         objectEnd();
 674     }
 675
 676     override void visit(TemplateDeclaration d)
 677     {
 678         objectStart();
 679         // TemplateDeclaration::kind returns the kind of its Aggregate onemember, if it is one
 680         property("kind", "template");
 681         jsonProperties(d);
 682         propertyStart("parameters");
 683         arrayStart();
 684         for (size_t i = 0; i < d.parameters.dim; i++)
 685         {
 686             TemplateParameter s = (*d.parameters)[i];
 687             objectStart();
 688             property("name", s.ident.toString());
 689
 690             if (auto type = s.isTemplateTypeParameter())
 691             {
 692                 if (s.isTemplateThisParameter())
 693                     property("kind", "this");
 694                 else
 695                     property("kind", "type");
 696                 property("type", "deco", type.specType);
 697                 property("default", "defaultDeco", type.defaultType);
 698             }
 699
 700             if (auto value = s.isTemplateValueParameter())
 701             {
 702                 property("kind", "value");
 703                 property("type", "deco", value.valType);
 704                 if (value.specValue)
 705                     property("specValue", value.specValue.toString());
 706                 if (value.defaultValue)
 707                     property("defaultValue", value.defaultValue.toString());
 708             }
 709
 710             if (auto _alias = s.isTemplateAliasParameter())
 711             {
 712                 property("kind", "alias");
 713                 property("type", "deco", _alias.specType);
 714                 if (_alias.specAlias)
 715                     property("specAlias", _alias.specAlias.toString());
 716                 if (_alias.defaultAlias)
 717                     property("defaultAlias", _alias.defaultAlias.toString());
 718             }
 719
 720             if (auto tuple = s.isTemplateTupleParameter())
 721             {
 722                 property("kind", "tuple");
 723             }
 724
 725             objectEnd();
 726         }
 727         arrayEnd();
 728         Expression expression = d.constraint;
 729         if (expression)
 730         {
 731             property("constraint", expression.toString());
 732         }
 733         propertyStart("members");
 734         arrayStart();
 735         for (size_t i = 0; i < d.members.dim; i++)
 736         {
 737             Dsymbol s = (*d.members)[i];
 738             s.accept(this);
 739         }
 740         arrayEnd();
 741         objectEnd();
 742     }
 743
 744     override void visit(EnumDeclaration d)
 745     {
 746         if (d.isAnonymous())
 747         {
 748             if (d.members)
 749             {
 750                 for (size_t i = 0; i < d.members.dim; i++)
 751                 {
 752                     Dsymbol s = (*d.members)[i];
 753                     s.accept(this);
 754                 }
 755             }
 756             return;
 757         }
 758         objectStart();
 759         jsonProperties(d);
 760         property("base", "baseDeco", d.memtype);
 761         if (d.members)
 762         {
 763             propertyStart("members");
 764             arrayStart();
 765             for (size_t i = 0; i < d.members.dim; i++)
 766             {
 767                 Dsymbol s = (*d.members)[i];
 768                 s.accept(this);
 769             }
 770             arrayEnd();
 771         }
 772         objectEnd();
 773     }
 774
 775     override void visit(EnumMember s)
 776     {
 777         objectStart();
 778         jsonProperties(cast(Dsymbol)s);
 779         property("type", "deco", s.origType);
 780         objectEnd();
 781     }
 782
 783     override void visit(VarDeclaration d)
 784     {
 785         if (d.storage_class & STC.local)
 786             return;
 787         objectStart();
 788         jsonProperties(d);
 789         if (d._init)
 790             property("init", d._init.toString());
 791         if (d.isField())
 792             property("offset", d.offset);
 793         if (!d.alignment.isUnknown() && !d.alignment.isDefault())
 794             property("align", d.alignment.get());
 795         objectEnd();
 796     }
 797
 798     override void visit(TemplateMixin d)
 799     {
 800         objectStart();
 801         jsonProperties(d);
 802         objectEnd();
 803     }
 804
 805     /**
 806     Generate an array of module objects that represent the syntax of each
 807     "root module".
 808
 809     Params:
 810      modules = array of the "root modules"
 811     */
 812     private void generateModules(Modules* modules)
 813     {
 814         arrayStart();
 815         if (modules)
 816         {
 817             foreach (m; *modules)
 818             {
 819                 if (global.params.verbose)
 820                     message("json gen %s", m.toChars());
 821                 m.accept(this);
 822             }
 823         }
 824         arrayEnd();
 825     }
 826
 827     /**
 828     Generate the "compilerInfo" object which contains information about the compiler
 829     such as the filename, version, supported features, etc.
 830     */
 831     private void generateCompilerInfo()
 832     {
 833         import dmd.target : target;
 834         objectStart();
 835         requiredProperty("vendor", global.vendor);
 836         requiredProperty("version", global.versionString());
 837         property("__VERSION__", global.versionNumber());
 838         requiredProperty("interface", determineCompilerInterface());
 839         property("size_t", size_t.sizeof);
 840         propertyStart("platforms");
 841         arrayStart();
 842         if (target.os == Target.OS.Windows)
 843         {
 844             item("windows");
 845         }
 846         else
 847         {
 848             item("posix");
 849             if (target.os == Target.OS.linux)
 850                 item("linux");
 851             else if (target.os == Target.OS.OSX)
 852                 item("osx");
 853             else if (target.os == Target.OS.FreeBSD)
 854             {
 855                 item("freebsd");
 856                 item("bsd");
 857             }
 858             else if (target.os == Target.OS.OpenBSD)
 859             {
 860                 item("openbsd");
 861                 item("bsd");
 862             }
 863             else if (target.os == Target.OS.Solaris)
 864             {
 865                 item("solaris");
 866                 item("bsd");
 867             }
 868         }
 869         arrayEnd();
 870
 871         propertyStart("architectures");
 872         arrayStart();
 873         item(target.architectureName);
 874         arrayEnd();
 875
 876         propertyStart("predefinedVersions");
 877         arrayStart();
 878         if (global.versionids)
 879         {
 880             foreach (const versionid; *global.versionids)
 881             {
 882                 item(versionid.toString());
 883             }
 884         }
 885         arrayEnd();
 886
 887         propertyStart("supportedFeatures");
 888         {
 889             objectStart();
 890             scope(exit) objectEnd();
 891             propertyBool("includeImports", true);
 892         }
 893         objectEnd();
 894     }
 895
 896     /**
 897     Generate the "buildInfo" object which contains information specific to the
 898     current build such as CWD, importPaths, configFile, etc.
 899     */
 900     private void generateBuildInfo()
 901     {
 902         objectStart();
 903         requiredProperty("cwd", getcwd(null, 0).toDString);
 904         requiredProperty("argv0", global.params.argv0);
 905         requiredProperty("config", global.inifilename);
 906         requiredProperty("libName", global.params.libname);
 907
 908         propertyStart("importPaths");
 909         arrayStart();
 910         if (global.params.imppath)
 911         {
 912             foreach (importPath; *global.params.imppath)
 913             {
 914                 item(importPath.toDString);
 915             }
 916         }
 917         arrayEnd();
 918
 919         propertyStart("objectFiles");
 920         arrayStart();
 921         foreach (objfile; global.params.objfiles)
 922         {
 923             item(objfile.toDString);
 924         }
 925         arrayEnd();
 926
 927         propertyStart("libraryFiles");
 928         arrayStart();
 929         foreach (lib; global.params.libfiles)
 930         {
 931             item(lib.toDString);
 932         }
 933         arrayEnd();
 934
 935         propertyStart("ddocFiles");
 936         arrayStart();
 937         foreach (ddocFile; global.params.ddocfiles)
 938         {
 939             item(ddocFile.toDString);
 940         }
 941         arrayEnd();
 942
 943         requiredProperty("mapFile", global.params.mapfile);
 944         requiredProperty("resourceFile", global.params.resfile);
 945         requiredProperty("defFile", global.params.deffile);
 946
 947         objectEnd();
 948     }
 949
 950     /**
 951     Generate the "semantics" object which contains a 'modules' field representing
 952     semantic information about all the modules used in the compilation such as
 953     module name, isRoot, contentImportedFiles, etc.
 954     */
 955     private void generateSemantics()
 956     {
 957         objectStart();
 958         propertyStart("modules");
 959         arrayStart();
 960         foreach (m; Module.amodules)
 961         {
 962             objectStart();
 963             requiredProperty("name", m.md ? m.md.toString() : null);
 964             requiredProperty("file", m.srcfile.toString());
 965             propertyBool("isRoot", m.isRoot());
 966             if(m.contentImportedFiles.dim > 0)
 967             {
 968                 propertyStart("contentImports");
 969                 arrayStart();
 970                 foreach (file; m.contentImportedFiles)
 971                 {
 972                     item(file.toDString);
 973                 }
 974                 arrayEnd();
 975             }
 976             objectEnd();
 977         }
 978         arrayEnd();
 979         objectEnd();
 980     }
 981 }
 982
 983 extern (C++) void json_generate(OutBuffer* buf, Modules* modules)
 984 {
 985     scope ToJsonVisitor json = new ToJsonVisitor(buf);
 986     // write trailing newline
 987     scope(exit) buf.writeByte('\n');
 988
 989     if (global.params.jsonFieldFlags == 0)
 990     {
 991         // Generate the original format, which is just an array
 992         // of modules representing their syntax.
 993         json.generateModules(modules);
 994         json.removeComma();
 995     }
 996     else
 997     {
 998         // Generate the new format which is an object where each
 999         // output option is its own field.
1000
1001         json.objectStart();
1002         if (global.params.jsonFieldFlags & JsonFieldFlags.compilerInfo)
1003         {
1004             json.propertyStart("compilerInfo");
1005             json.generateCompilerInfo();
1006         }
1007         if (global.params.jsonFieldFlags & JsonFieldFlags.buildInfo)
1008         {
1009             json.propertyStart("buildInfo");
1010             json.generateBuildInfo();
1011         }
1012         if (global.params.jsonFieldFlags & JsonFieldFlags.modules)
1013         {
1014             json.propertyStart("modules");
1015             json.generateModules(modules);
1016         }
1017         if (global.params.jsonFieldFlags & JsonFieldFlags.semantics)
1018         {
1019             json.propertyStart("semantics");
1020             json.generateSemantics();
1021         }
1022         json.objectEnd();
1023     }
1024 }
1025
1026 /**
1027 A string listing the name of each JSON field. Useful for errors messages.
1028 */
1029 enum jsonFieldNames = () {
1030     string s;
1031     string prefix = "";
1032     foreach (idx, enumName; __traits(allMembers, JsonFieldFlags))
1033     {
1034         static if (idx > 0)
1035         {
1036             s ~= prefix ~ "`" ~ enumName ~ "`";
1037             prefix = ", ";
1038         }
1039     }
1040     return s;
1041 }();
1042
1043 /**
1044 Parse the given `fieldName` and return its corresponding JsonFieldFlags value.
1045
1046 Params:
1047  fieldName = the field name to parse
1048
1049 Returns: JsonFieldFlags.none on error, otherwise the JsonFieldFlags value
1050          corresponding to the given fieldName.
1051 */
1052 extern (C++) JsonFieldFlags tryParseJsonField(const(char)* fieldName)
1053 {
1054     auto fieldNameString = fieldName.toDString();
1055     foreach (idx, enumName; __traits(allMembers, JsonFieldFlags))
1056     {
1057         static if (idx > 0)
1058         {
1059             if (fieldNameString == enumName)
1060                 return __traits(getMember, JsonFieldFlags, enumName);
1061         }
1062     }
1063     return JsonFieldFlags.none;
1064 }
1065
1066 /**
1067 Determines and returns the compiler interface which is one of `dmd`, `ldc`,
1068 `gdc` or `sdc`. Returns `null` if no interface can be determined.
1069 */
1070 private extern(D) string determineCompilerInterface()
1071 {
1072     if (global.vendor == "Digital Mars D")
1073         return "dmd";
1074     if (global.vendor == "LDC")
1075         return "ldc";
1076     if (global.vendor == "GNU D")
1077         return "gdc";
1078     if (global.vendor == "SDC")
1079         return "sdc";
1080     return null;
1081 }