lib/d/src/thrift/codegen/idlgen.d - packaging/sources/thrift - Gitiles

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements. See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership. The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 /**
  * Contains <b>experimental</b> functionality for generating Thrift IDL files
  * (.thrift) from existing D data structures, i.e. the reverse of what the
  * Thrift compiler does.
  */
 module thrift.codegen.idlgen;

 import std.algorithm : find;
 import std.array : empty, front;
 import std.conv : to;
 import std.traits : EnumMembers, isSomeFunction, OriginalType,
   ParameterTypeTuple, ReturnType;
 import std.typetuple : allSatisfy, staticIndexOf, staticMap, NoDuplicates,
   TypeTuple;
 import thrift.base;
 import thrift.codegen.base;
 import thrift.internal.codegen;
 import thrift.internal.ctfe;
 import thrift.util.hashset;

 /**
  * True if the passed type is a Thrift entity (struct, exception, enum,
  * service).
  */
 alias Any!(isStruct, isException, isEnum, isService) isThriftEntity;

 /**
  * Returns an IDL string describing the passed »root« entities and all types
  * they depend on.
  */
 template idlString(Roots...) if (allSatisfy!(isThriftEntity, Roots)) {
   enum idlString = idlStringImpl!Roots.result;
 }

 private {
   template idlStringImpl(Roots...) if (allSatisfy!(isThriftEntity, Roots)) {
     alias ForAllWithList!(
       ConfinedTuple!(StaticFilter!(isService, Roots)),
       AddBaseServices
     ) Services;

     alias TypeTuple!(
       StaticFilter!(isEnum, Roots),
       ForAllWithList!(
         ConfinedTuple!(
           StaticFilter!(Any!(isException, isStruct), Roots),
           staticMap!(CompositeTypeDeps, staticMap!(ServiceTypeDeps, Services))
         ),
         AddStructWithDeps
       )
     ) Types;

     enum result = ctfeJoin(
       [
         staticMap!(
           enumIdlString,
           StaticFilter!(isEnum, Types)
         ),
         staticMap!(
           structIdlString,
           StaticFilter!(Any!(isStruct, isException), Types)
         ),
         staticMap!(
           serviceIdlString,
           Services
         )
       ],
       "\n"
     );
   }

   template ServiceTypeDeps(T) if (isService!T) {
     alias staticMap!(
       PApply!(MethodTypeDeps, T),
       FilterMethodNames!(T, __traits(derivedMembers, T))
     ) ServiceTypeDeps;
   }

   template MethodTypeDeps(T, string name) if (
     isService!T && isSomeFunction!(MemberType!(T, name))
   ) {
     alias TypeTuple!(
       ReturnType!(MemberType!(T, name)),
       ParameterTypeTuple!(MemberType!(T, name)),
       ExceptionTypes!(T, name)
     ) MethodTypeDeps;
   }

   template ExceptionTypes(T, string name) if (
     isService!T && isSomeFunction!(MemberType!(T, name))
   ) {
     mixin({
       enum meta = find!`a.name == b`(getMethodMeta!T, name);
       if (meta.empty) return "alias TypeTuple!() ExceptionTypes;";

       string result = "alias TypeTuple!(";
       foreach (i, e; meta.front.exceptions) {
         if (i > 0) result ~= ", ";
         result ~= "mixin(`T." ~ e.type ~ "`)";
       }
       result ~= ") ExceptionTypes;";
       return result;
     }());
   }

   template AddBaseServices(T, List...) {
     static if (staticIndexOf!(T, List) == -1) {
       alias NoDuplicates!(BaseServices!T, List) AddBaseServices;
     } else {
       alias List AddStructWithDeps;
     }
   }

   unittest {
     interface A {}
     interface B : A {}
     interface C : B {}
     interface D : A {}

     static assert(is(AddBaseServices!(C) == TypeTuple!(A, B, C)));
     static assert(is(ForAllWithList!(ConfinedTuple!(C, D), AddBaseServices) ==
       TypeTuple!(A, D, B, C)));
   }

   template BaseServices(T, Rest...) if (isService!T) {
     static if (isDerivedService!T) {
       alias BaseServices!(BaseService!T, T, Rest) BaseServices;
     } else {
       alias TypeTuple!(T, Rest) BaseServices;
     }
   }

   template AddStructWithDeps(T, List...) {
     static if (staticIndexOf!(T, List) == -1) {
       // T is not already in the List, so add T and the types it depends on in
       // the front. Because with the Thrift compiler types can only depend on
       // other types that have already been defined, we collect all the
       // dependencies, prepend them to the list, and then prune the duplicates
       // (keeping the first occurrences). If this requirement should ever be
       // dropped from Thrift, this could be easily adapted to handle circular
       // dependencies by passing TypeTuple!(T, List) to ForAllWithList instead
       // of appending List afterwards, and removing the now unnecessary
       // NoDuplicates.
       alias NoDuplicates!(
         ForAllWithList!(
           ConfinedTuple!(
             staticMap!(
               CompositeTypeDeps,
               staticMap!(
                 PApply!(MemberType, T),
                 FieldNames!T
               )
             )
           ),
           .AddStructWithDeps,
           T
         ),
         List
       ) AddStructWithDeps;
     } else {
       alias List AddStructWithDeps;
     }
   }

   version (unittest) {
     struct A {}
     struct B {
       A a;
       int b;
       A c;
       string d;
     }
     struct C {
       B b;
       A a;
     }

     static assert(is(AddStructWithDeps!C == TypeTuple!(A, B, C)));

     struct D {
       C c;
       mixin TStructHelpers!([TFieldMeta("c", 0, TReq.IGNORE)]);
     }
     static assert(is(AddStructWithDeps!D == TypeTuple!(D)));
   }

   version (unittest) {
     // Circles in the type dependency graph are not allowed in Thrift, but make
     // sure we fail in a sane way instead of crashing the compiler.

     struct Rec1 {
       Rec2[] other;
     }

     struct Rec2 {
       Rec1[] other;
     }

     static assert(!__traits(compiles, AddStructWithDeps!Rec1));
   }

   /*
    * Returns the non-primitive types T directly depends on.
    *
    * For example, CompositeTypeDeps!int would yield an empty type tuple,
    * CompositeTypeDeps!SomeStruct would give SomeStruct, and
    * CompositeTypeDeps!(A[B]) both CompositeTypeDeps!A and CompositeTypeDeps!B.
    */
   template CompositeTypeDeps(T) {
     static if (is(FullyUnqual!T == bool) || is(FullyUnqual!T == byte) ||
       is(FullyUnqual!T == short) || is(FullyUnqual!T == int) ||
       is(FullyUnqual!T == long) || is(FullyUnqual!T : string) ||
       is(FullyUnqual!T == double) || is(FullyUnqual!T == void)
     ) {
       alias TypeTuple!() CompositeTypeDeps;
     } else static if (is(FullyUnqual!T _ : U[], U)) {
       alias CompositeTypeDeps!U CompositeTypeDeps;
     } else static if (is(FullyUnqual!T _ : HashSet!E, E)) {
       alias CompositeTypeDeps!E CompositeTypeDeps;
     } else static if (is(FullyUnqual!T _ : V[K], K, V)) {
       alias TypeTuple!(CompositeTypeDeps!K, CompositeTypeDeps!V) CompositeTypeDeps;
     } else static if (is(FullyUnqual!T == enum) || is(FullyUnqual!T == struct) ||
       is(FullyUnqual!T : TException)
     ) {
       alias TypeTuple!(FullyUnqual!T) CompositeTypeDeps;
     } else {
       static assert(false, "Cannot represent type in Thrift: " ~ T.stringof);
     }
   }
 }

 /**
  * Returns an IDL string describing the passed service. IDL code for any type
  * dependcies is not included.
  */
 template serviceIdlString(T) if (isService!T) {
   enum serviceIdlString = {
     string result = "service " ~ T.stringof;
     static if (isDerivedService!T) {
       result ~= " extends " ~ BaseService!T.stringof;
     }
     result ~= " {\n";

     foreach (methodName; FilterMethodNames!(T, __traits(derivedMembers, T))) {
       result ~= "  ";

       enum meta = find!`a.name == b`(T.methodMeta, methodName);

       static if (!meta.empty && meta.front.type == TMethodType.ONEWAY) {
         result ~= "oneway ";
       }

       alias ReturnType!(MemberType!(T, methodName)) RT;
       static if (is(RT == void)) {
         // We special-case this here instead of adding void to dToIdlType to
         // avoid accepting things like void[].
         result ~= "void ";
       } else {
         result ~= dToIdlType!RT ~ " ";
       }
       result ~= methodName ~ "(";

       short lastId;
       foreach (i, ParamType; ParameterTypeTuple!(MemberType!(T, methodName))) {
         static if (!meta.empty && i < meta.front.params.length) {
           enum havePM = true;
         } else {
           enum havePM = false;
         }

         short id;
         static if (havePM) {
           id = meta.front.params[i].id;
         } else {
           id = --lastId;
         }

         string paramName;
         static if (havePM) {
           paramName = meta.front.params[i].name;
         } else {
           paramName = "param" ~ to!string(i + 1);
         }

         result ~= to!string(id) ~ ": " ~ dToIdlType!ParamType ~ " " ~ paramName;

         static if (havePM && !meta.front.params[i].defaultValue.empty) {
           result ~= " = " ~ dToIdlConst(mixin(meta.front.params[i].defaultValue));
         } else {
           // Unfortunately, getting the default value for parameters from a
           // function alias isn't possible – we can't transfer the default
           // value to the IDL e.g. for interface Foo { void foo(int a = 5); }
           // without the user explicitly declaring it in metadata.
         }
         result ~= ", ";
       }
       result ~= ")";

       static if (!meta.empty && !meta.front.exceptions.empty) {
         result ~= " throws (";
         foreach (e; meta.front.exceptions) {
           result ~= to!string(e.id) ~ ": " ~ e.type ~ " " ~ e.name ~ ", ";
         }
         result ~= ")";
       }

       result ~= ",\n";
     }

     result ~= "}\n";
     return result;
   }();
 }

 /**
  * Returns an IDL string describing the passed enum. IDL code for any type
  * dependcies is not included.
  */
 template enumIdlString(T) if (isEnum!T) {
   enum enumIdlString = {
     static assert(is(OriginalType!T : long),
       "Can only have integer enums in Thrift (not " ~ OriginalType!T.stringof ~
       ", for " ~ T.stringof ~ ").");

     string result = "enum " ~ T.stringof ~ " {\n";

     foreach (name; __traits(derivedMembers, T)) {
       result ~= "  " ~ name ~ " = " ~ dToIdlConst(GetMember!(T, name)) ~ ",\n";
     }

     result ~= "}\n";
     return result;
   }();
 }

 /**
  * Returns an IDL string describing the passed struct. IDL code for any type
  * dependcies is not included.
  */
 template structIdlString(T) if (isStruct!T || isException!T) {
   enum structIdlString = {
     mixin({
       string code = "";
       foreach (field; getFieldMeta!T) {
         code ~= "static assert(is(MemberType!(T, `" ~ field.name ~ "`)));\n";
       }
       return code;
     }());

     string result;
     static if (isException!T) {
       result = "exception ";
     } else {
       result = "struct ";
     }
     result ~= T.stringof ~ " {\n";

     // The last automatically assigned id – fields with no meta information
     // are assigned (in lexical order) descending negative ids, starting with
     // -1, just like the Thrift compiler does.
     short lastId;

     foreach (name; FieldNames!T) {
       enum meta = find!`a.name == b`(getFieldMeta!T, name);

       static if (meta.empty || meta.front.req != TReq.IGNORE) {
         short id;
         static if (meta.empty) {
           id = --lastId;
         } else {
           id = meta.front.id;
         }

         result ~= "  " ~ to!string(id) ~ ":";
         static if (!meta.empty) {
           result ~= dToIdlReq(meta.front.req);
         }
         result ~= " " ~ dToIdlType!(MemberType!(T, name)) ~ " " ~ name;

         static if (!meta.empty && !meta.front.defaultValue.empty) {
           result ~= " = " ~ dToIdlConst(mixin(meta.front.defaultValue));
         } else static if (__traits(compiles, fieldInitA!(T, name))) {
           static if (is(typeof(fieldInitA!(T, name))) &&
             !is(typeof(fieldInitA!(T, name)) == void)
           ) {
             result ~= " = " ~ dToIdlConst(fieldInitA!(T, name));
           }
         } else static if (is(typeof(fieldInitB!(T, name))) &&
           !is(typeof(fieldInitB!(T, name)) == void)
         ) {
           result ~= " = " ~ dToIdlConst(fieldInitB!(T, name));
         }
         result ~= ",\n";
       }
     }

     result ~= "}\n";
     return result;
   }();
 }

 private {
   // This very convoluted way of doing things was chosen because putting the
   // static if directly into structIdlString caused »not evaluatable at compile
   // time« errors to slip through even though typeof() was used, resp. the
   // condition to be true even though the value couldn't actually be read at
   // compile time due to a @@BUG@@ in DMD 2.055.
   // The extra »compiled« field in fieldInitA is needed because we must not try
   // to use != if !is compiled as well (but was false), e.g. for floating point
   // types.
   template fieldInitA(T, string name) {
     static if (mixin("T.init." ~ name) !is MemberType!(T, name).init) {
       enum fieldInitA = mixin("T.init." ~ name);
     }
   }

   template fieldInitB(T, string name) {
     static if (mixin("T.init." ~ name) != MemberType!(T, name).init) {
       enum fieldInitB = mixin("T.init." ~ name);
     }
   }

   template dToIdlType(T) {
     static if (is(FullyUnqual!T == bool)) {
       enum dToIdlType = "bool";
     } else static if (is(FullyUnqual!T == byte)) {
       enum dToIdlType = "byte";
     } else static if (is(FullyUnqual!T == double)) {
       enum dToIdlType = "double";
     } else static if (is(FullyUnqual!T == short)) {
       enum dToIdlType = "i16";
     } else static if (is(FullyUnqual!T == int)) {
       enum dToIdlType = "i32";
     } else static if (is(FullyUnqual!T == long)) {
       enum dToIdlType = "i64";
     } else static if (is(FullyUnqual!T : string)) {
       enum dToIdlType = "string";
     } else static if (is(FullyUnqual!T _ : U[], U)) {
       enum dToIdlType = "list<" ~ dToIdlType!U ~ ">";
     } else static if (is(FullyUnqual!T _ : V[K], K, V)) {
       enum dToIdlType = "map<" ~ dToIdlType!K ~ ", " ~ dToIdlType!V ~ ">";
     } else static if (is(FullyUnqual!T _ : HashSet!E, E)) {
       enum dToIdlType = "set<" ~ dToIdlType!E ~ ">";
     } else static if (is(FullyUnqual!T == struct) || is(FullyUnqual!T == enum) ||
       is(FullyUnqual!T : TException)
     ) {
       enum dToIdlType = FullyUnqual!(T).stringof;
     } else {
       static assert(false, "Cannot represent type in Thrift: " ~ T.stringof);
     }
   }

   string dToIdlReq(TReq req) {
     switch (req) {
       case TReq.REQUIRED: return " required";
       case TReq.OPTIONAL: return " optional";
       default: return "";
     }
   }

   string dToIdlConst(T)(T value) {
     static if (is(FullyUnqual!T == bool)) {
       return value ? "1" : "0";
     } else static if (is(FullyUnqual!T == byte) ||
       is(FullyUnqual!T == short) || is(FullyUnqual!T == int) ||
       is(FullyUnqual!T == long)
     ) {
       return to!string(value);
     } else static if (is(FullyUnqual!T : string)) {
       return `"` ~ to!string(value) ~ `"`;
     } else static if (is(FullyUnqual!T == double)) {
       return ctfeToString(value);
     } else static if (is(FullyUnqual!T _ : U[], U) ||
       is(FullyUnqual!T _ : HashSet!E, E)
     ) {
       string result = "[";
       foreach (e; value) {
         result ~= dToIdlConst(e) ~ ", ";
       }
       result ~= "]";
       return result;
     } else static if (is(FullyUnqual!T _ : V[K], K, V)) {
       string result = "{";
       foreach (key, val; value) {
         result ~= dToIdlConst(key) ~ ": " ~ dToIdlConst(val) ~ ", ";
       }
       result ~= "}";
       return result;
     } else static if (is(FullyUnqual!T == enum)) {
       import std.conv;
       import std.traits;
       return to!string(cast(OriginalType!T)value);
     } else static if (is(FullyUnqual!T == struct) ||
       is(FullyUnqual!T : TException)
     ) {
       string result = "{";
       foreach (name; __traits(derivedMembers, T)) {
         static if (memberReq!(T, name) != TReq.IGNORE) {
           result ~= name ~ ": " ~ dToIdlConst(mixin("value." ~ name)) ~ ", ";
         }
       }
       result ~= "}";
       return result;
     } else {
       static assert(false, "Cannot represent type in Thrift: " ~ T.stringof);
     }
   }
 }

 version (unittest) {
   enum Foo {
     a = 1,
     b = 10,
     c = 5
   }

   static assert(enumIdlString!Foo ==
 `enum Foo {
   a = 1,
   b = 10,
   c = 5,
 }
 `);
 }


 version (unittest) {
   struct WithoutMeta {
     string a;
     int b;
   }

   struct WithDefaults {
     string a = "asdf";
     double b = 3.1415;
     WithoutMeta c;

     mixin TStructHelpers!([
       TFieldMeta("c", 1, TReq.init, `WithoutMeta("foo", 3)`)
     ]);
   }

   // These are from DebugProtoTest.thrift.
   struct OneOfEach {
     bool im_true;
     bool im_false;
     byte a_bite;
     short integer16;
     int integer32;
     long integer64;
     double double_precision;
     string some_characters;
     string zomg_unicode;
     bool what_who;
     string base64;
     byte[] byte_list;
     short[] i16_list;
     long[] i64_list;

     mixin TStructHelpers!([
       TFieldMeta(`im_true`, 1),
       TFieldMeta(`im_false`, 2),
       TFieldMeta(`a_bite`, 3, TReq.OPT_IN_REQ_OUT, q{cast(byte)127}),
       TFieldMeta(`integer16`, 4, TReq.OPT_IN_REQ_OUT, q{cast(short)32767}),
       TFieldMeta(`integer32`, 5),
       TFieldMeta(`integer64`, 6, TReq.OPT_IN_REQ_OUT, q{10000000000L}),
       TFieldMeta(`double_precision`, 7),
       TFieldMeta(`some_characters`, 8),
       TFieldMeta(`zomg_unicode`, 9),
       TFieldMeta(`what_who`, 10),
       TFieldMeta(`base64`, 11),
       TFieldMeta(`byte_list`, 12, TReq.OPT_IN_REQ_OUT, q{{
         byte[] v;
         v ~= cast(byte)1;
         v ~= cast(byte)2;
         v ~= cast(byte)3;
         return v;
       }()}),
       TFieldMeta(`i16_list`, 13, TReq.OPT_IN_REQ_OUT, q{{
         short[] v;
         v ~= cast(short)1;
         v ~= cast(short)2;
         v ~= cast(short)3;
         return v;
       }()}),
       TFieldMeta(`i64_list`, 14, TReq.OPT_IN_REQ_OUT, q{{
         long[] v;
         v ~= 1L;
         v ~= 2L;
         v ~= 3L;
         return v;
       }()})
     ]);
   }

   struct Bonk {
     int type;
     string message;

     mixin TStructHelpers!([
       TFieldMeta(`type`, 1),
       TFieldMeta(`message`, 2)
     ]);
   }

   struct HolyMoley {
     OneOfEach[] big;
     HashSet!(string[]) contain;
     Bonk[][string] bonks;

     mixin TStructHelpers!([
       TFieldMeta(`big`, 1),
       TFieldMeta(`contain`, 2),
       TFieldMeta(`bonks`, 3)
     ]);
   }

   static assert(structIdlString!WithoutMeta ==
 `struct WithoutMeta {
   -1: string a,
   -2: i32 b,
 }
 `);

 import std.algorithm;
   static assert(structIdlString!WithDefaults.startsWith(
 `struct WithDefaults {
   -1: string a = "asdf",
   -2: double b = 3.141`));

   static assert(structIdlString!WithDefaults.endsWith(
 `1: WithoutMeta c = {a: "foo", b: 3, },
 }
 `));

   static assert(structIdlString!OneOfEach ==
 `struct OneOfEach {
   1: bool im_true,
   2: bool im_false,
   3: byte a_bite = 127,
   4: i16 integer16 = 32767,
   5: i32 integer32,
   6: i64 integer64 = 10000000000,
   7: double double_precision,
   8: string some_characters,
   9: string zomg_unicode,
   10: bool what_who,
   11: string base64,
   12: list<byte> byte_list = [1, 2, 3, ],
   13: list<i16> i16_list = [1, 2, 3, ],
   14: list<i64> i64_list = [1, 2, 3, ],
 }
 `);

   static assert(structIdlString!Bonk ==
 `struct Bonk {
   1: i32 type,
   2: string message,
 }
 `);

   static assert(structIdlString!HolyMoley ==
 `struct HolyMoley {
   1: list<OneOfEach> big,
   2: set<list<string>> contain,
   3: map<string, list<Bonk>> bonks,
 }
 `);
 }

 version (unittest) {
   class ExceptionWithAMap : TException {
     string blah;
     string[string] map_field;

     mixin TStructHelpers!([
       TFieldMeta(`blah`, 1),
       TFieldMeta(`map_field`, 2)
     ]);
   }

   interface Srv {
     void voidMethod();
     int primitiveMethod();
     OneOfEach structMethod();
     void methodWithDefaultArgs(int something);
     void onewayMethod();
     void exceptionMethod();

     alias .ExceptionWithAMap ExceptionWithAMap;

     enum methodMeta = [
       TMethodMeta(`methodWithDefaultArgs`,
         [TParamMeta(`something`, 1, q{2})]
       ),
       TMethodMeta(`onewayMethod`,
         [],
         [],
         TMethodType.ONEWAY
       ),
       TMethodMeta(`exceptionMethod`,
         [],
         [
           TExceptionMeta("a", 1, "ExceptionWithAMap"),
           TExceptionMeta("b", 2, "ExceptionWithAMap")
         ]
       )
     ];
   }

   interface ChildSrv : Srv {
     int childMethod(int arg);
   }

   static assert(idlString!ChildSrv ==
 `exception ExceptionWithAMap {
   1: string blah,
   2: map<string, string> map_field,
 }

 struct OneOfEach {
   1: bool im_true,
   2: bool im_false,
   3: byte a_bite = 127,
   4: i16 integer16 = 32767,
   5: i32 integer32,
   6: i64 integer64 = 10000000000,
   7: double double_precision,
   8: string some_characters,
   9: string zomg_unicode,
   10: bool what_who,
   11: string base64,
   12: list<byte> byte_list = [1, 2, 3, ],
   13: list<i16> i16_list = [1, 2, 3, ],
   14: list<i64> i64_list = [1, 2, 3, ],
 }

 service Srv {
   void voidMethod(),
   i32 primitiveMethod(),
   OneOfEach structMethod(),
   void methodWithDefaultArgs(1: i32 something = 2, ),
   oneway void onewayMethod(),
   void exceptionMethod() throws (1: ExceptionWithAMap a, 2: ExceptionWithAMap b, ),
 }

 service ChildSrv extends Srv {
   i32 childMethod(-1: i32 param1, ),
 }
 `);
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	/**
	* Contains <b>experimental</b> functionality for generating Thrift IDL files
	* (.thrift) from existing D data structures, i.e. the reverse of what the
	* Thrift compiler does.
	*/
	module thrift.codegen.idlgen;

	import std.algorithm : find;
	import std.array : empty, front;
	import std.conv : to;
	import std.traits : EnumMembers, isSomeFunction, OriginalType,
	ParameterTypeTuple, ReturnType;
	import std.typetuple : allSatisfy, staticIndexOf, staticMap, NoDuplicates,
	TypeTuple;
	import thrift.base;
	import thrift.codegen.base;
	import thrift.internal.codegen;
	import thrift.internal.ctfe;
	import thrift.util.hashset;

	/**
	* True if the passed type is a Thrift entity (struct, exception, enum,
	* service).
	*/
	alias Any!(isStruct, isException, isEnum, isService) isThriftEntity;

	/**
	* Returns an IDL string describing the passed »root« entities and all types
	* they depend on.
	*/
	template idlString(Roots...) if (allSatisfy!(isThriftEntity, Roots)) {
	enum idlString = idlStringImpl!Roots.result;
	}

	private {
	template idlStringImpl(Roots...) if (allSatisfy!(isThriftEntity, Roots)) {
	alias ForAllWithList!(
	ConfinedTuple!(StaticFilter!(isService, Roots)),
	AddBaseServices
	) Services;

	alias TypeTuple!(
	StaticFilter!(isEnum, Roots),
	ForAllWithList!(
	ConfinedTuple!(
	StaticFilter!(Any!(isException, isStruct), Roots),
	staticMap!(CompositeTypeDeps, staticMap!(ServiceTypeDeps, Services))
	),
	AddStructWithDeps
	)
	) Types;

	enum result = ctfeJoin(
	[
	staticMap!(
	enumIdlString,
	StaticFilter!(isEnum, Types)
	),
	staticMap!(
	structIdlString,
	StaticFilter!(Any!(isStruct, isException), Types)
	),
	staticMap!(
	serviceIdlString,
	Services
	)
	],
	"\n"
	);
	}

	template ServiceTypeDeps(T) if (isService!T) {
	alias staticMap!(
	PApply!(MethodTypeDeps, T),
	FilterMethodNames!(T, __traits(derivedMembers, T))
	) ServiceTypeDeps;
	}

	template MethodTypeDeps(T, string name) if (
	isService!T && isSomeFunction!(MemberType!(T, name))
	) {
	alias TypeTuple!(
	ReturnType!(MemberType!(T, name)),
	ParameterTypeTuple!(MemberType!(T, name)),
	ExceptionTypes!(T, name)
	) MethodTypeDeps;
	}

	template ExceptionTypes(T, string name) if (
	isService!T && isSomeFunction!(MemberType!(T, name))
	) {
	mixin({
	enum meta = find!`a.name == b`(getMethodMeta!T, name);
	if (meta.empty) return "alias TypeTuple!() ExceptionTypes;";

	string result = "alias TypeTuple!(";
	foreach (i, e; meta.front.exceptions) {
	if (i > 0) result ~= ", ";
	result ~= "mixin(`T." ~ e.type ~ "`)";
	}
	result ~= ") ExceptionTypes;";
	return result;
	}());
	}

	template AddBaseServices(T, List...) {
	static if (staticIndexOf!(T, List) == -1) {
	alias NoDuplicates!(BaseServices!T, List) AddBaseServices;
	} else {
	alias List AddStructWithDeps;
	}
	}

	unittest {
	interface A {}
	interface B : A {}
	interface C : B {}
	interface D : A {}

	static assert(is(AddBaseServices!(C) == TypeTuple!(A, B, C)));
	static assert(is(ForAllWithList!(ConfinedTuple!(C, D), AddBaseServices) ==
	TypeTuple!(A, D, B, C)));
	}

	template BaseServices(T, Rest...) if (isService!T) {
	static if (isDerivedService!T) {
	alias BaseServices!(BaseService!T, T, Rest) BaseServices;
	} else {
	alias TypeTuple!(T, Rest) BaseServices;
	}
	}

	template AddStructWithDeps(T, List...) {
	static if (staticIndexOf!(T, List) == -1) {
	// T is not already in the List, so add T and the types it depends on in
	// the front. Because with the Thrift compiler types can only depend on
	// other types that have already been defined, we collect all the
	// dependencies, prepend them to the list, and then prune the duplicates
	// (keeping the first occurrences). If this requirement should ever be
	// dropped from Thrift, this could be easily adapted to handle circular
	// dependencies by passing TypeTuple!(T, List) to ForAllWithList instead
	// of appending List afterwards, and removing the now unnecessary
	// NoDuplicates.
	alias NoDuplicates!(
	ForAllWithList!(
	ConfinedTuple!(
	staticMap!(
	CompositeTypeDeps,
	staticMap!(
	PApply!(MemberType, T),
	FieldNames!T
	)
	)
	),
	.AddStructWithDeps,
	T
	),
	List
	) AddStructWithDeps;
	} else {
	alias List AddStructWithDeps;
	}
	}

	version (unittest) {
	struct A {}
	struct B {
	A a;
	int b;
	A c;
	string d;
	}
	struct C {
	B b;
	A a;
	}

	static assert(is(AddStructWithDeps!C == TypeTuple!(A, B, C)));

	struct D {
	C c;
	mixin TStructHelpers!([TFieldMeta("c", 0, TReq.IGNORE)]);
	}
	static assert(is(AddStructWithDeps!D == TypeTuple!(D)));
	}

	version (unittest) {
	// Circles in the type dependency graph are not allowed in Thrift, but make
	// sure we fail in a sane way instead of crashing the compiler.

	struct Rec1 {
	Rec2[] other;
	}

	struct Rec2 {
	Rec1[] other;
	}

	static assert(!__traits(compiles, AddStructWithDeps!Rec1));
	}

	/*
	* Returns the non-primitive types T directly depends on.
	*
	* For example, CompositeTypeDeps!int would yield an empty type tuple,
	* CompositeTypeDeps!SomeStruct would give SomeStruct, and
	* CompositeTypeDeps!(A[B]) both CompositeTypeDeps!A and CompositeTypeDeps!B.
	*/
	template CompositeTypeDeps(T) {
	static if (is(FullyUnqual!T == bool) \|\| is(FullyUnqual!T == byte) \|\|
	is(FullyUnqual!T == short) \|\| is(FullyUnqual!T == int) \|\|
	is(FullyUnqual!T == long) \|\| is(FullyUnqual!T : string) \|\|
	is(FullyUnqual!T == double) \|\| is(FullyUnqual!T == void)
	) {
	alias TypeTuple!() CompositeTypeDeps;
	} else static if (is(FullyUnqual!T _ : U[], U)) {
	alias CompositeTypeDeps!U CompositeTypeDeps;
	} else static if (is(FullyUnqual!T _ : HashSet!E, E)) {
	alias CompositeTypeDeps!E CompositeTypeDeps;
	} else static if (is(FullyUnqual!T _ : V[K], K, V)) {
	alias TypeTuple!(CompositeTypeDeps!K, CompositeTypeDeps!V) CompositeTypeDeps;
	} else static if (is(FullyUnqual!T == enum) \|\| is(FullyUnqual!T == struct) \|\|
	is(FullyUnqual!T : TException)
	) {
	alias TypeTuple!(FullyUnqual!T) CompositeTypeDeps;
	} else {
	static assert(false, "Cannot represent type in Thrift: " ~ T.stringof);
	}
	}
	}

	/**
	* Returns an IDL string describing the passed service. IDL code for any type
	* dependcies is not included.
	*/
	template serviceIdlString(T) if (isService!T) {
	enum serviceIdlString = {
	string result = "service " ~ T.stringof;
	static if (isDerivedService!T) {
	result ~= " extends " ~ BaseService!T.stringof;
	}
	result ~= " {\n";

	foreach (methodName; FilterMethodNames!(T, __traits(derivedMembers, T))) {
	result ~= " ";

	enum meta = find!`a.name == b`(T.methodMeta, methodName);

	static if (!meta.empty && meta.front.type == TMethodType.ONEWAY) {
	result ~= "oneway ";
	}

	alias ReturnType!(MemberType!(T, methodName)) RT;
	static if (is(RT == void)) {
	// We special-case this here instead of adding void to dToIdlType to
	// avoid accepting things like void[].
	result ~= "void ";
	} else {
	result ~= dToIdlType!RT ~ " ";
	}
	result ~= methodName ~ "(";

	short lastId;
	foreach (i, ParamType; ParameterTypeTuple!(MemberType!(T, methodName))) {
	static if (!meta.empty && i < meta.front.params.length) {
	enum havePM = true;
	} else {
	enum havePM = false;
	}

	short id;
	static if (havePM) {
	id = meta.front.params[i].id;
	} else {
	id = --lastId;
	}

	string paramName;
	static if (havePM) {
	paramName = meta.front.params[i].name;
	} else {
	paramName = "param" ~ to!string(i + 1);
	}

	result ~= to!string(id) ~ ": " ~ dToIdlType!ParamType ~ " " ~ paramName;

	static if (havePM && !meta.front.params[i].defaultValue.empty) {
	result ~= " = " ~ dToIdlConst(mixin(meta.front.params[i].defaultValue));
	} else {
	// Unfortunately, getting the default value for parameters from a
	// function alias isn't possible – we can't transfer the default
	// value to the IDL e.g. for interface Foo { void foo(int a = 5); }
	// without the user explicitly declaring it in metadata.
	}
	result ~= ", ";
	}
	result ~= ")";

	static if (!meta.empty && !meta.front.exceptions.empty) {
	result ~= " throws (";
	foreach (e; meta.front.exceptions) {
	result ~= to!string(e.id) ~ ": " ~ e.type ~ " " ~ e.name ~ ", ";
	}
	result ~= ")";
	}

	result ~= ",\n";
	}

	result ~= "}\n";
	return result;
	}();
	}

	/**
	* Returns an IDL string describing the passed enum. IDL code for any type
	* dependcies is not included.
	*/
	template enumIdlString(T) if (isEnum!T) {
	enum enumIdlString = {
	static assert(is(OriginalType!T : long),
	"Can only have integer enums in Thrift (not " ~ OriginalType!T.stringof ~
	", for " ~ T.stringof ~ ").");

	string result = "enum " ~ T.stringof ~ " {\n";

	foreach (name; __traits(derivedMembers, T)) {
	result ~= " " ~ name ~ " = " ~ dToIdlConst(GetMember!(T, name)) ~ ",\n";
	}

	result ~= "}\n";
	return result;
	}();
	}

	/**
	* Returns an IDL string describing the passed struct. IDL code for any type
	* dependcies is not included.
	*/
	template structIdlString(T) if (isStruct!T \|\| isException!T) {
	enum structIdlString = {
	mixin({
	string code = "";
	foreach (field; getFieldMeta!T) {
	code ~= "static assert(is(MemberType!(T, `" ~ field.name ~ "`)));\n";
	}
	return code;
	}());

	string result;
	static if (isException!T) {
	result = "exception ";
	} else {
	result = "struct ";
	}
	result ~= T.stringof ~ " {\n";

	// The last automatically assigned id – fields with no meta information
	// are assigned (in lexical order) descending negative ids, starting with
	// -1, just like the Thrift compiler does.
	short lastId;

	foreach (name; FieldNames!T) {
	enum meta = find!`a.name == b`(getFieldMeta!T, name);

	static if (meta.empty \|\| meta.front.req != TReq.IGNORE) {
	short id;
	static if (meta.empty) {
	id = --lastId;
	} else {
	id = meta.front.id;
	}

	result ~= " " ~ to!string(id) ~ ":";
	static if (!meta.empty) {
	result ~= dToIdlReq(meta.front.req);
	}
	result ~= " " ~ dToIdlType!(MemberType!(T, name)) ~ " " ~ name;

	static if (!meta.empty && !meta.front.defaultValue.empty) {
	result ~= " = " ~ dToIdlConst(mixin(meta.front.defaultValue));
	} else static if (__traits(compiles, fieldInitA!(T, name))) {
	static if (is(typeof(fieldInitA!(T, name))) &&
	!is(typeof(fieldInitA!(T, name)) == void)
	) {
	result ~= " = " ~ dToIdlConst(fieldInitA!(T, name));
	}
	} else static if (is(typeof(fieldInitB!(T, name))) &&
	!is(typeof(fieldInitB!(T, name)) == void)
	) {
	result ~= " = " ~ dToIdlConst(fieldInitB!(T, name));
	}
	result ~= ",\n";
	}
	}

	result ~= "}\n";
	return result;
	}();
	}

	private {
	// This very convoluted way of doing things was chosen because putting the
	// static if directly into structIdlString caused »not evaluatable at compile
	// time« errors to slip through even though typeof() was used, resp. the
	// condition to be true even though the value couldn't actually be read at
	// compile time due to a @@BUG@@ in DMD 2.055.
	// The extra »compiled« field in fieldInitA is needed because we must not try
	// to use != if !is compiled as well (but was false), e.g. for floating point
	// types.
	template fieldInitA(T, string name) {
	static if (mixin("T.init." ~ name) !is MemberType!(T, name).init) {
	enum fieldInitA = mixin("T.init." ~ name);
	}
	}

	template fieldInitB(T, string name) {
	static if (mixin("T.init." ~ name) != MemberType!(T, name).init) {
	enum fieldInitB = mixin("T.init." ~ name);
	}
	}

	template dToIdlType(T) {
	static if (is(FullyUnqual!T == bool)) {
	enum dToIdlType = "bool";
	} else static if (is(FullyUnqual!T == byte)) {
	enum dToIdlType = "byte";
	} else static if (is(FullyUnqual!T == double)) {
	enum dToIdlType = "double";
	} else static if (is(FullyUnqual!T == short)) {
	enum dToIdlType = "i16";
	} else static if (is(FullyUnqual!T == int)) {
	enum dToIdlType = "i32";
	} else static if (is(FullyUnqual!T == long)) {
	enum dToIdlType = "i64";
	} else static if (is(FullyUnqual!T : string)) {
	enum dToIdlType = "string";
	} else static if (is(FullyUnqual!T _ : U[], U)) {
	enum dToIdlType = "list<" ~ dToIdlType!U ~ ">";
	} else static if (is(FullyUnqual!T _ : V[K], K, V)) {
	enum dToIdlType = "map<" ~ dToIdlType!K ~ ", " ~ dToIdlType!V ~ ">";
	} else static if (is(FullyUnqual!T _ : HashSet!E, E)) {
	enum dToIdlType = "set<" ~ dToIdlType!E ~ ">";
	} else static if (is(FullyUnqual!T == struct) \|\| is(FullyUnqual!T == enum) \|\|
	is(FullyUnqual!T : TException)
	) {
	enum dToIdlType = FullyUnqual!(T).stringof;
	} else {
	static assert(false, "Cannot represent type in Thrift: " ~ T.stringof);
	}
	}

	string dToIdlReq(TReq req) {
	switch (req) {
	case TReq.REQUIRED: return " required";
	case TReq.OPTIONAL: return " optional";
	default: return "";
	}
	}

	string dToIdlConst(T)(T value) {
	static if (is(FullyUnqual!T == bool)) {
	return value ? "1" : "0";
	} else static if (is(FullyUnqual!T == byte) \|\|
	is(FullyUnqual!T == short) \|\| is(FullyUnqual!T == int) \|\|
	is(FullyUnqual!T == long)
	) {
	return to!string(value);
	} else static if (is(FullyUnqual!T : string)) {
	return `"` ~ to!string(value) ~ `"`;
	} else static if (is(FullyUnqual!T == double)) {
	return ctfeToString(value);
	} else static if (is(FullyUnqual!T _ : U[], U) \|\|
	is(FullyUnqual!T _ : HashSet!E, E)
	) {
	string result = "[";
	foreach (e; value) {
	result ~= dToIdlConst(e) ~ ", ";
	}
	result ~= "]";
	return result;
	} else static if (is(FullyUnqual!T _ : V[K], K, V)) {
	string result = "{";
	foreach (key, val; value) {
	result ~= dToIdlConst(key) ~ ": " ~ dToIdlConst(val) ~ ", ";
	}
	result ~= "}";
	return result;
	} else static if (is(FullyUnqual!T == enum)) {
	import std.conv;
	import std.traits;
	return to!string(cast(OriginalType!T)value);
	} else static if (is(FullyUnqual!T == struct) \|\|
	is(FullyUnqual!T : TException)
	) {
	string result = "{";
	foreach (name; __traits(derivedMembers, T)) {
	static if (memberReq!(T, name) != TReq.IGNORE) {
	result ~= name ~ ": " ~ dToIdlConst(mixin("value." ~ name)) ~ ", ";
	}
	}
	result ~= "}";
	return result;
	} else {
	static assert(false, "Cannot represent type in Thrift: " ~ T.stringof);
	}
	}
	}

	version (unittest) {
	enum Foo {
	a = 1,
	b = 10,
	c = 5
	}

	static assert(enumIdlString!Foo ==
	`enum Foo {
	a = 1,
	b = 10,
	c = 5,
	}
	`);
	}


	version (unittest) {
	struct WithoutMeta {
	string a;
	int b;
	}

	struct WithDefaults {
	string a = "asdf";
	double b = 3.1415;
	WithoutMeta c;

	mixin TStructHelpers!([
	TFieldMeta("c", 1, TReq.init, `WithoutMeta("foo", 3)`)
	]);
	}

	// These are from DebugProtoTest.thrift.
	struct OneOfEach {
	bool im_true;
	bool im_false;
	byte a_bite;
	short integer16;
	int integer32;
	long integer64;
	double double_precision;
	string some_characters;
	string zomg_unicode;
	bool what_who;
	string base64;
	byte[] byte_list;
	short[] i16_list;
	long[] i64_list;

	mixin TStructHelpers!([
	TFieldMeta(`im_true`, 1),
	TFieldMeta(`im_false`, 2),
	TFieldMeta(`a_bite`, 3, TReq.OPT_IN_REQ_OUT, q{cast(byte)127}),
	TFieldMeta(`integer16`, 4, TReq.OPT_IN_REQ_OUT, q{cast(short)32767}),
	TFieldMeta(`integer32`, 5),
	TFieldMeta(`integer64`, 6, TReq.OPT_IN_REQ_OUT, q{10000000000L}),
	TFieldMeta(`double_precision`, 7),
	TFieldMeta(`some_characters`, 8),
	TFieldMeta(`zomg_unicode`, 9),
	TFieldMeta(`what_who`, 10),
	TFieldMeta(`base64`, 11),
	TFieldMeta(`byte_list`, 12, TReq.OPT_IN_REQ_OUT, q{{
	byte[] v;
	v ~= cast(byte)1;
	v ~= cast(byte)2;
	v ~= cast(byte)3;
	return v;
	}()}),
	TFieldMeta(`i16_list`, 13, TReq.OPT_IN_REQ_OUT, q{{
	short[] v;
	v ~= cast(short)1;
	v ~= cast(short)2;
	v ~= cast(short)3;
	return v;
	}()}),
	TFieldMeta(`i64_list`, 14, TReq.OPT_IN_REQ_OUT, q{{
	long[] v;
	v ~= 1L;
	v ~= 2L;
	v ~= 3L;
	return v;
	}()})
	]);
	}

	struct Bonk {
	int type;
	string message;

	mixin TStructHelpers!([
	TFieldMeta(`type`, 1),
	TFieldMeta(`message`, 2)
	]);
	}

	struct HolyMoley {
	OneOfEach[] big;
	HashSet!(string[]) contain;
	Bonk[][string] bonks;

	mixin TStructHelpers!([
	TFieldMeta(`big`, 1),
	TFieldMeta(`contain`, 2),
	TFieldMeta(`bonks`, 3)
	]);
	}

	static assert(structIdlString!WithoutMeta ==
	`struct WithoutMeta {
	-1: string a,
	-2: i32 b,
	}
	`);

	import std.algorithm;
	static assert(structIdlString!WithDefaults.startsWith(
	`struct WithDefaults {
	-1: string a = "asdf",
	-2: double b = 3.141`));

	static assert(structIdlString!WithDefaults.endsWith(
	`1: WithoutMeta c = {a: "foo", b: 3, },
	}
	`));

	static assert(structIdlString!OneOfEach ==
	`struct OneOfEach {
	1: bool im_true,
	2: bool im_false,
	3: byte a_bite = 127,
	4: i16 integer16 = 32767,
	5: i32 integer32,
	6: i64 integer64 = 10000000000,
	7: double double_precision,
	8: string some_characters,
	9: string zomg_unicode,
	10: bool what_who,
	11: string base64,
	12: list<byte> byte_list = [1, 2, 3, ],
	13: list<i16> i16_list = [1, 2, 3, ],
	14: list<i64> i64_list = [1, 2, 3, ],
	}
	`);

	static assert(structIdlString!Bonk ==
	`struct Bonk {
	1: i32 type,
	2: string message,
	}
	`);

	static assert(structIdlString!HolyMoley ==
	`struct HolyMoley {
	1: list<OneOfEach> big,
	2: set<list<string>> contain,
	3: map<string, list<Bonk>> bonks,
	}
	`);
	}

	version (unittest) {
	class ExceptionWithAMap : TException {
	string blah;
	string[string] map_field;

	mixin TStructHelpers!([
	TFieldMeta(`blah`, 1),
	TFieldMeta(`map_field`, 2)
	]);
	}

	interface Srv {
	void voidMethod();
	int primitiveMethod();
	OneOfEach structMethod();
	void methodWithDefaultArgs(int something);
	void onewayMethod();
	void exceptionMethod();

	alias .ExceptionWithAMap ExceptionWithAMap;

	enum methodMeta = [
	TMethodMeta(`methodWithDefaultArgs`,
	[TParamMeta(`something`, 1, q{2})]
	),
	TMethodMeta(`onewayMethod`,
	[],
	[],
	TMethodType.ONEWAY
	),
	TMethodMeta(`exceptionMethod`,
	[],
	[
	TExceptionMeta("a", 1, "ExceptionWithAMap"),
	TExceptionMeta("b", 2, "ExceptionWithAMap")
	]
	)
	];
	}

	interface ChildSrv : Srv {
	int childMethod(int arg);
	}

	static assert(idlString!ChildSrv ==
	`exception ExceptionWithAMap {
	1: string blah,
	2: map<string, string> map_field,
	}

	struct OneOfEach {
	1: bool im_true,
	2: bool im_false,
	3: byte a_bite = 127,
	4: i16 integer16 = 32767,
	5: i32 integer32,
	6: i64 integer64 = 10000000000,
	7: double double_precision,
	8: string some_characters,
	9: string zomg_unicode,
	10: bool what_who,
	11: string base64,
	12: list<byte> byte_list = [1, 2, 3, ],
	13: list<i16> i16_list = [1, 2, 3, ],
	14: list<i64> i64_list = [1, 2, 3, ],
	}

	service Srv {
	void voidMethod(),
	i32 primitiveMethod(),
	OneOfEach structMethod(),
	void methodWithDefaultArgs(1: i32 something = 2, ),
	oneway void onewayMethod(),
	void exceptionMethod() throws (1: ExceptionWithAMap a, 2: ExceptionWithAMap b, ),
	}

	service ChildSrv extends Srv {
	i32 childMethod(-1: i32 param1, ),
	}
	`);
	}