tweak FunctionTypeImpl to support generic methods

pkg/analyzer/lib/src/task/strong_mode.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.src.task.strong_mode;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart'
     show TypeProvider, InheritanceManager;
 import 'package:analyzer/src/generated/type_system.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
  * Set the type of the sole parameter of the given [element] to the given [type].
  */
 void setParameterType(PropertyAccessorElement element, DartType type) {
   if (element is PropertyAccessorElementImpl) {
     ParameterElement parameter = _getParameter(element);
     if (parameter is ParameterElementImpl) {
       //
       // Update the type of the parameter.
       //
       parameter.type = type;
       //
       // Update the type of the setter to reflect the new parameter type.
       //
+      // TODO(jmesserly): why is this necessary? The function type should always

[Brian Wilkerson, 2015/11/13 18:56:16]

Good question! I don't know. Does anything break if we change this?

[Jennifer Messerly, 2015/11/13 19:04:46]

Yeah, I was planning to give it a shot right after this.

[Brian Wilkerson, 2015/11/13 20:17:14]

Sounds good. Certainly not necessary before landing this CL.

+      // delegate to the orginal element.
       FunctionType functionType = element.type;
       if (functionType is FunctionTypeImpl) {
-        element.type =
-            new FunctionTypeImpl(element, functionType.prunedTypedefs)
-              ..typeArguments = functionType.typeArguments;
+        element.type = new FunctionTypeImpl(element);
       } else {
         assert(false);
       }
     } else {
       assert(false);
     }
   } else {
     throw new StateError('element is an instance of ${element.runtimeType}');
     assert(false);

[Brian Wilkerson, 2015/11/13 18:56:16]

Also, why is there an assert after a throw? We can't reach this code.

[Jennifer Messerly, 2015/11/13 19:04:46]

yeah--it's strange right? The asserts above seem sketchy too & inconsistent.
Should I just have it all be a throw?

(and below in setReturnType)

[Jennifer Messerly, 2015/11/13 19:17:22]

Thinking on this more, it seems like we just want a cast:

    (element as PropertyAccessorElementImpl)

same for the other "is" checks. These aren't really type tests, they're
logically asserting that certain types are expected, even though our type system
is not tracking it.

Longer term, it would be nice if we can help the type system track this better.

[Brian Wilkerson, 2015/11/13 20:17:14]

The rationale we've used before is that we want this to run as quickly as
possible in production, but have as much checking as possible during
development. Hence the assert statements. They disappear in production, but can
help us find problems during development. That's why we avoid casts except where
necessary to get around the limited abilities of type promotion.

It just seems odd to have code after an explicit throw because it will never be
reached.

I certainly don't expect you to make any of these changes as part of this CL.
:-)

   }
 }
 
 /**
  * Set the return type of the given [element] to the given [type].
  */
 void setReturnType(ExecutableElement element, DartType type) {
   if (element is ExecutableElementImpl) {
     //
     // Update the return type of the element, which is stored in two places:
     // directly in the element and indirectly in the type of the element.
     //
+    // TODO(jmesserly): why is this necessary? The function type should always
+    // delegate to the orginal element.
     element.returnType = type;
     FunctionType functionType = element.type;
     if (functionType is FunctionTypeImpl) {
-      element.type = new FunctionTypeImpl(element, functionType.prunedTypedefs)
-        ..typeArguments = functionType.typeArguments;
+      element.type = new FunctionTypeImpl(element);
     } else {
       assert(false);
     }
   } else {
     assert(false);
   }
 }
 
 /**
  * Return the element for the single parameter of the given [setter], or `null`
@@ skipping 428 matching lines @@
         results.add(element);
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}