Generate Mojom Types in Dart (Take 2)

mojo/dart/packages/_mojo_for_test_only/lib/regression_tests/regression_tests.mojom.dart

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 library regression_tests_mojom;
 
 import 'dart:async';
+import 'dart:collection';
 
 import 'package:mojo/bindings.dart' as bindings;
 import 'package:mojo/core.dart' as core;
+import 'package:mojo/mojo/bindings/types/mojom_types.mojom.dart' as mojom_types;
+import 'package:mojo/mojo/bindings/types/service_describer.mojom.dart' as service_describer;
 
 class EnumWithReference extends bindings.MojoEnum {
   static const EnumWithReference kStereoAndKeyboardMic = const EnumWithReference._(30);
   static const EnumWithReference kMax = const EnumWithReference._(30);
 
   const EnumWithReference._(int v) : super(v);
 
   static const Map<String, EnumWithReference> valuesMap = const {
     "kStereoAndKeyboardMic": kStereoAndKeyboardMic,
     "kMax": kMax,
@@ skipping 25 matching lines @@
     }
     return result;
   }
 
   String toString() {
     switch(this) {
       case kStereoAndKeyboardMic:
         return 'EnumWithReference.kStereoAndKeyboardMic';
       case kMax:
         return 'EnumWithReference.kMax';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+mojom_types.MojomEnum _regressionTestsEnumWithReference() {
+  return new mojom_types.MojomEnum()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'EnumWithReference'
+      ..fullIdentifier = 'regression_tests.EnumWithReference')
+    ..values = <mojom_types.EnumValue>[
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'KStereoAndKeyboardMic')
+        ..enumTypeKey = 'regression_tests_EnumWithReference__'
+        ..intValue = 30,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'KMax')
+        ..enumTypeKey = 'regression_tests_EnumWithReference__'
+        ..intValue = 30,];
+}
+
 class EnumWithLowercase extends bindings.MojoEnum {
   static const EnumWithLowercase planarF16 = const EnumWithLowercase._(0);
   static const EnumWithLowercase planarF32 = const EnumWithLowercase._(1);
 
   const EnumWithLowercase._(int v) : super(v);
 
   static const Map<String, EnumWithLowercase> valuesMap = const {
     "planarF16": planarF16,
     "planarF32": planarF32,
   };
@@ skipping 24 matching lines @@
     }
     return result;
   }
 
   String toString() {
     switch(this) {
       case planarF16:
         return 'EnumWithLowercase.planarF16';
       case planarF32:
         return 'EnumWithLowercase.planarF32';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+mojom_types.MojomEnum _regressionTestsEnumWithLowercase() {
+  return new mojom_types.MojomEnum()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'EnumWithLowercase'
+      ..fullIdentifier = 'regression_tests.EnumWithLowercase')
+    ..values = <mojom_types.EnumValue>[
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'PlanarF16')
+        ..enumTypeKey = 'regression_tests_EnumWithLowercase__'
+        ..intValue = 0,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'PlanarF32')
+        ..enumTypeKey = 'regression_tests_EnumWithLowercase__'
+        ..intValue = 1,];
+}
+
 class EnumWithNumbers extends bindings.MojoEnum {
   static const EnumWithNumbers k21 = const EnumWithNumbers._(4);
 
   const EnumWithNumbers._(int v) : super(v);
 
   static const Map<String, EnumWithNumbers> valuesMap = const {
     "k21": k21,
   };
   static const List<EnumWithNumbers> values = const [
     k21,
@@ skipping 17 matching lines @@
       throw new bindings.MojoCodecError(
           'Bad value $v for enum EnumWithNumbers.');
     }
     return result;
   }
 
   String toString() {
     switch(this) {
       case k21:
         return 'EnumWithNumbers.k21';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+mojom_types.MojomEnum _regressionTestsEnumWithNumbers() {
+  return new mojom_types.MojomEnum()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'EnumWithNumbers'
+      ..fullIdentifier = 'regression_tests.EnumWithNumbers')
+    ..values = <mojom_types.EnumValue>[
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'K21')
+        ..enumTypeKey = 'regression_tests_EnumWithNumbers__'
+        ..intValue = 4,];
+}
+
 class EnumWithK extends bindings.MojoEnum {
   static const EnumWithK k = const EnumWithK._(0);
 
   const EnumWithK._(int v) : super(v);
 
   static const Map<String, EnumWithK> valuesMap = const {
     "k": k,
   };
   static const List<EnumWithK> values = const [
     k,
@@ skipping 17 matching lines @@
       throw new bindings.MojoCodecError(
           'Bad value $v for enum EnumWithK.');
     }
     return result;
   }
 
   String toString() {
     switch(this) {
       case k:
         return 'EnumWithK.k';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+mojom_types.MojomEnum _regressionTestsEnumWithK() {
+  return new mojom_types.MojomEnum()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'EnumWithK'
+      ..fullIdentifier = 'regression_tests.EnumWithK')
+    ..values = <mojom_types.EnumValue>[
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'K')
+        ..enumTypeKey = 'regression_tests_EnumWithK__'
+        ..intValue = 0,];
+}
+
 class EnumWithInternalAllCaps extends bindings.MojoEnum {
   static const EnumWithInternalAllCaps standard = const EnumWithInternalAllCaps._(0);
   static const EnumWithInternalAllCaps fullscreen = const EnumWithInternalAllCaps._(1);
   static const EnumWithInternalAllCaps immersive = const EnumWithInternalAllCaps._(2);
 
   const EnumWithInternalAllCaps._(int v) : super(v);
 
   static const Map<String, EnumWithInternalAllCaps> valuesMap = const {
     "standard": standard,
     "fullscreen": fullscreen,
@@ skipping 31 matching lines @@
   }
 
   String toString() {
     switch(this) {
       case standard:
         return 'EnumWithInternalAllCaps.standard';
       case fullscreen:
         return 'EnumWithInternalAllCaps.fullscreen';
       case immersive:
         return 'EnumWithInternalAllCaps.immersive';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+mojom_types.MojomEnum _regressionTestsEnumWithInternalAllCaps() {
+  return new mojom_types.MojomEnum()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'EnumWithInternalAllCaps'
+      ..fullIdentifier = 'regression_tests.EnumWithINTERNALAllCaps')
+    ..values = <mojom_types.EnumValue>[
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Standard')
+        ..enumTypeKey = 'regression_tests_EnumWithINTERNALAllCaps__'
+        ..intValue = 0,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Fullscreen')
+        ..enumTypeKey = 'regression_tests_EnumWithINTERNALAllCaps__'
+        ..intValue = 1,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Immersive')
+        ..enumTypeKey = 'regression_tests_EnumWithINTERNALAllCaps__'
+        ..intValue = 2,];
+}
+
 class NormalEnum extends bindings.MojoEnum {
   static const NormalEnum first = const NormalEnum._(0);
   static const NormalEnum second = const NormalEnum._(1);
 
   const NormalEnum._(int v) : super(v);
 
   static const Map<String, NormalEnum> valuesMap = const {
     "first": first,
     "second": second,
   };
@@ skipping 24 matching lines @@
     }
     return result;
   }
 
   String toString() {
     switch(this) {
       case first:
         return 'NormalEnum.first';
       case second:
         return 'NormalEnum.second';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+mojom_types.MojomEnum _regressionTestsNormalEnum() {
+  return new mojom_types.MojomEnum()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'NormalEnum'
+      ..fullIdentifier = 'regression_tests.NormalEnum')
+    ..values = <mojom_types.EnumValue>[
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'First')
+        ..enumTypeKey = 'regression_tests_NormalEnum__'
+        ..intValue = 0,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Second')
+        ..enumTypeKey = 'regression_tests_NormalEnum__'
+        ..intValue = 1,];
+}
+
 class CamelCaseTestEnum extends bindings.MojoEnum {
   static const CamelCaseTestEnum boolThing = const CamelCaseTestEnum._(0);
   static const CamelCaseTestEnum doubleThing = const CamelCaseTestEnum._(1);
   static const CamelCaseTestEnum floatThing = const CamelCaseTestEnum._(2);
   static const CamelCaseTestEnum int8Thing = const CamelCaseTestEnum._(3);
   static const CamelCaseTestEnum int16Thing = const CamelCaseTestEnum._(4);
   static const CamelCaseTestEnum int32Th1Ng = const CamelCaseTestEnum._(5);
   static const CamelCaseTestEnum int64Th1ng = const CamelCaseTestEnum._(6);
   static const CamelCaseTestEnum uint8TH1ng = const CamelCaseTestEnum._(7);
   static const CamelCaseTestEnum uint16tH1Ng = const CamelCaseTestEnum._(8);
@@ skipping 87 matching lines @@
       case int64Th1ng:
         return 'CamelCaseTestEnum.int64Th1ng';
       case uint8TH1ng:
         return 'CamelCaseTestEnum.uint8TH1ng';
       case uint16tH1Ng:
         return 'CamelCaseTestEnum.uint16tH1Ng';
       case uint32Th1ng:
         return 'CamelCaseTestEnum.uint32Th1ng';
       case uint64Th1Ng:
         return 'CamelCaseTestEnum.uint64Th1Ng';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+mojom_types.MojomEnum _regressionTestsCamelCaseTestEnum() {
+  return new mojom_types.MojomEnum()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CamelCaseTestEnum'
+      ..fullIdentifier = 'regression_tests.CamelCaseTestEnum')
+    ..values = <mojom_types.EnumValue>[
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'BoolThing')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 0,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'DoubleThing')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 1,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'FloatThing')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 2,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Int8Thing')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 3,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Int16Thing')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 4,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Int32Th1Ng')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 5,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Int64Th1ng')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 6,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Uint8TH1ng')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 7,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Uint16tH1Ng')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 8,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Uint32Th1ng')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 9,
+      new mojom_types.EnumValue()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Uint64Th1Ng')
+        ..enumTypeKey = 'regression_tests_CamelCaseTestEnum__'
+        ..intValue = 10,];
+}
+
 
 
 class Edge extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   Vertex v = null;
 
   Edge() : super(kVersions.last.size);
 
