Use entities in CommonElements interface.

pkg/compiler/lib/src/elements/resolution_types.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.
 
 /// Implementation of the Dart types hierarchy in 'types.dart' specifically
 /// tailored to the resolution phase of the compiler.
 
 library resolution_types;
 
 import 'dart:math' show min;
@@ skipping 1649 matching lines @@
   ///
   /// Otherwise, a function type is returned whose return type and
   /// parameter types are the least upper bound of those of [a] and [b],
   /// respectively. In addition, the optional parameters are the least upper
   /// bound of the longest common prefix of the optional parameters of [a] and
   /// [b], and the named parameters are the least upper bound of those common to
   /// [a] and [b].
   ResolutionDartType computeLeastUpperBoundFunctionTypes(
       ResolutionFunctionType a, ResolutionFunctionType b) {
     if (a.parameterTypes.length != b.parameterTypes.length) {
-      return commonElements.functionType;
+      ResolutionInterfaceType functionType = commonElements.functionType;
+      return functionType;
     }
     ResolutionDartType returnType =
         computeLeastUpperBound(a.returnType, b.returnType);
     List<ResolutionDartType> parameterTypes =
         computeLeastUpperBoundsTypes(a.parameterTypes, b.parameterTypes);
     List<ResolutionDartType> optionalParameterTypes =
         computeLeastUpperBoundsTypes(
             a.optionalParameterTypes, b.optionalParameterTypes);
     List<String> namedParameters = <String>[];
     List<String> aNamedParameters = a.namedParameters;
@@ skipping 61 matching lines @@
 
     if (a.treatAsDynamic || b.treatAsDynamic)
       return const ResolutionDynamicType();
     if (a.isVoid || b.isVoid) return const ResolutionVoidType();
 
     if (a.isFunctionType && b.isFunctionType) {
       return computeLeastUpperBoundFunctionTypes(a, b);
     }
 
     if (a.isFunctionType) {
-      a = commonElements.functionType;
+      ResolutionInterfaceType functionType = commonElements.functionType;
+      a = functionType;
     }
     if (b.isFunctionType) {
-      b = commonElements.functionType;
+      ResolutionInterfaceType functionType = commonElements.functionType;
+      b = functionType;
     }
 
     if (a.isInterfaceType && b.isInterfaceType) {
       return computeLeastUpperBoundInterfaces(a, b);
     }
     return const ResolutionDynamicType();
   }
 
   /// Computes the unaliased type of the first non type variable bound of
   /// [type].
@@ skipping 22 matching lines @@
   ///     unaliasedBound(U) = unaliasedBound(Baz) = ()->dynamic
   ///     unaliasedBound(X) = unaliasedBound(Y) = `Object`
   ///
   static ResolutionDartType computeUnaliasedBound(
       Resolution resolution, ResolutionDartType type) {
     ResolutionDartType originalType = type;
     while (type.isTypeVariable) {
       ResolutionTypeVariableType variable = type;
       type = variable.element.bound;
       if (type == originalType) {
-        type = resolution.commonElements.objectType;
+        ResolutionInterfaceType objectType =
+            resolution.commonElements.objectType;
+        type = objectType;
       }
     }
     if (type.isMalformed) {
       return const ResolutionDynamicType();
     }
     type.computeUnaliased(resolution);
     return type.unaliased;
   }
 
   /// Computes the interface type of [type], which is the type that defines
@@ skipping 23 matching lines @@
   /// When typechecking `o.foo` the interface type of the static type of `o` is
   /// used to lookup the existence and type of `foo`.
   ///
   static ResolutionInterfaceType computeInterfaceType(
       Resolution resolution, ResolutionDartType type) {
     type = computeUnaliasedBound(resolution, type);
     if (type.treatAsDynamic) {
       return null;
     }
     if (type.isFunctionType) {
-      type = resolution.commonElements.functionType;
+      ResolutionInterfaceType functionType =
+          resolution.commonElements.functionType;
+      type = functionType;
     }
     assert(invariant(NO_LOCATION_SPANNABLE, type.isInterfaceType,
         message: "unexpected type kind ${type.kind}."));
     return type;
   }
 }
 
 /**
  * Type visitor that determines one type could a subtype of another given the
  * right type variable substitution. The computation is approximate and returns
@@ skipping 205 matching lines @@
           sb.write(', ');
         }
         namedParameterTypes[index].accept(this, namedParameters[index]);
         needsComma = true;
       }
       sb.write('}');
     }
     sb.write(')');
   }
 }