Revert "Normalize type masks to use the least upper instantiated subclass/type."

tests/compiler/dart2js/type_combination_test.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.
 
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/js_backend/backend_helpers.dart';
 import 'package:compiler/src/js_backend/js_backend.dart';
 import 'package:compiler/src/types/types.dart';
 import 'package:compiler/src/world.dart';
@@ skipping 58 matching lines @@
     typesSeen..add(type1)..add(type2);
     var pair1 = new Pair(type1, type2);
     var pair2 = new Pair(type2, type1);
     if (pairsSeen.contains(pair1)) {
       Expect.isFalse(true, 'Redundant rule ($type1, $type2, ...)');
     }
     pairsSeen..add(pair1)..add(pair2);
 
     var r1 = operate(type1, type2);
     var r2 = operate(type2, type1);
-    Expect.equals(result, r1,
-        "Unexpected result of $name($type1,$type2)");
-    Expect.equals(r1, r2, 'Symmetry violation of $name($type1,$type2)');
+    Expect.equals(result, r1);
+    Expect.equals(r1, r2, 'symmetry violation');
   }
 
   void check(type1, type2, predicate) {
     typesSeen..add(type1)..add(type2);
     var pair = new Pair(type1, type2);
     pairsSeen..add(pair);
     var result = operate(type1, type2);
     Expect.isTrue(predicate(result));
   }
 
@@ skipping 633 matching lines @@
 
 void testRegressions(MockCompiler compiler) {
   TypeMask nonNullPotentialString = new TypeMask.nonNullSubtype(
       patternClass, compiler.world);
   Expect.equals(
       potentialString, jsStringOrNull.union(
           nonNullPotentialString, compiler.world));
 }
 
 void main() {
-  asyncTest(() async {
-    MockCompiler compiler = new MockCompiler.internal();
-    await compiler.init("""
-    class PatternImpl implements Pattern {}
-    """);
+  asyncTest(() => MockCompiler.create((MockCompiler compiler) {
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
     World world = compiler.world;
     helpers.interceptorsLibrary.forEachLocalMember((element) {
       if (element.isClass) {
         element.ensureResolved(compiler.resolution);
         backend.registerInstantiatedType(
             element.rawType,
             compiler.enqueuer.resolution,
             compiler.globalDependencies);
       }
     });
-    ClassElement patternImplClass = compiler.mainApp.find('PatternImpl');
-    patternImplClass.ensureResolved(compiler.resolution);
-
     backend.registerInstantiatedType(
         compiler.coreTypes.mapType(),
         compiler.enqueuer.resolution,
         compiler.globalDependencies);
     backend.registerInstantiatedType(
         compiler.coreTypes.functionType,
         compiler.enqueuer.resolution,
         compiler.globalDependencies);
-    backend.registerInstantiatedType(
-        patternImplClass.rawType,
-        compiler.enqueuer.resolution,
-        compiler.globalDependencies);
     compiler.world.populate();
 
     // Grab hold of a supertype for String so we can produce potential
     // string types.
     patternClass = compiler.coreLibrary.find('Pattern');
 
     nonPrimitive1 = new TypeMask.nonNullSubtype(
         compiler.coreClasses.mapClass, world);
     nonPrimitive2 = new TypeMask.nonNullSubtype(
         compiler.coreClasses.functionClass, world);
@@ skipping 33 matching lines @@
     jsNumberOrNull = new TypeMask.subclass(helpers.jsNumberClass, world);
     jsIntegerOrNull = new TypeMask.exact(helpers.jsIntClass, world);
     jsDoubleOrNull = new TypeMask.exact(helpers.jsDoubleClass, world);
     nullType = const TypeMask.empty();
     objectType = new TypeMask.nonNullSubclass(
         compiler.coreClasses.objectClass, world);
     emptyType = const TypeMask.nonNullEmpty();
     dynamicType = new TypeMask.subclass(
         compiler.coreClasses.objectClass, world);
 
-    Expect.notEquals(emptyType, nonPrimitive1,
-        "nonPrimitive1 expected to be non-empty.");
-    Expect.notEquals(jsStringOrNull, potentialString,
-        "potentialString expected not to be exact JSString");
-    Expect.notEquals(jsArrayOrNull, potentialArray,
-        "potentialArray expected not to be JSArray subclass");
-
     testUnion(compiler);
     testIntersection(compiler);
     testRegressions(compiler);
-  });
+  }));
 }