Don't include implicit initializing formal types in summaries.

pkg/analyzer/test/src/summary/summary_test.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.src.summary.summary_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 1365 matching lines @@
     expect(parameter.parameters[1].name, 'b');
   }
 
   test_constructor_initializing_formal_implicit_type() {
     // Note: the implicit type of an initializing formal is the type of the
     // field.
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(this.x); int x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
-    checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
+    expect(parameter.type, isNull);
     expect(parameter.hasImplicitType, isTrue);
   }
 
   test_constructor_initializing_formal_name() {
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(this.x); final x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.name, 'x');
   }
@@ skipping 31 matching lines @@
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.kind, UnlinkedParamKind.required);
   }
 
   test_constructor_initializing_formal_typedef() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText(
                 'typedef F<T>(T x); class C<X> { C(this.f); F<X> f; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.parameters, hasLength(1));
+    expect(parameter.isFunctionTyped, isFalse);
+    expect(parameter.parameters, isEmpty);
   }
 
   test_constructor_named() {
     String text = 'class C { C.foo(); }';
     UnlinkedExecutable executable = findExecutable('foo',
         executables: serializeClassText(text).executables);
     expect(executable.name, 'foo');
     expect(executable.nameOffset, text.indexOf('foo'));
   }
 
@@ skipping 1708 matching lines @@
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 
   test_varible_private() {
     serializeVariableText('int _i;', variableName: '_i');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 }