Introduce code to generate summaries from an element model.

pkg/analyzer/lib/src/generated/testing/test_type_provider.dart

Index: pkg/analyzer/lib/src/generated/testing/test_type_provider.dart
diff --git a/pkg/analyzer/lib/src/generated/testing/test_type_provider.dart b/pkg/analyzer/lib/src/generated/testing/test_type_provider.dart
index 5b5204a3d752f8acde2fc57558a13ab4179b9f3c..85cc8902810d68551e58b4cb2ad1dec7a83c7d22 100644
--- a/pkg/analyzer/lib/src/generated/testing/test_type_provider.dart
+++ b/pkg/analyzer/lib/src/generated/testing/test_type_provider.dart
@@ -208,7 +208,10 @@ class TestTypeProvider implements TypeProvider {
   @override
   InterfaceType get functionType {
     if (_functionType == null) {
-      _functionType = ElementFactory.classElement2("Function").type;
+      ClassElementImpl functionClassElement =
+          ElementFactory.classElement2("Function");
+      _functionType = functionClassElement.type;
+      functionClassElement.constructors = <ConstructorElement>[];

[Brian Wilkerson, 2015/11/11 15:26:10]

I'm surprised that this is necessary. I thought we already initialized all of
the fields in elements. If not, I think we ought to. And if that isn't feasible,
wouldn't it be better to do the initialization in ElementFactory.classElement2?

(Also, we should use ConstructorElement.EMPTY_LIST rather than create a new list
for each element.)

[Paul Berry, 2015/11/11 19:12:22]

What we currently do is: in the constructor for ClassElementImpl, we initialize
"_constructors" to null, and in the "constructors" getter, we assert that it's
not null, and then if we're running in unchecked mode, we replace null with
ConstructorElement.EMPTY_LIST.  I think that strikes a really good balance: it
means that if a bug is ever encountered during testing where we forget to set
_constructors, an assertion will fire, but if such a bug happens in production,
the code will defensively act like there are no constructors, avoiding an
exception.

So I'd rather not initialize _constructors to ConstructorElement.EMPTY_LIST in
the ClassElementImpl constructor, since that would make us lose the ability to
detect the bug during testing.

But I'm quite happy initializing _constructors in ElementFactory.classElement2.
As we discussed in person, I'd prefer to move toward using `const
<ConstructorElement>[]` rather than `ConstructorElement.EMPTY_LIST` just because
the former is more idiomatic Dart.  So that's what I'm doing for now.  If you
find that it really bothers you, we can discuss it more.

     }
     return _functionType;
   }
@@ -396,7 +399,10 @@ class TestTypeProvider implements TypeProvider {
   @override
   InterfaceType get stackTraceType {
     if (_stackTraceType == null) {
-      _stackTraceType = ElementFactory.classElement2("StackTrace").type;
+      ClassElementImpl stackTraceClassElement =
+          ElementFactory.classElement2("StackTrace");
+      _stackTraceType = stackTraceClassElement.type;
+      stackTraceClassElement.constructors = <ConstructorElement>[];
     }
     return _stackTraceType;
   }
@@ -463,7 +469,9 @@ class TestTypeProvider implements TypeProvider {
   @override
   InterfaceType get typeType {
     if (_typeType == null) {
-      _typeType = ElementFactory.classElement2("Type").type;
+      ClassElementImpl typeClassElement = ElementFactory.classElement2("Type");
+      _typeType = typeClassElement.type;
+      typeClassElement.constructors = <ConstructorElement>[];
     }
     return _typeType;
   }