@@ skipping 49 matching lines @@
            "v: $v" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["v"] = v;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsEdge() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'Edge'
+      ..fullIdentifier = 'regression_tests.Edge')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'V')
+        ..type = (new mojom_types.Type()
+          ..typeReference = (new mojom_types.TypeReference()
+          ..nullable = true
+        
+          ..identifier = 'regression_tests_Vertex__'
+          ..typeKey = 'regression_tests_Vertex__'
+        )),];
+}
+
 
 class Vertex extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   EmptyStruct e = null;
 
   Vertex() : super(kVersions.last.size);
 
   static Vertex deserialize(bindings.Message message) {
@@ skipping 48 matching lines @@
            "e: $e" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["e"] = e;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsVertex() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'Vertex'
+      ..fullIdentifier = 'regression_tests.Vertex')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'E')
+        ..type = (new mojom_types.Type()
+          ..typeReference = (new mojom_types.TypeReference()
+          ..nullable = true
+        
+          ..identifier = 'regression_tests_EmptyStruct__'
+          ..typeKey = 'regression_tests_EmptyStruct__'
+        )),];
+}
+
 
 class EmptyStruct extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   EmptyStruct() : super(kVersions.last.size);
 
   static EmptyStruct deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 38 matching lines @@
   String toString() {
     return "EmptyStruct("")";
   }
 
   Map toJson() {
     Map map = new Map();
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsEmptyStruct() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'EmptyStruct'
+      ..fullIdentifier = 'regression_tests.EmptyStruct')
+    ..fields = <mojom_types.StructField>[];
+}
+
 
 class A extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   B b = null;
 
   A() : super(kVersions.last.size);
 
   static A deserialize(bindings.Message message) {
@@ skipping 48 matching lines @@
            "b: $b" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["b"] = b;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsA() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'A'
+      ..fullIdentifier = 'regression_tests.A')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'B')
+        ..type = (new mojom_types.Type()
+          ..typeReference = (new mojom_types.TypeReference()
+          ..nullable = true
+        
+          ..identifier = 'regression_tests_B__'
+          ..typeKey = 'regression_tests_B__'
+        )),];
+}
+
 
 class B extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   A a = null;
 
   B() : super(kVersions.last.size);
 
   static B deserialize(bindings.Message message) {
@@ skipping 48 matching lines @@
            "a: $a" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["a"] = a;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsB() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'B'
+      ..fullIdentifier = 'regression_tests.B')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'A')
+        ..type = (new mojom_types.Type()
+          ..typeReference = (new mojom_types.TypeReference()
+          ..nullable = true
+        
+          ..identifier = 'regression_tests_A__'
+          ..typeKey = 'regression_tests_A__'
+        )),];
+}
+
 
 class StructWithHandleCalledHandles extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   core.MojoHandle handles = null;
 
   StructWithHandleCalledHandles() : super(kVersions.last.size);
 
   static StructWithHandleCalledHandles deserialize(bindings.Message message) {
@@ skipping 46 matching lines @@
     return "StructWithHandleCalledHandles("
            "handles: $handles" ")";
   }
 
   Map toJson() {
     throw new bindings.MojoCodecError(
         'Object containing handles cannot be encoded to JSON.');
   }
 }
 
