Fix static warnings spotted by dartc.

sdk/lib/_internal/compiler/implementation/types/union_type_mask.dart

 // Copyright (c) 2013, 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.
 
 part of types;
 
 class UnionTypeMask implements TypeMask {
   final Iterable<FlatTypeMask> disjointMasks;
 
   static const int MAX_UNION_LENGTH = 4;
@@ skipping 12 matching lines @@
   static void unionOfHelper(Iterable<TypeMask> masks,
                             List<FlatTypeMask> disjoint,
                             Compiler compiler) {
     for (TypeMask mask in masks) {
       if (mask.isUnion) {
         UnionTypeMask union = mask;
         unionOfHelper(union.disjointMasks, disjoint, compiler);
       } else if (mask.isEmpty && !mask.isNullable) {
         continue;
       } else {
-        assert(mask.base == null || mask.base.element != compiler.dynamicClass);
-        assert(mask is FlatTypeMask);
+        FlatTypeMask flatMask = mask;
+        assert(flatMask.base == null
+               || flatMask.base.element != compiler.dynamicClass);
         int inListIndex = -1;
         bool covered = false;
 
         // Iterate over [disjoint] to find out if one of the mask
         // already covers [mask].
         for (int i = 0; i < disjoint.length; i++) {
           FlatTypeMask current = disjoint[i];
           if (current == null) continue;
           TypeMask newMask = mask.union(current, compiler);
           // If we have found a disjoint union, continue iterating.
@@ skipping 32 matching lines @@
     // If either type mask is a subtype type mask, we cannot use a
     // subclass type mask to represent their union.
     bool useSubclass = masks.every((e) => !e.isSubtype);
     bool isNullable = masks.any((e) => e.isNullable);
 
     // Compute the common supertypes of the two types.
     ClassElement firstElement = masks[0].base.element;
     ClassElement secondElement = masks[1].base.element;
     Iterable<ClassElement> candidates =
         compiler.world.commonSupertypesOf(firstElement, secondElement);
+    bool unseenType = false;
     for (int i = 2; i < masks.length; i++) {
       ClassElement element = masks[i].base.element;
       Set<ClassElement> supertypes = compiler.world.supertypesOf(element);
       if (supertypes == null) {
-        candidates.clear();
+        unseenType = true;
         break;
       }
       candidates = candidates.where((e) => supertypes.contains(e));
     }
 
-    if (candidates.isEmpty) {
+    if (candidates.isEmpty || unseenType) {
       // TODO(kasperl): Get rid of this check. It can only happen when
       // at least one of the two base types is 'unseen'.
       return new TypeMask(compiler.objectClass.rawType,
                           FlatTypeMask.SUBCLASS,
                           isNullable);
     }
     // Compute the best candidate and its kind.
     ClassElement bestElement;
     int bestKind;
     int bestSize;
@@ skipping 140 matching lines @@
 
   String toString() => 'Union of $disjointMasks';
 
   bool operator==(other) {
     if (identical(this, other)) return true;
     return other is UnionTypeMask
         && other.disjointMasks.length == disjointMasks.length
         && other.disjointMasks.every((e) => disjointMasks.contains(e));
   }
 }