Ensure that element handles never refer to Member objects.

pkg/analyzer/lib/src/dart/element/member.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.src.dart.element.member;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 110 matching lines @@
     }
     return new ConstructorMember(constructor, definingType, substitutedType);
   }
 }
 
 /**
  * An executable element defined in a parameterized type where the values of the
  * type parameters are known.
  */
 abstract class ExecutableMember extends Member implements ExecutableElement {
-  @override
-  final FunctionType type;
+  FunctionType _type;
 
   /**
    * Initialize a newly created element to represent a callable element (like a
    * method or function or property), based on the [baseElement], defined by the
    * [definingType]. If [type] is passed, it represents the full type of the
    * member, and will take precedence over the [definingType].
    */
   ExecutableMember(ExecutableElement baseElement, InterfaceType definingType,
       [FunctionType type])

[scheglov, 2016/02/10 21:53:26]

[FunctionType this._type] maybe?
OTOH this is not the most nice name to expose to clients.

[Paul Berry, 2016/02/10 22:10:59]

Yeah, I had a similar thought.  I think I'd prefer to leave as is so that the
documentation can still refer to [type].

-      : type = type ??
-            baseElement.type.substitute2(definingType.typeArguments,
-                TypeParameterTypeImpl.getTypes(definingType.typeParameters)),
+      : _type = type,
         super(baseElement, definingType);
 
   @override
   ExecutableElement get baseElement => super.baseElement as ExecutableElement;
 
   @override
   List<FunctionElement> get functions {
     //
     // Elements within this element should have type parameters substituted,
     // just like this element.
@@ skipping 39 matching lines @@
 //    return getBaseElement().getLocalVariables();
   }
 
   @override
   List<ParameterElement> get parameters => type.parameters;
 
   @override
   DartType get returnType => type.returnType;
 
   @override
+  FunctionType get type {
+    return _type ??= baseElement.type.substitute2(definingType.typeArguments,
+        TypeParameterTypeImpl.getTypes(definingType.typeParameters));
+  }
+
+  @override
   List<TypeParameterElement> get typeParameters => baseElement.typeParameters;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     // TODO(brianwilkerson) We need to finish implementing the accessors used
     // below so that we can safely invoke them.
     super.visitChildren(visitor);
     safelyVisitChildren(baseElement.functions, visitor);
     safelyVisitChildren(labels, visitor);
     safelyVisitChildren(baseElement.localVariables, visitor);
@@ skipping 745 matching lines @@
   bool get isStatic => baseElement.isStatic;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     // TODO(brianwilkerson) We need to finish implementing the accessors used
     // below so that we can safely invoke them.
     super.visitChildren(visitor);
     safelyVisitChild(baseElement.initializer, visitor);
   }
 }