+mojom_types.MojomStruct _regressionTestsStructWithHandleCalledHandles() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'StructWithHandleCalledHandles'
+      ..fullIdentifier = 'regression_tests.StructWithHandleCalledHandles')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Handles')
+        ..type = (new mojom_types.Type()
+          ..handleType = (new mojom_types.HandleType()
+            ..kind = mojom_types.HandleTypeKind.unspecified)),];
+}
+
 
 class StructWithArrayOfHandlesCalledHandles extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   List<core.MojoHandle> handles = null;
 
   StructWithArrayOfHandlesCalledHandles() : super(kVersions.last.size);
 
   static StructWithArrayOfHandlesCalledHandles deserialize(bindings.Message message) {
@@ skipping 46 matching lines @@
     return "StructWithArrayOfHandlesCalledHandles("
            "handles: $handles" ")";
   }
 
   Map toJson() {
     throw new bindings.MojoCodecError(
         'Object containing handles cannot be encoded to JSON.');
   }
 }
 
+mojom_types.MojomStruct _regressionTestsStructWithArrayOfHandlesCalledHandles() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'StructWithArrayOfHandlesCalledHandles'
+      ..fullIdentifier = 'regression_tests.StructWithArrayOfHandlesCalledHandles')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Handles')
+        ..type = (new mojom_types.Type()
+          ..arrayType = (new mojom_types.ArrayType()
+            ..elementType = (new mojom_types.Type()
+                    ..handleType = (new mojom_types.HandleType()
+                      ..kind = mojom_types.HandleTypeKind.unspecified)))),];
+}
+
 
 class StructWithInterfaceCalledHandles extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   Object handles = null;
 
   StructWithInterfaceCalledHandles() : super(kVersions.last.size);
 
   static StructWithInterfaceCalledHandles deserialize(bindings.Message message) {
@@ skipping 46 matching lines @@
     return "StructWithInterfaceCalledHandles("
            "handles: $handles" ")";
   }
 
   Map toJson() {
     throw new bindings.MojoCodecError(
         'Object containing handles cannot be encoded to JSON.');
   }
 }
 
