Fix for summarizing typedef typed parameters.

pkg/analyzer/test/generated/resolver_test.dart

 // Copyright (c) 2014, 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.generated.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 202 matching lines @@
       ];
       futureConstructor.factory = true;
       futureElement.constructors = <ConstructorElement>[futureConstructor];
       //   Future then(onValue(T value), { Function onError });
       TypeDefiningElement futureThenR = DynamicElementImpl.instance;
       if (context.analysisOptions.strongMode) {
         futureThenR = ElementFactory.typeParameterWithType('R');
       }
       FunctionElementImpl thenOnValue = ElementFactory.functionElement3(
           'onValue', futureThenR, [futureElement.typeParameters[0]], null);
+      thenOnValue.synthetic = true;
 
       DartType futureRType = futureElement.type.substitute4([futureThenR.type]);
       MethodElementImpl thenMethod = ElementFactory
           .methodElementWithParameters(futureElement, "then", futureRType, [
         ElementFactory.requiredParameter2("onValue", thenOnValue.type),
         ElementFactory.namedParameter2("onError", provider.functionType)
       ]);
       if (!futureThenR.type.isDynamic) {
         thenMethod.typeParameters = [futureThenR];
       }
@@ skipping 16 matching lines @@
       ClassElementImpl streamSubscriptionElement =
           ElementFactory.classElement2("StreamSubscription", ["T"]);
       // Stream
       ClassElementImpl streamElement =
           ElementFactory.classElement2("Stream", ["T"]);
       streamElement.constructors = <ConstructorElement>[
         ElementFactory.constructorElement2(streamElement, null)
       ];
       DartType returnType = streamSubscriptionElement.type
           .substitute4(streamElement.type.typeArguments);
-      List<DartType> parameterTypes = <DartType>[
-        ElementFactory
-            .functionElement3('onData', VoidTypeImpl.instance.element,
-                <TypeDefiningElement>[streamElement.typeParameters[0]], null)
-            .type,
-      ];
+      FunctionElementImpl listenOnData = ElementFactory.functionElement3(
+          'onData',
+          VoidTypeImpl.instance.element,
+          <TypeDefiningElement>[streamElement.typeParameters[0]],
+          null);
+      listenOnData.synthetic = true;
+      List<DartType> parameterTypes = <DartType>[listenOnData.type,];
       // TODO(brianwilkerson) This is missing the optional parameters.
       MethodElementImpl listenMethod =
           ElementFactory.methodElement('listen', returnType, parameterTypes);
       streamElement.methods = <MethodElement>[listenMethod];
       listenMethod.type = new FunctionTypeImpl(listenMethod);
 
       FunctionElementImpl listenParamFunction = parameterTypes[0].element;
       listenParamFunction.enclosingElement = listenMethod;
       listenParamFunction.type = new FunctionTypeImpl(listenParamFunction);
       ParameterElementImpl listenParam = listenMethod.parameters[0];
@@ skipping 16675 matching lines @@
 
 /**
  * Shared infrastructure for [StaticTypeAnalyzer2Test] and
  * [StrongModeStaticTypeAnalyzer2Test].
  */
 class _StaticTypeAnalyzer2TestShared extends ResolverTestCase {
   String testCode;
   Source testSource;
   CompilationUnit testUnit;
 
-  SimpleIdentifier _findIdentifier(String search) {
-    SimpleIdentifier identifier = EngineTestCase.findNode(
-        testUnit, testCode, search, (node) => node is SimpleIdentifier);
-    return identifier;
+  /**
+   * Looks up the identifier with [name] and validates that its type type
+   * stringifies to [type] and that its generics match the given stringified
+   * output.
+   */
+  _expectFunctionType(String name, String type,
+      {String elementTypeParams: '[]',
+      String typeParams: '[]',
+      String typeArgs: '[]',
+      String typeFormals: '[]'}) {
+    SimpleIdentifier identifier = _findIdentifier(name);
+    // Element is either ExecutableElement or ParameterElement.
+    var element = identifier.staticElement;
+    FunctionTypeImpl functionType = identifier.staticType;
+    expect(functionType.toString(), type);
+    expect(element.typeParameters.toString(), elementTypeParams);
+    expect(functionType.typeParameters.toString(), typeParams);
+    expect(functionType.typeArguments.toString(), typeArgs);
+    expect(functionType.typeFormals.toString(), typeFormals);
   }
 
   /**
    * Looks up the identifier with [name] and validates its static [type].
    *
    * If [type] is a string, validates that the identifier's static type
    * stringifies to that text. Otherwise, [type] is used directly a [Matcher]
    * to match the type.
    *
    * If [propagatedType] is given, also validate's the identifier's propagated
@@ skipping 23 matching lines @@
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
     Expression initializer = declaration.initializer;
     _expectType(initializer.staticType, type);
     if (propagatedType != null) {
       _expectType(initializer.propagatedType, propagatedType);
     }
   }
 
   /**
-   * Looks up the identifier with [name] and validates that its type type
-   * stringifies to [type] and that its generics match the given stringified
-   * output.
-   */
-  _expectFunctionType(String name, String type,
-      {String elementTypeParams: '[]',
-      String typeParams: '[]',
-      String typeArgs: '[]',
-      String typeFormals: '[]'}) {
-    SimpleIdentifier identifier = _findIdentifier(name);
-    // Element is either ExecutableElement or ParameterElement.
-    var element = identifier.staticElement;
-    FunctionTypeImpl functionType = identifier.staticType;
-    expect(functionType.toString(), type);
-    expect(element.typeParameters.toString(), elementTypeParams);
-    expect(functionType.typeParameters.toString(), typeParams);
-    expect(functionType.typeArguments.toString(), typeArgs);
-    expect(functionType.typeFormals.toString(), typeFormals);
-  }
-
-  /**
    * Validates that [type] matches [expected].
    *
    * If [expected] is a string, validates that the type stringifies to that
    * text. Otherwise, [expected] is used directly a [Matcher] to match the type.
    */
   _expectType(DartType type, expected) {
     if (expected is String) {
       expect(type.toString(), expected);
     } else {
       expect(type, expected);
     }
   }
 
+  SimpleIdentifier _findIdentifier(String search) {
+    SimpleIdentifier identifier = EngineTestCase.findNode(
+        testUnit, testCode, search, (node) => node is SimpleIdentifier);
+    return identifier;
+  }
+
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }