dartfmt pkg/compiler

pkg/compiler/lib/src/dart_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.
 
 library dart_types;
 
 import 'dart:math' show min;
 
 import 'common.dart';
-import 'common/resolution.dart' show
-    Resolution;
+import 'common/resolution.dart' show Resolution;
 import 'core_types.dart';
-import 'elements/modelx.dart' show
-    LibraryElementX,
-    TypeDeclarationElementX,
-    TypedefElementX;
+import 'elements/modelx.dart'
+    show LibraryElementX, TypeDeclarationElementX, TypedefElementX;
 import 'elements/elements.dart';
-import 'ordered_typeset.dart' show
-    OrderedTypeSet;
-import 'util/util.dart' show
-    equalElements;
+import 'ordered_typeset.dart' show OrderedTypeSet;
+import 'util/util.dart' show equalElements;
 
 enum TypeKind {
   FUNCTION,
   INTERFACE,
   STATEMENT,
   TYPEDEF,
   TYPE_VARIABLE,
   MALFORMED_TYPE,
   DYNAMIC,
   VOID,
@@ skipping 40 matching lines @@
   ///
   /// The unaliased type of a typedef'd type is the unaliased type to which its
   /// name is bound. The unaliased version of any other type is the type itself.
   ///
   /// For example, the unaliased type of `typedef A Func<A,B>(B b)` is the
   /// function type `(B) -> A` and the unaliased type of `Func<int,String>`
   /// is the function type `(String) -> int`.
   // TODO(johnniwinther): Maybe move this to [TypedefType].
   void computeUnaliased(Resolution resolution) {}
 
-
   /// Returns the unaliased type of this type.
   ///
   /// The unaliased type of a typedef'd type is the unaliased type to which its
   /// name is bound. The unaliased version of any other type is the type itself.
   ///
   /// For example, the unaliased type of `typedef A Func<A,B>(B b)` is the
   /// function type `(B) -> A` and the unaliased type of `Func<int,String>`
   /// is the function type `(String) -> int`.
   DartType get unaliased => this;
 
@@ skipping 65 matching lines @@
   /// Returns a textual representation of this type as if it was the type
   /// of a member named [name].
   String getStringAsDeclared(String name) {
     return new TypeDeclarationFormatter().format(this, name);
   }
 
   accept(DartTypeVisitor visitor, var argument);
 
   void visitChildren(DartTypeVisitor visitor, var argument) {}
 
-  static void visitList(List<DartType> types,
-                        DartTypeVisitor visitor, var argument) {
+  static void visitList(
+      List<DartType> types, DartTypeVisitor visitor, var argument) {
     for (DartType type in types) {
       type.accept(visitor, argument);
     }
   }
 }
 
 /**
  * Represents a type variable, that is the type parameters of a class type.
  *
  * For example, in [: class Array<E> { ... } :], E is a type variable.
@@ skipping 47 matching lines @@
     f(this);
   }
 
   accept(DartTypeVisitor visitor, var argument) {
     return visitor.visitTypeVariableType(this, argument);
   }
 
   int get hashCode => 17 * element.hashCode;
 
   bool operator ==(other) {
-    if (other is !TypeVariableType) return false;
+    if (other is! TypeVariableType) return false;
     return identical(other.element, element);
   }
 
   String toString() => name;
 }
 
 /// Internal type representing the result of analyzing a statement.
 class StatementType extends DartType {
   Element get element => null;
 
@@ skipping 51 matching lines @@
    * where [: T :] is a type variable, in which case [declaredType] holds
    * [: dynamic :] and [: T :], respectively, or for [: X<int> :] where [: X :]
    * is not resolved or does not imply a type.
    */
   final List<DartType> typeArguments;
 
   final int hashCode = (nextHash++) & 0x3fffffff;
   static int nextHash = 43765;
 
   MalformedType(this.element, this.userProvidedBadType,
-                [this.typeArguments = null]);
+      [this.typeArguments = null]);
 
   TypeKind get kind => TypeKind.MALFORMED_TYPE;
 
   String get name => element.name;
 
   DartType subst(List<DartType> arguments, List<DartType> parameters) {
     // Malformed types are not substitutable.
     return this;
   }
 
@@ skipping 21 matching lines @@
       sb.write(userProvidedBadType.toString());
     }
     return sb.toString();
   }
 }
 
 abstract class GenericType extends DartType {
   final TypeDeclarationElement element;
   final List<DartType> typeArguments;
 
-  GenericType(TypeDeclarationElement element,
-              this.typeArguments,
-              {bool checkTypeArgumentCount: true})
+  GenericType(TypeDeclarationElement element, this.typeArguments,
+      {bool checkTypeArgumentCount: true})
       : this.element = element {
     assert(invariant(CURRENT_ELEMENT_SPANNABLE, element != null,
         message: "Missing element for generic type."));
     assert(invariant(element, () {
-        if (!checkTypeArgumentCount) return true;
-        if (element is TypeDeclarationElementX) {
-          return element.thisTypeCache == null ||
-                 typeArguments.length == element.typeVariables.length;
-        }
-        return true;
-    }, message: () => 'Invalid type argument count on ${element.thisType}. '
-                      'Provided type arguments: $typeArguments.'));
+      if (!checkTypeArgumentCount) return true;
+      if (element is TypeDeclarationElementX) {
+        return element.thisTypeCache == null ||
+            typeArguments.length == element.typeVariables.length;
+      }
+      return true;
+    },
+        message: () => 'Invalid type argument count on ${element.thisType}. '
+            'Provided type arguments: $typeArguments.'));
   }
 
   /// Creates a new instance of this type using the provided type arguments.
   GenericType createInstantiation(List<DartType> newTypeArguments);
 
   DartType subst(List<DartType> arguments, List<DartType> parameters) {
     if (typeArguments.isEmpty) {
       // Return fast on non-generic types.
       return this;
     }
@@ skipping 39 matching lines @@
   int get hashCode {
     int hash = element.hashCode;
     for (DartType argument in typeArguments) {
       int argumentHash = argument != null ? argument.hashCode : 0;
       hash = 17 * hash + 3 * argumentHash;
     }
     return hash;
   }
 
   bool operator ==(other) {
-    if (other is !GenericType) return false;
-    return kind == other.kind
-        && element == other.element
-        && equalElements(typeArguments, other.typeArguments);
+    if (other is! GenericType) return false;
+    return kind == other.kind &&
+        element == other.element &&
+        equalElements(typeArguments, other.typeArguments);
   }
 
   /// Returns `true` if the declaration of this type has type variables.
   bool get isGeneric => !typeArguments.isEmpty;
 
   bool get isRaw => typeArguments.isEmpty || identical(this, element.rawType);
 
   GenericType asRaw() => element.rawType;
 
   bool get treatAsRaw {
     if (isRaw) return true;
     for (DartType type in typeArguments) {
       if (!type.treatAsDynamic) return false;
     }
     return true;
   }
 }
 
 class InterfaceType extends GenericType {
   int _hashCode;
 
   InterfaceType(ClassElement element,
-                [List<DartType> typeArguments = const <DartType>[]])
+      [List<DartType> typeArguments = const <DartType>[]])
       : super(element, typeArguments) {
     assert(invariant(element, element.isDeclaration));
   }
 
-  InterfaceType.forUserProvidedBadType(
-      ClassElement element,
+  InterfaceType.forUserProvidedBadType(ClassElement element,
       [List<DartType> typeArguments = const <DartType>[]])
       : super(element, typeArguments, checkTypeArgumentCount: false);
 
   ClassElement get element => super.element;
 
   TypeKind get kind => TypeKind.INTERFACE;
 
   String get name => element.name;
 
   bool get isObject => element.isObject;
 
   bool get isEnumType => element.isEnumClass;
 
   InterfaceType createInstantiation(List<DartType> newTypeArguments) {
     return new InterfaceType(element, newTypeArguments);
   }
 
   /**
    * Returns the type as an instance of class [other], if possible, null
    * otherwise.
    */
   InterfaceType asInstanceOf(ClassElement other) {
     other = other.declaration;
     if (element == other) return this;
     InterfaceType supertype = element.asInstanceOf(other);
     if (supertype != null) {
-      List<DartType> arguments = Types.substTypes(supertype.typeArguments,
-                                                  typeArguments,
-                                                  element.typeVariables);
+      List<DartType> arguments = Types.substTypes(
+          supertype.typeArguments, typeArguments, element.typeVariables);
       return new InterfaceType(supertype.element, arguments);
     }
     return null;
   }
 
   MemberSignature lookupInterfaceMember(Name name) {
     MemberSignature member = element.lookupInterfaceMember(name);
     if (member != null && isGeneric) {
       return new InterfaceMember(this, member);
     }
@@ skipping 26 matching lines @@
 
 /**
  * Special subclass of [InterfaceType] used for generic interface types created
  * with the wrong number of type arguments.
  *
  * The type uses [:dynamic:] for all it s type arguments.
  */
 class BadInterfaceType extends InterfaceType {
   final InterfaceType userProvidedBadType;
 
-  BadInterfaceType(ClassElement element,
-                   InterfaceType this.userProvidedBadType)
+  BadInterfaceType(ClassElement element, InterfaceType this.userProvidedBadType)
       : super(element, element.rawType.typeArguments);
 
   String toString() {
     return userProvidedBadType.toString();
   }
 }
 
-
 /**
  * Special subclass of [TypedefType] used for generic typedef types created
  * with the wrong number of type arguments.
  *
  * The type uses [:dynamic:] for all it s type arguments.
  */
 class BadTypedefType extends TypedefType {
   final TypedefType userProvidedBadType;
 
-  BadTypedefType(TypedefElement element,
-                 TypedefType this.userProvidedBadType)
+  BadTypedefType(TypedefElement element, TypedefType this.userProvidedBadType)
       : super(element, element.rawType.typeArguments);
 
   String toString() {
     return userProvidedBadType.toString();
   }
 }
 
 class FunctionType extends DartType {
   final FunctionTypedElement element;
   final DartType returnType;
   final List<DartType> parameterTypes;
   final List<DartType> optionalParameterTypes;
 
   /**
    * The names of the named parameters ordered lexicographically.
    */
   final List<String> namedParameters;
 
   /**
    * The types of the named parameters in the order corresponding to the
    * [namedParameters].
    */
   final List<DartType> namedParameterTypes;
 
-  factory FunctionType(
-      FunctionTypedElement element,
+  factory FunctionType(FunctionTypedElement element,
       [DartType returnType = const DynamicType(),
-       List<DartType> parameterTypes = const <DartType>[],
-       List<DartType> optionalParameterTypes = const <DartType>[],
-       List<String> namedParameters = const <String>[],
-       List<DartType> namedParameterTypes = const <DartType>[]]) {
+      List<DartType> parameterTypes = const <DartType>[],
+      List<DartType> optionalParameterTypes = const <DartType>[],
+      List<String> namedParameters = const <String>[],
+      List<DartType> namedParameterTypes = const <DartType>[]]) {
     assert(invariant(CURRENT_ELEMENT_SPANNABLE, element != null));
     assert(invariant(element, element.isDeclaration));
-    return new FunctionType.internal(element,
-        returnType, parameterTypes, optionalParameterTypes,
-        namedParameters, namedParameterTypes);
+    return new FunctionType.internal(element, returnType, parameterTypes,
+        optionalParameterTypes, namedParameters, namedParameterTypes);
   }
 
   factory FunctionType.synthesized(
       [DartType returnType = const DynamicType(),
-       List<DartType> parameterTypes = const <DartType>[],
-       List<DartType> optionalParameterTypes = const <DartType>[],
-       List<String> namedParameters = const <String>[],
-       List<DartType> namedParameterTypes = const <DartType>[]]) {
-    return new FunctionType.internal(null,
-        returnType, parameterTypes, optionalParameterTypes,
-        namedParameters, namedParameterTypes);
+      List<DartType> parameterTypes = const <DartType>[],
+      List<DartType> optionalParameterTypes = const <DartType>[],
+      List<String> namedParameters = const <String>[],
+      List<DartType> namedParameterTypes = const <DartType>[]]) {
+    return new FunctionType.internal(null, returnType, parameterTypes,
+        optionalParameterTypes, namedParameters, namedParameterTypes);
   }
 
   FunctionType.internal(FunctionTypedElement this.element,
-                        [DartType this.returnType = const DynamicType(),
-                         this.parameterTypes = const <DartType>[],
-                         this.optionalParameterTypes = const <DartType>[],
-                         this.namedParameters = const <String>[],
-                         this.namedParameterTypes = const <DartType>[]]) {
-    assert(invariant(CURRENT_ELEMENT_SPANNABLE,
-        element == null || element.isDeclaration));
+      [DartType this.returnType = const DynamicType(),
+      this.parameterTypes = const <DartType>[],
+      this.optionalParameterTypes = const <DartType>[],
+      this.namedParameters = const <String>[],
+      this.namedParameterTypes = const <DartType>[]]) {
+    assert(invariant(
+        CURRENT_ELEMENT_SPANNABLE, element == null || element.isDeclaration));
     // Assert that optional and named parameters are not used at the same time.
     assert(optionalParameterTypes.isEmpty || namedParameterTypes.isEmpty);
     assert(namedParameters.length == namedParameterTypes.length);
   }
 
   TypeKind get kind => TypeKind.FUNCTION;
 
   DartType getNamedParameterType(String name) {
     for (int i = 0; i < namedParameters.length; i++) {
       if (namedParameters[i] == name) {
@@ skipping 12 matching lines @@
     DartType newReturnType = returnType.subst(arguments, parameters);
     bool changed = !identical(newReturnType, returnType);
     List<DartType> newParameterTypes =
         Types.substTypes(parameterTypes, arguments, parameters);
     List<DartType> newOptionalParameterTypes =
         Types.substTypes(optionalParameterTypes, arguments, parameters);
     List<DartType> newNamedParameterTypes =
         Types.substTypes(namedParameterTypes, arguments, parameters);
     if (!changed &&
         (!identical(parameterTypes, newParameterTypes) ||
-         !identical(optionalParameterTypes, newOptionalParameterTypes) ||
-         !identical(namedParameterTypes, newNamedParameterTypes))) {
+            !identical(optionalParameterTypes, newOptionalParameterTypes) ||
+            !identical(namedParameterTypes, newNamedParameterTypes))) {
       changed = true;
     }
     if (changed) {
       // Create a new type only if necessary.
-      return new FunctionType.internal(element,
-                                       newReturnType,
-                                       newParameterTypes,
-                                       newOptionalParameterTypes,
-                                       namedParameters,
-                                       newNamedParameterTypes);
+      return new FunctionType.internal(
+          element,
+          newReturnType,
+          newParameterTypes,
+          newOptionalParameterTypes,
+          namedParameters,
+          newNamedParameterTypes);
     }
     return this;
   }
 
   TypeVariableType get typeVariableOccurrence {
     TypeVariableType typeVariableType = returnType.typeVariableOccurrence;
     if (typeVariableType != null) return typeVariableType;
 
     typeVariableType = _findTypeVariableOccurrence(parameterTypes);
     if (typeVariableType != null) return typeVariableType;
@@ skipping 15 matching lines @@
     namedParameterTypes.forEach((DartType type) {
       type.forEachTypeVariable(f);
     });
   }
 
   accept(DartTypeVisitor visitor, var argument) {
     return visitor.visitFunctionType(this, argument);
   }
 
   void visitChildren(DartTypeVisitor visitor, var argument) {
-   returnType.accept(visitor, argument);
-   DartType.visitList(parameterTypes, visitor, argument);
-   DartType.visitList(optionalParameterTypes, visitor, argument);
-   DartType.visitList(namedParameterTypes, visitor, argument);
+    returnType.accept(visitor, argument);
+    DartType.visitList(parameterTypes, visitor, argument);
+    DartType.visitList(optionalParameterTypes, visitor, argument);
+    DartType.visitList(namedParameterTypes, visitor, argument);
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('(');
     sb.write(parameterTypes.join(', '));
     bool first = parameterTypes.isEmpty;
     if (!optionalParameterTypes.isEmpty) {
       if (!first) {
         sb.write(', ');
       }
       sb.write('[');
       sb.write(optionalParameterTypes.join(', '));
       sb.write(']');
       first = false;
     }
     if (!namedParameterTypes.isEmpty) {
       if (!first) {
         sb.write(', ');
       }
       sb.write('{');
       first = true;
       for (int i = 0; i < namedParameters.length; i++) {
         if (!first) {
           sb.write(', ');
         }
         sb.write(namedParameterTypes[i]);
         sb.write(' ');
-          sb.write(namedParameters[i]);
+        sb.write(namedParameters[i]);
         first = false;
       }
       sb.write('}');
     }
     sb.write(') -> ${returnType}');
     return sb.toString();
   }
 
   String get name => 'Function';
 
   int computeArity() => parameterTypes.length;
 
   int get hashCode {
     int hash = 3 * returnType.hashCode;
-    for (DartType parameter  in parameterTypes) {
+    for (DartType parameter in parameterTypes) {
       hash = 17 * hash + 5 * parameter.hashCode;
     }
-    for (DartType parameter  in optionalParameterTypes) {
+    for (DartType parameter in optionalParameterTypes) {
       hash = 19 * hash + 7 * parameter.hashCode;
     }
-    for (String name  in namedParameters) {
+    for (String name in namedParameters) {
       hash = 23 * hash + 11 * name.hashCode;
     }
-    for (DartType parameter  in namedParameterTypes) {
+    for (DartType parameter in namedParameterTypes) {
       hash = 29 * hash + 13 * parameter.hashCode;
     }
     return hash;
   }
 
   bool operator ==(other) {
-    if (other is !FunctionType) return false;
+    if (other is! FunctionType) return false;
     return returnType == other.returnType &&
         equalElements(parameterTypes, other.parameterTypes) &&
         equalElements(optionalParameterTypes, other.optionalParameterTypes) &&
         equalElements(namedParameters, other.namedParameters) &&
         equalElements(namedParameterTypes, other.namedParameterTypes);
   }
 }
 
 class TypedefType extends GenericType {
   DartType _unaliased;
 
   TypedefType(TypedefElement element,
-              [List<DartType> typeArguments = const <DartType>[]])
+      [List<DartType> typeArguments = const <DartType>[]])
       : super(element, typeArguments);
 
   TypedefType.forUserProvidedBadType(TypedefElement element,
-                                     [List<DartType> typeArguments =
-                                         const <DartType>[]])
+      [List<DartType> typeArguments = const <DartType>[]])
       : super(element, typeArguments, checkTypeArgumentCount: false);
 
   TypedefElement get element => super.element;
 
   TypeKind get kind => TypeKind.TYPEDEF;
 
   String get name => element.name;
 
   TypedefType createInstantiation(List<DartType> newTypeArguments) {
     return new TypedefType(element, newTypeArguments);
@@ skipping 111 matching lines @@
 
   R visitDynamicType(DynamicType type, A argument) => null;
 }
 
 abstract class BaseDartTypeVisitor<R, A> extends DartTypeVisitor<R, A> {
   const BaseDartTypeVisitor();
 
   R visitType(DartType type, A argument);
 
   @override
-  R visitVoidType(VoidType type, A argument) =>
-      visitType(type, argument);
+  R visitVoidType(VoidType type, A argument) => visitType(type, argument);
 
   @override
   R visitTypeVariableType(TypeVariableType type, A argument) =>
       visitType(type, argument);
 
   @override
   R visitFunctionType(FunctionType type, A argument) =>
       visitType(type, argument);
 
   @override
   R visitMalformedType(MalformedType type, A argument) =>
       visitType(type, argument);
 
   @override
   R visitStatementType(StatementType type, A argument) =>
       visitType(type, argument);
 
-  R visitGenericType(GenericType type, A argument) =>
-      visitType(type, argument);
+  R visitGenericType(GenericType type, A argument) => visitType(type, argument);
 
   @override
   R visitInterfaceType(InterfaceType type, A argument) =>
       visitGenericType(type, argument);
 
   @override
   R visitTypedefType(TypedefType type, A argument) =>
       visitGenericType(type, argument);
 
   @override
-  R visitDynamicType(DynamicType type, A argument) =>
-      visitType(type, argument);
+  R visitDynamicType(DynamicType type, A argument) => visitType(type, argument);
 }
 
 /**
  * Abstract visitor for determining relations between types.
  */
 abstract class AbstractTypeRelation
     extends BaseDartTypeVisitor<bool, DartType> {
   final Resolution resolution;
 
   AbstractTypeRelation(this.resolution);
@@ skipping 15 matching lines @@
 
   bool invalidFunctionParameterTypes(DartType t, DartType s);
 
   bool invalidTypeVariableBounds(DartType bound, DartType s);
 
   /// Handle as dynamic for both subtype and more specific relation to avoid
   /// spurious errors from malformed types.
   bool visitMalformedType(MalformedType t, DartType s) => true;
 
   bool visitInterfaceType(InterfaceType t, DartType s) {
-
     // TODO(johnniwinther): Currently needed since literal types like int,
     // double, bool etc. might not have been resolved yet.
     t.element.ensureResolved(resolution);
 
     bool checkTypeArguments(InterfaceType instance, InterfaceType other) {
       List<DartType> tTypeArgs = instance.typeArguments;
       List<DartType> sTypeArgs = other.typeArguments;
       assert(tTypeArgs.length == sTypeArgs.length);
       for (int i = 0; i < tTypeArgs.length; i++) {
         if (invalidTypeArguments(tTypeArgs[i], sTypeArgs[i])) {
           return false;
         }
       }
       return true;
     }
 
     if (s is InterfaceType) {
       InterfaceType instance = t.asInstanceOf(s.element);
       return instance != null && checkTypeArguments(instance, s);
     } else {
       return false;
     }
   }
 
   bool visitFunctionType(FunctionType t, DartType s) {
     if (s == coreTypes.functionType) {
       return true;
     }
-    if (s is !FunctionType) return false;
+    if (s is! FunctionType) return false;
     FunctionType tf = t;
     FunctionType sf = s;
     if (invalidFunctionReturnTypes(tf.returnType, sf.returnType)) {
       return false;
     }
 
     // TODO(johnniwinther): Rewrite the function subtyping to be more readable
     // but still as efficient.
 
     // For the comments we use the following abbreviations:
@@ skipping 18 matching lines @@
       }
       return false;
     }
 
     if (incompatibleParameters()) return false;
     if (tNotEmpty) {
       // We must have [: len(t.p) <= len(s.p) :].
       return false;
     }
     if (!sf.namedParameters.isEmpty) {
-        // We must have [: len(t.p) == len(s.p) :].
+      // We must have [: len(t.p) == len(s.p) :].
       if (sNotEmpty) {
         return false;
       }
       // Since named parameters are globally ordered we can determine the
       // subset relation with a linear search for [:sf.namedParameters:]
       // within [:tf.namedParameters:].
       List<String> tNames = tf.namedParameters;
       List<DartType> tTypes = tf.namedParameterTypes;
       List<String> sNames = sf.namedParameters;
       List<DartType> sTypes = sf.namedParameterTypes;
@@ skipping 109 matching lines @@
 
   bool invalidTypeVariableBounds(DartType bound, DartType s) {
     return !isMoreSpecific(bound, s);
   }
 }
 
 /**
  * Type visitor that determines the subtype relation two types.
  */
 class SubtypeVisitor extends MoreSpecificVisitor {
-
   SubtypeVisitor(Resolution resolution) : super(resolution);
 
   bool isSubtype(DartType t, DartType s) {
     return t.treatAsDynamic || isMoreSpecific(t, s);
   }
 
   bool isAssignable(DartType t, DartType s) {
     return isSubtype(t, s) || isSubtype(s, t);
   }
 
@@ skipping 24 matching lines @@
     }
     return false;
   }
 }
 
 /**
  * Callback used to check whether the [typeArgument] of [type] is a valid
  * substitute for the bound of [typeVariable]. [bound] holds the bound against
  * which [typeArgument] should be checked.
  */
-typedef void CheckTypeVariableBound(GenericType type,
-                                    DartType typeArgument,
-                                    TypeVariableType typeVariable,
-                                    DartType bound);
+typedef void CheckTypeVariableBound(GenericType type, DartType typeArgument,
+    TypeVariableType typeVariable, DartType bound);
 
 /// Basic interface for the Dart type system.
 abstract class DartTypes {
   /// The types defined in 'dart:core'.
   CoreTypes get coreTypes;
 
   /// Returns `true` if [t] is a subtype of [s].
   bool isSubtype(DartType t, DartType s);
 
   /// Returns `true` if [t] might be a subtype of [s] for some values of
@@ skipping 92 matching lines @@
     // TODO(johnniwinther): Return a set of variable points in the positive
     // cases.
     return potentialSubtypeVisitor.isSubtype(t, s);
   }
 
   /**
    * Checks the type arguments of [type] against the type variable bounds
    * declared on [element]. Calls [checkTypeVariableBound] on each type
    * argument and bound.
    */
-  void checkTypeVariableBounds(GenericType type,
-                               CheckTypeVariableBound checkTypeVariableBound) {
+  void checkTypeVariableBounds(
+      GenericType type, CheckTypeVariableBound checkTypeVariableBound) {
     TypeDeclarationElement element = type.element;
     List<DartType> typeArguments = type.typeArguments;
     List<DartType> typeVariables = element.typeVariables;
     assert(typeVariables.length == typeArguments.length);
     for (int index = 0; index < typeArguments.length; index++) {
       TypeVariableType typeVariable = typeVariables[index];
       DartType bound = typeVariable.element.bound.substByContext(type);
       DartType typeArgument = typeArguments[index];
       checkTypeVariableBound(type, typeArgument, typeVariable, bound);
     }
   }
 
   /**
    * Helper method for performing substitution of a list of types.
    *
    * If no types are changed by the substitution, the [types] is returned
    * instead of a newly created list.
    */
   static List<DartType> substTypes(List<DartType> types,
-                                   List<DartType> arguments,
-                                   List<DartType> parameters) {
+      List<DartType> arguments, List<DartType> parameters) {
     bool changed = false;
     List<DartType> result = new List<DartType>.generate(types.length, (index) {
       DartType type = types[index];
       DartType argument = type.subst(arguments, parameters);
       if (!changed && !identical(argument, type)) {
         changed = true;
       }
       return argument;
     });
     // Use the new List only if necessary.
@@ skipping 39 matching lines @@
       return 1;
     }
     if (a.isDynamic) {
       // [b] is not dynamic => a < b.
       return -1;
     } else if (b.isDynamic) {
       // [a] is not dynamic => a > b.
       return 1;
     }
     bool isDefinedByDeclaration(DartType type) {
-      return type.isInterfaceType ||
-             type.isTypedef ||
-             type.isTypeVariable;
+      return type.isInterfaceType || type.isTypedef || type.isTypeVariable;
     }
 
     if (isDefinedByDeclaration(a)) {
       if (isDefinedByDeclaration(b)) {
         int result = Elements.compareByPosition(a.element, b.element);
         if (result != 0) return result;
         if (a.isTypeVariable) {
           return b.isTypeVariable
               ? 0
               : 1; // [b] is not a type variable => a > b.
         } else {
           if (b.isTypeVariable) {
             // [a] is not a type variable => a < b.
             return -1;
           } else {
             return compareList((a as GenericType).typeArguments,
-                               (b as GenericType).typeArguments);
+                (b as GenericType).typeArguments);
           }
         }
       } else {
         // [b] is neither an interface, typedef, type variable, dynamic,
         // nor void => a < b.
         return -1;
       }
     } else if (isDefinedByDeclaration(b)) {
       // [a] is neither an interface, typedef, type variable, dynamic,
       // nor void => a > b.
       return 1;
     }
     if (a.isFunctionType) {
       if (b.isFunctionType) {
         FunctionType aFunc = a;
         FunctionType bFunc = b;
         int result = compare(aFunc.returnType, bFunc.returnType);
         if (result != 0) return result;
         result = compareList(aFunc.parameterTypes, bFunc.parameterTypes);
         if (result != 0) return result;
-        result = compareList(aFunc.optionalParameterTypes,
-                             bFunc.optionalParameterTypes);
+        result = compareList(
+            aFunc.optionalParameterTypes, bFunc.optionalParameterTypes);
         if (result != 0) return result;
         // TODO(karlklose): reuse [compareList].
         Iterator<String> aNames = aFunc.namedParameters.iterator;
         Iterator<String> bNames = bFunc.namedParameters.iterator;
         while (aNames.moveNext() && bNames.moveNext()) {
           int result = aNames.current.compareTo(bNames.current);
           if (result != 0) return result;
         }
         if (aNames.moveNext()) {
           // [aNames] is longer that [bNames] => a > b.
           return 1;
         } else if (bNames.moveNext()) {
           // [bNames] is longer that [aNames] => a < b.
           return -1;
         }
-        return compareList(aFunc.namedParameterTypes,
-                           bFunc.namedParameterTypes);
+        return compareList(
+            aFunc.namedParameterTypes, bFunc.namedParameterTypes);
       } else {
         // [b] is a malformed or statement type => a < b.
         return -1;
       }
     } else if (b.isFunctionType) {
       // [b] is a malformed or statement type => a > b.
       return 1;
     }
     if (a.kind == TypeKind.STATEMENT) {
       if (b.kind == TypeKind.STATEMENT) {
         return 0;
       } else {
         // [b] is a malformed type => a > b.
         return 1;
       }
     } else if (b.kind == TypeKind.STATEMENT) {
       // [a] is a malformed type => a < b.
       return -1;
     }
-    assert (a.isMalformed);
-    assert (b.isMalformed);
+    assert(a.isMalformed);
+    assert(b.isMalformed);
     // TODO(johnniwinther): Can we do this better?
     return Elements.compareByPosition(a.element, b.element);
   }
 
   static int compareList(List<DartType> a, List<DartType> b) {
     for (int index = 0; index < min(a.length, b.length); index++) {
       int result = compare(a[index], b[index]);
       if (result != 0) return result;
     }
     if (a.length > b.length) {
       return 1;
     } else if (a.length < b.length) {
       return -1;
     }
     return 0;
   }
 
   static List<DartType> sorted(Iterable<DartType> types) {
     return types.toList()..sort(compare);
   }
 
   /// Computes the least upper bound of two interface types [a] and [b].
-  InterfaceType computeLeastUpperBoundInterfaces(InterfaceType a,
-                                                 InterfaceType b) {
-
+  InterfaceType computeLeastUpperBoundInterfaces(
+      InterfaceType a, InterfaceType b) {
     /// Returns the set of supertypes of [type] at depth [depth].
     Set<DartType> getSupertypesAtDepth(InterfaceType type, int depth) {
       OrderedTypeSet types = type.element.allSupertypesAndSelf;
       Set<DartType> set = new Set<DartType>();
       types.forEach(depth, (DartType supertype) {
         set.add(supertype.substByContext(type));
       });
       return set;
     }
 
     ClassElement aClass = a.element;
     ClassElement bClass = b.element;
     int maxCommonDepth = min(aClass.hierarchyDepth, bClass.hierarchyDepth);
     for (int depth = maxCommonDepth; depth >= 0; depth--) {
       Set<DartType> aTypeSet = getSupertypesAtDepth(a, depth);
       Set<DartType> bTypeSet = getSupertypesAtDepth(b, depth);
       Set<DartType> intersection = aTypeSet..retainAll(bTypeSet);
       if (intersection.length == 1) {
         return intersection.first;
       }
     }
 
     reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
         'No least upper bound computed for $a and $b.');
     return null;
   }
 
   /// Computes the least upper bound of the types in the longest prefix of [a]
   /// and [b].
-  List<DartType> computeLeastUpperBoundsTypes(List<DartType> a,
-                                              List<DartType> b) {
+  List<DartType> computeLeastUpperBoundsTypes(
+      List<DartType> a, List<DartType> b) {
     if (a.isEmpty || b.isEmpty) return const <DartType>[];
     int prefixLength = min(a.length, b.length);
     List<DartType> types = new List<DartType>(prefixLength);
     for (int index = 0; index < prefixLength; index++) {
       types[index] = computeLeastUpperBound(a[index], b[index]);
     }
     return types;
   }
 
   /// Computes the least upper bound of two function types [a] and [b].
   ///
   /// If the required parameter count of [a] and [b] does not match, `Function`
   /// is returned.
   ///
   /// 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].
-  DartType computeLeastUpperBoundFunctionTypes(FunctionType a,
-                                               FunctionType b) {
+  DartType computeLeastUpperBoundFunctionTypes(FunctionType a, FunctionType b) {
     if (a.parameterTypes.length != b.parameterTypes.length) {
       return coreTypes.functionType;
     }
     DartType returnType = computeLeastUpperBound(a.returnType, b.returnType);
     List<DartType> parameterTypes =
         computeLeastUpperBoundsTypes(a.parameterTypes, b.parameterTypes);
-    List<DartType> optionalParameterTypes =
-        computeLeastUpperBoundsTypes(a.optionalParameterTypes,
-                                     b.optionalParameterTypes);
+    List<DartType> optionalParameterTypes = computeLeastUpperBoundsTypes(
+        a.optionalParameterTypes, b.optionalParameterTypes);
     List<String> namedParameters = <String>[];
     List<String> aNamedParameters = a.namedParameters;
     List<String> bNamedParameters = b.namedParameters;
     List<DartType> namedParameterTypes = <DartType>[];
     List<DartType> aNamedParameterTypes = a.namedParameterTypes;
     List<DartType> bNamedParameterTypes = b.namedParameterTypes;
     int aIndex = 0;
     int bIndex = 0;
-    while (aIndex < aNamedParameters.length &&
-           bIndex < bNamedParameters.length) {
+    while (
+        aIndex < aNamedParameters.length && bIndex < bNamedParameters.length) {
       String aNamedParameter = aNamedParameters[aIndex];
       String bNamedParameter = bNamedParameters[bIndex];
       int result = aNamedParameter.compareTo(bNamedParameter);
       if (result == 0) {
         namedParameters.add(aNamedParameter);
         namedParameterTypes.add(computeLeastUpperBound(
             aNamedParameterTypes[aIndex], bNamedParameterTypes[bIndex]));
       }
       if (result <= 0) {
         aIndex++;
       }
       if (result >= 0) {
         bIndex++;
       }
     }
-    return new FunctionType.synthesized(
-        returnType,
-        parameterTypes, optionalParameterTypes,
-        namedParameters, namedParameterTypes);
+    return new FunctionType.synthesized(returnType, parameterTypes,
+        optionalParameterTypes, namedParameters, namedParameterTypes);
   }
 
   /// Computes the least upper bound of two types of which at least one is a
   /// type variable. The least upper bound of a type variable is defined in
   /// terms of its bound, but to ensure reflexivity we need to check for common
   /// bounds transitively.
-  DartType computeLeastUpperBoundTypeVariableTypes(DartType a,
-                                                   DartType b) {
+  DartType computeLeastUpperBoundTypeVariableTypes(DartType a, DartType b) {
     Set<DartType> typeVariableBounds = new Set<DartType>();
     while (a.isTypeVariable) {
       if (a == b) return a;
       typeVariableBounds.add(a);
       TypeVariableElement element = a.element;
       a = element.bound;
     }
     while (b.isTypeVariable) {
       if (typeVariableBounds.contains(b)) return b;
       TypeVariableElement element = b.element;
@@ skipping 55 matching lines @@
   ///
   ///     unaliasedBound(Foo) = Foo
   ///     unaliasedBound(Bar) = Bar
   ///     unaliasedBound(Unresolved) = `dynamic`
   ///     unaliasedBound(Baz) = ()->dynamic
   ///     unaliasedBound(T) = Bar
   ///     unaliasedBound(S) = unaliasedBound(T) = Bar
   ///     unaliasedBound(U) = unaliasedBound(Baz) = ()->dynamic
   ///     unaliasedBound(X) = unaliasedBound(Y) = `Object`
   ///
-  static DartType computeUnaliasedBound(
-      Resolution resolution,
-      DartType type) {
+  static DartType computeUnaliasedBound(Resolution resolution, DartType type) {
     DartType originalType = type;
     while (type.isTypeVariable) {
       TypeVariableType variable = type;
       type = variable.element.bound;
       if (type == originalType) {
         type = resolution.coreTypes.objectType;
       }
     }
     if (type.isMalformed) {
       return const DynamicType();
@@ skipping 23 matching lines @@
   ///     interfaceType(Baz) = interfaceType(()->dynamic) = Function
   ///     interfaceType(T) = interfaceType(Bar) = Bar
   ///     interfaceType(S) = interfaceType(T) = interfaceType(Bar) = Bar
   ///     interfaceType(U) = interfaceType(Baz)
   ///                      = intefaceType(()->dynamic) = Function
   ///
   /// When typechecking `o.foo` the interface type of the static type of `o` is
   /// used to lookup the existence and type of `foo`.
   ///
   static InterfaceType computeInterfaceType(
-      Resolution resolution,
-      DartType type) {
+      Resolution resolution, DartType type) {
     type = computeUnaliasedBound(resolution, type);
     if (type.treatAsDynamic) {
       return null;
     }
     if (type.isFunctionType) {
       type = resolution.coreTypes.functionType;
     }
     assert(invariant(NO_LOCATION_SPANNABLE, type.isInterfaceType,
         message: "unexpected type kind ${type.kind}."));
     return type;
@@ skipping 27 matching lines @@
   final Types types;
   Map<TypeVariableType, DartType> constraintMap;
 
   MoreSpecificSubtypeVisitor(this.types);
 
   /// Compute an instance of [element] which is more specific than [supertype].
   /// If no instance is found, `null` is returned.
   ///
   /// Note that this computation is a heuristic. It does not find a suggestion
   /// in all possible cases.
-  InterfaceType computeMoreSpecific(ClassElement element,
-                                    InterfaceType supertype) {
+  InterfaceType computeMoreSpecific(
+      ClassElement element, InterfaceType supertype) {
     InterfaceType supertypeInstance =
         element.thisType.asInstanceOf(supertype.element);
     if (supertypeInstance == null) return null;
 
     constraintMap = new Map<TypeVariableType, DartType>();
     element.typeVariables.forEach((TypeVariableType typeVariable) {
       constraintMap[typeVariable] = const DynamicType();
     });
     if (supertypeInstance.accept(this, supertype)) {
       List<DartType> variables = element.typeVariables;
@@ skipping 10 matching lines @@
 
   bool visitTypes(List<DartType> a, List<DartType> b) {
     int prefixLength = min(a.length, b.length);
     for (int index = 0; index < prefixLength; index++) {
       if (!a[index].accept(this, b[index])) return false;
     }
     return prefixLength == a.length && a.length == b.length;
   }
 
   bool visitTypeVariableType(TypeVariableType type, DartType argument) {
-    DartType constraint =
-        types.getMostSpecific(constraintMap[type], argument);
+    DartType constraint = types.getMostSpecific(constraintMap[type], argument);
     constraintMap[type] = constraint;
     return constraint != null;
   }
 
   bool visitFunctionType(FunctionType type, DartType argument) {
     if (argument is FunctionType) {
-      if (type.parameterTypes.length !=
-          argument.parameterTypes.length) {
+      if (type.parameterTypes.length != argument.parameterTypes.length) {
         return false;
       }
       if (type.optionalParameterTypes.length !=
           argument.optionalParameterTypes.length) {
         return false;
       }
       if (type.namedParameters != argument.namedParameters) {
         return false;
       }
 
       if (!type.returnType.accept(this, argument.returnType)) return false;
       if (visitTypes(type.parameterTypes, argument.parameterTypes)) {
         return false;
       }
-      if (visitTypes(type.optionalParameterTypes,
-                     argument.optionalParameterTypes)) {
+      if (visitTypes(
+          type.optionalParameterTypes, argument.optionalParameterTypes)) {
         return false;
       }
       return visitTypes(type.namedParameterTypes, argument.namedParameterTypes);
     }
     return false;
   }
 
   bool visitGenericType(GenericType type, DartType argument) {
     if (argument is GenericType) {
       if (type.element != argument.element) return false;
@@ skipping 103 matching lines @@
           sb.write(', ');
         }
         namedParameterTypes[index].accept(this, namedParameters[index]);
         needsComma = true;
       }
       sb.write('}');
     }
     sb.write(')');
   }
 }
-