+mojom_types.MojomStruct _regressionTestsStructWithInterfaceCalledHandles() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'StructWithInterfaceCalledHandles'
+      ..fullIdentifier = 'regression_tests.StructWithInterfaceCalledHandles')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Handles')
+        ..type = (new mojom_types.Type()
+          ..typeReference = (new mojom_types.TypeReference()
+          ..identifier = 'regression_tests_TestInterface__'
+          ..typeKey = 'regression_tests_TestInterface__'
+        )),];
+}
+
 
 class ContainsArrayOfEnum extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   List<NormalEnum> arrayOfEnums = null;
 
   ContainsArrayOfEnum() : super(kVersions.last.size);
 
   static ContainsArrayOfEnum deserialize(bindings.Message message) {
@@ skipping 59 matching lines @@
            "arrayOfEnums: $arrayOfEnums" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["arrayOfEnums"] = arrayOfEnums;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsContainsArrayOfEnum() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'ContainsArrayOfEnum'
+      ..fullIdentifier = 'regression_tests.ContainsArrayOfEnum')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'ArrayOfEnums')
+        ..type = (new mojom_types.Type()
+          ..arrayType = (new mojom_types.ArrayType()
+            ..elementType = (new mojom_types.Type()
+                    ..typeReference = (new mojom_types.TypeReference()
+                    ..identifier = 'regression_tests_NormalEnum__'
+                    ..typeKey = 'regression_tests_NormalEnum__'
+                  )))),];
+}
+
 
 class _CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseParams() : super(kVersions.last.size);
 
   static _CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 38 matching lines @@
   String toString() {
     return "_CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsCheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseParams'
+      ..fullIdentifier = 'regression_tests.CheckMethodWithEmptyResponse_WithoutParameterAndEmptyResponse_Params')
+    ..fields = <mojom_types.StructField>[];
+}
+
 
 class CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseResponseParams() : super(kVersions.last.size);
 
   static CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 38 matching lines @@
   String toString() {
     return "CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseResponseParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsCheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseResponseParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseResponseParams'
+      ..fullIdentifier = 'regression_tests.CheckMethodWithEmptyResponse_WithoutParameterAndEmptyResponse_ResponseParams')
+    ..fields = <mojom_types.StructField>[];
+}
+
 
 class _CheckMethodWithEmptyResponseWithParameterAndEmptyResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   bool b = false;
 
   _CheckMethodWithEmptyResponseWithParameterAndEmptyResponseParams() : super(kVersions.last.size);
 
   static _CheckMethodWithEmptyResponseWithParameterAndEmptyResponseParams deserialize(bindings.Message message) {
@@ skipping 47 matching lines @@
            "b: $b" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["b"] = b;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsCheckMethodWithEmptyResponseWithParameterAndEmptyResponseParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CheckMethodWithEmptyResponseWithParameterAndEmptyResponseParams'
+      ..fullIdentifier = 'regression_tests.CheckMethodWithEmptyResponse_WithParameterAndEmptyResponse_Params')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'B')
+        ..type = (new mojom_types.Type()
+          ..simpleType = mojom_types.SimpleType.bool),];
+}
+
 
 class CheckMethodWithEmptyResponseWithParameterAndEmptyResponseResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   CheckMethodWithEmptyResponseWithParameterAndEmptyResponseResponseParams() : super(kVersions.last.size);
 
   static CheckMethodWithEmptyResponseWithParameterAndEmptyResponseResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 38 matching lines @@
   String toString() {
     return "CheckMethodWithEmptyResponseWithParameterAndEmptyResponseResponseParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsCheckMethodWithEmptyResponseWithParameterAndEmptyResponseResponseParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CheckMethodWithEmptyResponseWithParameterAndEmptyResponseResponseParams'
+      ..fullIdentifier = 'regression_tests.CheckMethodWithEmptyResponse_WithParameterAndEmptyResponse_ResponseParams')
+    ..fields = <mojom_types.StructField>[];
+}
+
 
 class _CheckNameCollisionWithNameCollisionParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   bool message = false;
   bool response = false;
 
   _CheckNameCollisionWithNameCollisionParams() : super(kVersions.last.size);
 
@@ skipping 56 matching lines @@
   }
 
   Map toJson() {
     Map map = new Map();
     map["message"] = message;
     map["response"] = response;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsCheckNameCollisionWithNameCollisionParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CheckNameCollisionWithNameCollisionParams'
+      ..fullIdentifier = 'regression_tests.CheckNameCollision_WithNameCollision_Params')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Message')
+        ..type = (new mojom_types.Type()
+          ..simpleType = mojom_types.SimpleType.bool),
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Response')
+        ..type = (new mojom_types.Type()
+          ..simpleType = mojom_types.SimpleType.bool),];
+}
+
 
 class CheckNameCollisionWithNameCollisionResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   bool message = false;
   bool response = false;
 
   CheckNameCollisionWithNameCollisionResponseParams() : super(kVersions.last.size);
 
