Remove element from DynamicType.

sdk/lib/_internal/compiler/implementation/resolution/class_members.dart

 // Copyright (c) 2012, 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 resolution.compute_members;
 
 import '../elements/elements.dart'
     show Element,
          Name,
          PublicName,
@@ skipping 188 matching lines @@
         } else if (element.isGetter) {
           FunctionType functionType = element.computeType(compiler);
           DartType type = functionType.returnType;
           addDeclaredMember(name, type, functionType);
         } else if (element.isSetter) {
           FunctionType functionType = element.computeType(compiler);
           DartType type;
           if (!functionType.parameterTypes.isEmpty) {
             type = functionType.parameterTypes.head;
           } else {
-            type = compiler.types.dynamicType;
+            type = const DynamicType();
           }
           name = name.setter;
           addDeclaredMember(name, type, functionType);
         } else {
           assert(invariant(element, element.isFunction));
           FunctionType type = element.computeType(compiler);
           addDeclaredMember(name, type, type);
         }
       }
 
@@ skipping 475 matching lines @@
     // version.
     int minRequiredParameters;
     int maxPositionalParameters;
     Set<String> names = new Set<String>();
     for (MemberSignature member in inheritedMembers) {
       int requiredParameters = 0;
       int optionalParameters = 0;
       if (member.isSetter) {
         requiredParameters = 1;
       }
-      if (member.type.kind == TypeKind.FUNCTION) {
+      if (member.type.isFunctionType) {
         FunctionType type = member.type;
         type.namedParameters.forEach(
             (String name) => names.add(name));
         requiredParameters = type.parameterTypes.slowLength();
         optionalParameters = type.optionalParameterTypes.slowLength();
       }
       int positionalParameters = requiredParameters + optionalParameters;
       if (minRequiredParameters == null ||
           minRequiredParameters > requiredParameters) {
         minRequiredParameters = requiredParameters;
       }
       if (maxPositionalParameters == null ||
           maxPositionalParameters < positionalParameters) {
         maxPositionalParameters = positionalParameters;
       }
     }
     int optionalParameters =
         maxPositionalParameters - minRequiredParameters;
     // TODO(johnniwinther): Support function types with both optional
     // and named parameters?
     if (optionalParameters == 0 || names.isEmpty) {
       Link<DartType> requiredParameterTypes = const Link<DartType>();
       while (--minRequiredParameters >= 0) {
         requiredParameterTypes =
-            requiredParameterTypes.prepend(compiler.types.dynamicType);
+            requiredParameterTypes.prepend(const DynamicType());
       }
       Link<DartType> optionalParameterTypes = const Link<DartType>();
       while (--optionalParameters >= 0) {
         optionalParameterTypes =
-            optionalParameterTypes.prepend(compiler.types.dynamicType);
+            optionalParameterTypes.prepend(const DynamicType());
       }
       Link<String> namedParameters = const Link<String>();
       Link<DartType> namedParameterTypes = const Link<DartType>();
       List<String> namesReversed =
           names.toList()..sort((a, b) => -a.compareTo(b));
       for (String name in namesReversed) {
         namedParameters = namedParameters.prepend(name);
         namedParameterTypes =
-            namedParameterTypes.prepend(compiler.types.dynamicType);
+            namedParameterTypes.prepend(const DynamicType());
       }
       FunctionType memberType = new FunctionType.synthesized(
-          compiler.types.dynamicType,
+          const DynamicType(),
           requiredParameterTypes,
           optionalParameterTypes,
           namedParameters, namedParameterTypes);
       DartType type = memberType;
       if (inheritedMembers.first.isGetter ||
           inheritedMembers.first.isSetter) {
-        type = compiler.types.dynamicType;
+        type = const DynamicType();
       }
       interfaceMembers[name] =
           new SyntheticMember(inheritedMembers, type, memberType);
     }
   }
 }
 
 abstract class ClassMemberMixin implements ClassElement {
   /// When [classMembers] and [interfaceMembers] have not been fully computed
   /// [computedMembersNames] holds the names for which members have already been
@@ skipping 113 matching lines @@
         message: "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }