Fix for typedef-typed field formal parameter.

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/engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 474 matching lines @@
 
   /**
    * Serialize a type declaration using the given [text] as a type name, and
    * return a summary of the corresponding [UnlinkedTypeRef].  If the type
    * declaration needs to refer to types that are not available in core, those
    * types may be declared in [otherDeclarations].
    */
   UnlinkedTypeRef serializeTypeText(String text,
       {String otherDeclarations: '', bool allowErrors: false}) {
     return serializeVariableText('$otherDeclarations\n$text v;',
-        allowErrors: allowErrors).type;
+            allowErrors: allowErrors)
+        .type;
   }
 
   /**
    * Serialize the given library [text] and return the summary of the variable
    * with the given [variableName].
    */
   UnlinkedVariable serializeVariableText(String text,
       {String variableName: 'v', bool allowErrors: false}) {
     serializeLibraryText(text, allowErrors: allowErrors);
     return findVariable(variableName, failIfAbsent: true);
@@ skipping 388 matching lines @@
         executables: serializeClassText('class C { C(this.x()); Function x; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
     // Since the parameter is function-typed it is considered to have an
     // explicit type, even though that explicit type itself has an implicit
     // return type.
     expect(parameter.hasImplicitType, isFalse);
     checkDynamicTypeRef(parameter.type);
   }
 
-  test_constructor_initializing_formal_function_typed_no_prameters() {
+  test_constructor_initializing_formal_function_typed_no_parameters() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(this.x()); final x; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.parameters, isEmpty);
   }
 
-  test_constructor_initializing_formal_function_typed_prameter() {
+  test_constructor_initializing_formal_function_typed_parameter() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(this.x(a)); final x; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.parameters, hasLength(1));
   }
 
-  test_constructor_initializing_formal_function_typed_prameter_order() {
+  test_constructor_initializing_formal_function_typed_parameter_order() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(this.x(a, b)); final x; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.parameters, hasLength(2));
     expect(parameter.parameters[0].name, 'a');
     expect(parameter.parameters[1].name, 'b');
   }
 
   test_constructor_initializing_formal_implicit_type() {
@@ skipping 42 matching lines @@
   }
 
   test_constructor_initializing_formal_required() {
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(this.x); final x; }').executables);
     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));
+  }
+
   test_constructor_named() {
     UnlinkedExecutable executable = findExecutable('foo',
         executables: serializeClassText('class C { C.foo(); }').executables);
     expect(executable.name, 'foo');
   }
 
   test_constructor_non_const() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.isConst, isFalse);
@@ skipping 347 matching lines @@
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(1));
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'bool');
     expect(executable.typeParameters, isEmpty);
   }
 
   test_executable_operator_index_set() {
     UnlinkedExecutable executable = serializeClassText(
-        'class C { void operator[]=(int i, bool v) => null; }').executables[0];
+            'class C { void operator[]=(int i, bool v) => null; }')
+        .executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]=');
     expect(executable.hasImplicitReturnType, false);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(2));
     expect(executable.returnType, isNull);
     expect(executable.typeParameters, isEmpty);
@@ skipping 784 matching lines @@
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
   }
 
   test_variable_type() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 }