@@ skipping 56 matching lines @@
   }
 
   Map toJson() {
     Map map = new Map();
     map["message"] = message;
     map["response"] = response;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsCheckNameCollisionWithNameCollisionResponseParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CheckNameCollisionWithNameCollisionResponseParams'
+      ..fullIdentifier = 'regression_tests.CheckNameCollision_WithNameCollision_ResponseParams')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Message')
+        ..type = (new mojom_types.Type()
+          ..simpleType = mojom_types.SimpleType.bool),
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Response')
+        ..type = (new mojom_types.Type()
+          ..simpleType = mojom_types.SimpleType.bool),];
+}
+
 
 class _CheckEnumCapsSetEnumWithInternalAllCapsParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   EnumWithInternalAllCaps e = null;
 
   _CheckEnumCapsSetEnumWithInternalAllCapsParams() : super(kVersions.last.size);
 
   static _CheckEnumCapsSetEnumWithInternalAllCapsParams deserialize(bindings.Message message) {
@@ skipping 51 matching lines @@
            "e: $e" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["e"] = e;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsCheckEnumCapsSetEnumWithInternalAllCapsParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CheckEnumCapsSetEnumWithInternalAllCapsParams'
+      ..fullIdentifier = 'regression_tests.CheckEnumCaps_SetEnumWithINTERNALAllCaps_Params')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'E')
+        ..type = (new mojom_types.Type()
+          ..typeReference = (new mojom_types.TypeReference()
+          ..identifier = 'regression_tests_EnumWithINTERNALAllCaps__'
+          ..typeKey = 'regression_tests_EnumWithINTERNALAllCaps__'
+        )),];
+}
+
 
 class _TestInterfaceSomeMessageParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _TestInterfaceSomeMessageParams() : super(kVersions.last.size);
 
   static _TestInterfaceSomeMessageParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 38 matching lines @@
   String toString() {
     return "_TestInterfaceSomeMessageParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsTestInterfaceSomeMessageParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'TestInterfaceSomeMessageParams'
+      ..fullIdentifier = 'regression_tests.TestInterface_SomeMessage_Params')
+    ..fields = <mojom_types.StructField>[];
+}
+
 
 class _Regression551GetParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   List<String> keyPrefixes = null;
 
   _Regression551GetParams() : super(kVersions.last.size);
 
   static _Regression551GetParams deserialize(bindings.Message message) {
@@ skipping 63 matching lines @@
            "keyPrefixes: $keyPrefixes" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["keyPrefixes"] = keyPrefixes;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsRegression551GetParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'Regression551GetParams'
+      ..fullIdentifier = 'regression_tests.Regression551_Get_Params')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'KeyPrefixes')
+        ..type = (new mojom_types.Type()
+          ..arrayType = (new mojom_types.ArrayType()
+            ..elementType = (new mojom_types.Type()
+                    ..stringType = (new mojom_types.StringType())))),];
+}
+
 
 class Regression551GetResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int result = 0;
 
   Regression551GetResponseParams() : super(kVersions.last.size);
 
   static Regression551GetResponseParams deserialize(bindings.Message message) {
@@ skipping 47 matching lines @@
            "result: $result" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["result"] = result;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsRegression551GetResponseParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'Regression551GetResponseParams'
+      ..fullIdentifier = 'regression_tests.Regression551_Get_ResponseParams')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Result')
+        ..type = (new mojom_types.Type()
+          ..simpleType = mojom_types.SimpleType.int32),];
+}
+
 
 class _ServiceNameServiceNameParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _ServiceNameServiceNameParams() : super(kVersions.last.size);
 
   static _ServiceNameServiceNameParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 38 matching lines @@
   String toString() {
     return "_ServiceNameServiceNameParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsServiceNameServiceNameParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'ServiceNameServiceNameParams'
+      ..fullIdentifier = 'regression_tests.ServiceName_serviceName_Params')
+    ..fields = <mojom_types.StructField>[];
+}
+
 
 class ServiceNameServiceNameResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   String serviceName_ = null;
 
   ServiceNameServiceNameResponseParams() : super(kVersions.last.size);
 
   static ServiceNameServiceNameResponseParams deserialize(bindings.Message message) {
@@ skipping 47 matching lines @@
            "serviceName_: $serviceName_" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["serviceName_"] = serviceName_;
     return map;
   }
 }
 
+mojom_types.MojomStruct _regressionTestsServiceNameServiceNameResponseParams() {
+  return new mojom_types.MojomStruct()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'ServiceNameServiceNameResponseParams'
+      ..fullIdentifier = 'regression_tests.ServiceName_serviceName_ResponseParams')
+    ..fields = <mojom_types.StructField>[
+      new mojom_types.StructField()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'ServiceName')
+        ..type = (new mojom_types.Type()
+          ..stringType = (new mojom_types.StringType())),];
+}
+
+
 const int _CheckMethodWithEmptyResponse_withoutParameterAndEmptyResponseName = 0;
 const int _CheckMethodWithEmptyResponse_withParameterAndEmptyResponseName = 1;
 
+mojom_types.MojomInterface _regressionTestsCheckMethodWithEmptyResponse() {
+  return new mojom_types.MojomInterface()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CheckMethodWithEmptyResponse'
+      ..fullIdentifier = 'regression_tests.CheckMethodWithEmptyResponse')
+    ..interfaceName = 'CheckMethodWithEmptyResponse'
+    ..methods = <int, mojom_types.MojomMethod>{
+      _CheckMethodWithEmptyResponse_withoutParameterAndEmptyResponseName: new mojom_types.MojomMethod()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'WithoutParameterAndEmptyResponse')
+        ..ordinal = _CheckMethodWithEmptyResponse_withoutParameterAndEmptyResponseName
+        ..responseParams = _regressionTestsCheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseResponseParams()
+        ..parameters = _regressionTestsCheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseParams(),
+      _CheckMethodWithEmptyResponse_withParameterAndEmptyResponseName: new mojom_types.MojomMethod()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'WithParameterAndEmptyResponse')
+        ..ordinal = _CheckMethodWithEmptyResponse_withParameterAndEmptyResponseName
+        ..responseParams = _regressionTestsCheckMethodWithEmptyResponseWithParameterAndEmptyResponseResponseParams()
+        ..parameters = _regressionTestsCheckMethodWithEmptyResponseWithParameterAndEmptyResponseParams(),
+    };
+}
+
+class _CheckMethodWithEmptyResponseServiceDescription implements service_describer.ServiceDescription {
+  dynamic getTopLevelInterface([Function responseFactory]) =>
+      _regressionTestsCheckMethodWithEmptyResponse();
+
+  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
+      getAllMojomTypeDefinitions()[typeKey];
+
+  dynamic getAllTypeDefinitions([Function responseFactory]) =>
+      getAllMojomTypeDefinitions();
+}
+
 abstract class CheckMethodWithEmptyResponse {
   static const String serviceName = null;
   dynamic withoutParameterAndEmptyResponse([Function responseFactory = null]);
   dynamic withParameterAndEmptyResponse(bool b,[Function responseFactory = null]);
 }
 
 
 class _CheckMethodWithEmptyResponseProxyImpl extends bindings.Proxy {
   _CheckMethodWithEmptyResponseProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _CheckMethodWithEmptyResponseProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
   _CheckMethodWithEmptyResponseProxyImpl.unbound() : super.unbound();
 
   static _CheckMethodWithEmptyResponseProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For _CheckMethodWithEmptyResponseProxyImpl"));
     return new _CheckMethodWithEmptyResponseProxyImpl.fromEndpoint(endpoint);
   }
 
+  service_describer.ServiceDescription get serviceDescription =>
+    new _CheckMethodWithEmptyResponseServiceDescription();
+
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _CheckMethodWithEmptyResponse_withoutParameterAndEmptyResponseName:
         var r = CheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
         Completer c = completerMap[message.header.requestId];
@@ skipping 218 matching lines @@
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
     return "CheckMethodWithEmptyResponseStub($superString)";
   }
 
   int get version => 0;
+
+  service_describer.ServiceDescription get serviceDescription =>
+    new _CheckMethodWithEmptyResponseServiceDescription();
 }
 
 const int _CheckNameCollision_withNameCollisionName = 0;
 
+mojom_types.MojomInterface _regressionTestsCheckNameCollision() {
+  return new mojom_types.MojomInterface()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CheckNameCollision'
+      ..fullIdentifier = 'regression_tests.CheckNameCollision')
+    ..interfaceName = 'CheckNameCollision'
+    ..methods = <int, mojom_types.MojomMethod>{
+      _CheckNameCollision_withNameCollisionName: new mojom_types.MojomMethod()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'WithNameCollision')
+        ..ordinal = _CheckNameCollision_withNameCollisionName
+        ..responseParams = _regressionTestsCheckNameCollisionWithNameCollisionResponseParams()
+        ..parameters = _regressionTestsCheckNameCollisionWithNameCollisionParams(),
+    };
+}
+
+class _CheckNameCollisionServiceDescription implements service_describer.ServiceDescription {
+  dynamic getTopLevelInterface([Function responseFactory]) =>
+      _regressionTestsCheckNameCollision();
+
+  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
+      getAllMojomTypeDefinitions()[typeKey];
+
+  dynamic getAllTypeDefinitions([Function responseFactory]) =>
+      getAllMojomTypeDefinitions();
+}
+
 abstract class CheckNameCollision {
   static const String serviceName = null;
   dynamic withNameCollision(bool message,bool response,[Function responseFactory = null]);
 }
 
 
 class _CheckNameCollisionProxyImpl extends bindings.Proxy {
   _CheckNameCollisionProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _CheckNameCollisionProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
   _CheckNameCollisionProxyImpl.unbound() : super.unbound();
 
   static _CheckNameCollisionProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For _CheckNameCollisionProxyImpl"));
     return new _CheckNameCollisionProxyImpl.fromEndpoint(endpoint);
   }
 
+  service_describer.ServiceDescription get serviceDescription =>
+    new _CheckNameCollisionServiceDescription();
+
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _CheckNameCollision_withNameCollisionName:
         var r = CheckNameCollisionWithNameCollisionResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
         Completer c = completerMap[message.header.requestId];
@@ skipping 167 matching lines @@
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
     return "CheckNameCollisionStub($superString)";
   }
 
   int get version => 0;
+
+  service_describer.ServiceDescription get serviceDescription =>
+    new _CheckNameCollisionServiceDescription();
 }
 
 const int _CheckEnumCaps_setEnumWithInternalAllCapsName = 0;
 
+mojom_types.MojomInterface _regressionTestsCheckEnumCaps() {
+  return new mojom_types.MojomInterface()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'CheckEnumCaps'
+      ..fullIdentifier = 'regression_tests.CheckEnumCaps')
+    ..interfaceName = 'CheckEnumCaps'
+    ..methods = <int, mojom_types.MojomMethod>{
+      _CheckEnumCaps_setEnumWithInternalAllCapsName: new mojom_types.MojomMethod()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'SetEnumWithInternalAllCaps')
+        ..ordinal = _CheckEnumCaps_setEnumWithInternalAllCapsName
+        ..parameters = _regressionTestsCheckEnumCapsSetEnumWithInternalAllCapsParams(),
+    };
+}
+
+class _CheckEnumCapsServiceDescription implements service_describer.ServiceDescription {
+  dynamic getTopLevelInterface([Function responseFactory]) =>
+      _regressionTestsCheckEnumCaps();
+
+  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
+      getAllMojomTypeDefinitions()[typeKey];
+
+  dynamic getAllTypeDefinitions([Function responseFactory]) =>
+      getAllMojomTypeDefinitions();
+}
+
 abstract class CheckEnumCaps {
   static const String serviceName = null;
   void setEnumWithInternalAllCaps(EnumWithInternalAllCaps e);
 }
 
 
 class _CheckEnumCapsProxyImpl extends bindings.Proxy {
   _CheckEnumCapsProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _CheckEnumCapsProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
   _CheckEnumCapsProxyImpl.unbound() : super.unbound();
 
   static _CheckEnumCapsProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For _CheckEnumCapsProxyImpl"));
     return new _CheckEnumCapsProxyImpl.fromEndpoint(endpoint);
   }
 
+  service_describer.ServiceDescription get serviceDescription =>
+    new _CheckEnumCapsServiceDescription();
+
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
   String toString() {
@@ skipping 123 matching lines @@
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
     return "CheckEnumCapsStub($superString)";
   }
 
   int get version => 0;
+
+  service_describer.ServiceDescription get serviceDescription =>
+    new _CheckEnumCapsServiceDescription();
 }
 
 const int _TestInterface_someMessageName = 0;
 
+mojom_types.MojomInterface _regressionTestsTestInterface() {
+  return new mojom_types.MojomInterface()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'TestInterface'
+      ..fullIdentifier = 'regression_tests.TestInterface')
+    ..interfaceName = 'TestInterface'
+    ..methods = <int, mojom_types.MojomMethod>{
+      _TestInterface_someMessageName: new mojom_types.MojomMethod()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'SomeMessage')
+        ..ordinal = _TestInterface_someMessageName
+        ..parameters = _regressionTestsTestInterfaceSomeMessageParams(),
+    };
+}
+
+class _TestInterfaceServiceDescription implements service_describer.ServiceDescription {
+  dynamic getTopLevelInterface([Function responseFactory]) =>
+      _regressionTestsTestInterface();
+
+  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
+      getAllMojomTypeDefinitions()[typeKey];
+
+  dynamic getAllTypeDefinitions([Function responseFactory]) =>
+      getAllMojomTypeDefinitions();
+}
+
 abstract class TestInterface {
   static const String serviceName = null;
   void someMessage();
 }
 
 
 class _TestInterfaceProxyImpl extends bindings.Proxy {
   _TestInterfaceProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _TestInterfaceProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
   _TestInterfaceProxyImpl.unbound() : super.unbound();
 
   static _TestInterfaceProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For _TestInterfaceProxyImpl"));
     return new _TestInterfaceProxyImpl.fromEndpoint(endpoint);
   }
 
+  service_describer.ServiceDescription get serviceDescription =>
+    new _TestInterfaceServiceDescription();
+
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
   String toString() {
@@ skipping 122 matching lines @@
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
     return "TestInterfaceStub($superString)";
   }
 
   int get version => 0;
+
+  service_describer.ServiceDescription get serviceDescription =>
+    new _TestInterfaceServiceDescription();
 }
 
 const int _Regression551_getName = 0;
 
+mojom_types.MojomInterface _regressionTestsRegression551() {
+  return new mojom_types.MojomInterface()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'Regression551'
+      ..fullIdentifier = 'regression_tests.Regression551')
+    ..interfaceName = 'Regression551'
+    ..methods = <int, mojom_types.MojomMethod>{
+      _Regression551_getName: new mojom_types.MojomMethod()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'Get')
+        ..ordinal = _Regression551_getName
+        ..responseParams = _regressionTestsRegression551GetResponseParams()
+        ..parameters = _regressionTestsRegression551GetParams(),
+    };
+}
+
+class _Regression551ServiceDescription implements service_describer.ServiceDescription {
+  dynamic getTopLevelInterface([Function responseFactory]) =>
+      _regressionTestsRegression551();
+
+  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
+      getAllMojomTypeDefinitions()[typeKey];
+
+  dynamic getAllTypeDefinitions([Function responseFactory]) =>
+      getAllMojomTypeDefinitions();
+}
+
 abstract class Regression551 {
   static const String serviceName = null;
   dynamic get(List<String> keyPrefixes,[Function responseFactory = null]);
 }
 
 
 class _Regression551ProxyImpl extends bindings.Proxy {
   _Regression551ProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _Regression551ProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
   _Regression551ProxyImpl.unbound() : super.unbound();
 
   static _Regression551ProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For _Regression551ProxyImpl"));
     return new _Regression551ProxyImpl.fromEndpoint(endpoint);
   }
 
+  service_describer.ServiceDescription get serviceDescription =>
+    new _Regression551ServiceDescription();
+
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _Regression551_getName:
         var r = Regression551GetResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
         Completer c = completerMap[message.header.requestId];
@@ skipping 165 matching lines @@
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
     return "Regression551Stub($superString)";
   }
 
   int get version => 0;
+
+  service_describer.ServiceDescription get serviceDescription =>
+    new _Regression551ServiceDescription();
 }
 
 const int _ServiceName_serviceName_Name = 0;
 
+mojom_types.MojomInterface _regressionTestsServiceName() {
+  return new mojom_types.MojomInterface()
+    ..declData = (new mojom_types.DeclarationData()
+      ..shortName = 'ServiceName'
+      ..fullIdentifier = 'regression_tests.ServiceName')
+    ..interfaceName = 'ServiceName'
+    ..methods = <int, mojom_types.MojomMethod>{
+      _ServiceName_serviceName_Name: new mojom_types.MojomMethod()
+        ..declData = (new mojom_types.DeclarationData()
+          ..shortName = 'ServiceName')
+        ..ordinal = _ServiceName_serviceName_Name
+        ..responseParams = _regressionTestsServiceNameServiceNameResponseParams()
+        ..parameters = _regressionTestsServiceNameServiceNameParams(),
+    };
+}
+
+class _ServiceNameServiceDescription implements service_describer.ServiceDescription {
+  dynamic getTopLevelInterface([Function responseFactory]) =>
+      _regressionTestsServiceName();
+
+  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
+      getAllMojomTypeDefinitions()[typeKey];
+
+  dynamic getAllTypeDefinitions([Function responseFactory]) =>
+      getAllMojomTypeDefinitions();
+}
+
 abstract class ServiceName {
   static const String serviceName = null;
   dynamic serviceName_([Function responseFactory = null]);
 }
 
 
 class _ServiceNameProxyImpl extends bindings.Proxy {
   _ServiceNameProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _ServiceNameProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
   _ServiceNameProxyImpl.unbound() : super.unbound();
 
   static _ServiceNameProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For _ServiceNameProxyImpl"));
     return new _ServiceNameProxyImpl.fromEndpoint(endpoint);
   }
 
+  service_describer.ServiceDescription get serviceDescription =>
+    new _ServiceNameServiceDescription();
+
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _ServiceName_serviceName_Name:
         var r = ServiceNameServiceNameResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
         Completer c = completerMap[message.header.requestId];
@@ skipping 164 matching lines @@
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
     return "ServiceNameStub($superString)";
   }
 
   int get version => 0;
+
+  service_describer.ServiceDescription get serviceDescription =>
+    new _ServiceNameServiceDescription();
 }
 
 
+Map<String, mojom_types.UserDefinedType> _initDescriptions() {
+  var map = new HashMap<String, mojom_types.UserDefinedType>();
+  map["regression_tests_EnumWithReference__"] =
+    new mojom_types.UserDefinedType()
+      ..enumType = _regressionTestsEnumWithReference();
+  map["regression_tests_EnumWithLowercase__"] =
+    new mojom_types.UserDefinedType()
+      ..enumType = _regressionTestsEnumWithLowercase();
+  map["regression_tests_EnumWithNumbers__"] =
+    new mojom_types.UserDefinedType()
+      ..enumType = _regressionTestsEnumWithNumbers();
+  map["regression_tests_EnumWithK__"] =
+    new mojom_types.UserDefinedType()
+      ..enumType = _regressionTestsEnumWithK();
+  map["regression_tests_EnumWithINTERNALAllCaps__"] =
+    new mojom_types.UserDefinedType()
+      ..enumType = _regressionTestsEnumWithInternalAllCaps();
+  map["regression_tests_NormalEnum__"] =
+    new mojom_types.UserDefinedType()
+      ..enumType = _regressionTestsNormalEnum();
+  map["regression_tests_CamelCaseTestEnum__"] =
+    new mojom_types.UserDefinedType()
+      ..enumType = _regressionTestsCamelCaseTestEnum();
+  map["regression_tests_Edge__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsEdge();
+  map["regression_tests_Vertex__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsVertex();
+  map["regression_tests_EmptyStruct__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsEmptyStruct();
+  map["regression_tests_A__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsA();
+  map["regression_tests_B__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsB();
+  map["regression_tests_StructWithHandleCalledHandles__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsStructWithHandleCalledHandles();
+  map["regression_tests_StructWithArrayOfHandlesCalledHandles__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsStructWithArrayOfHandlesCalledHandles();
+  map["regression_tests_StructWithInterfaceCalledHandles__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsStructWithInterfaceCalledHandles();
+  map["regression_tests_ContainsArrayOfEnum__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsContainsArrayOfEnum();
+  map["regression_tests_CheckMethodWithEmptyResponse_WithoutParameterAndEmptyResponse_Params__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsCheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseParams();
+  map["regression_tests_CheckMethodWithEmptyResponse_WithoutParameterAndEmptyResponse_ResponseParams__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsCheckMethodWithEmptyResponseWithoutParameterAndEmptyResponseResponseParams();
+  map["regression_tests_CheckMethodWithEmptyResponse_WithParameterAndEmptyResponse_Params__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsCheckMethodWithEmptyResponseWithParameterAndEmptyResponseParams();
+  map["regression_tests_CheckMethodWithEmptyResponse_WithParameterAndEmptyResponse_ResponseParams__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsCheckMethodWithEmptyResponseWithParameterAndEmptyResponseResponseParams();
+  map["regression_tests_CheckNameCollision_WithNameCollision_Params__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsCheckNameCollisionWithNameCollisionParams();
+  map["regression_tests_CheckNameCollision_WithNameCollision_ResponseParams__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsCheckNameCollisionWithNameCollisionResponseParams();
+  map["regression_tests_CheckEnumCaps_SetEnumWithINTERNALAllCaps_Params__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsCheckEnumCapsSetEnumWithInternalAllCapsParams();
+  map["regression_tests_TestInterface_SomeMessage_Params__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsTestInterfaceSomeMessageParams();
+  map["regression_tests_Regression551_Get_Params__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsRegression551GetParams();
+  map["regression_tests_Regression551_Get_ResponseParams__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsRegression551GetResponseParams();
+  map["regression_tests_ServiceName_serviceName_Params__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsServiceNameServiceNameParams();
+  map["regression_tests_ServiceName_serviceName_ResponseParams__"] =
+    new mojom_types.UserDefinedType()
+      ..structType = _regressionTestsServiceNameServiceNameResponseParams();
+  map["regression_tests_CheckMethodWithEmptyResponse__"] =
+    new mojom_types.UserDefinedType()
+      ..interfaceType = _regressionTestsCheckMethodWithEmptyResponse();
+  map["regression_tests_CheckNameCollision__"] =
+    new mojom_types.UserDefinedType()
+      ..interfaceType = _regressionTestsCheckNameCollision();
+  map["regression_tests_CheckEnumCaps__"] =
+    new mojom_types.UserDefinedType()
+      ..interfaceType = _regressionTestsCheckEnumCaps();
+  map["regression_tests_TestInterface__"] =
+    new mojom_types.UserDefinedType()
+      ..interfaceType = _regressionTestsTestInterface();
+  map["regression_tests_Regression551__"] =
+    new mojom_types.UserDefinedType()
+      ..interfaceType = _regressionTestsRegression551();
+  map["regression_tests_ServiceName__"] =
+    new mojom_types.UserDefinedType()
+      ..interfaceType = _regressionTestsServiceName();
+  return map;
+}
+
+var _mojomDesc;
+Map<String, mojom_types.UserDefinedType> getAllMojomTypeDefinitions() {
+  if (_mojomDesc == null) {
+    _mojomDesc = _initDescriptions();
+  }
+  return _mojomDesc;
+}
+