Merge functionality of HExactType into HBoundedType and fix computation of unions and intersections.

lib/compiler/implementation/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 314 matching lines @@
       HInstruction thisInstruction = new HThis();
       builder.add(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
     } else if (function.isInstanceMember()
                || function.isGenerativeConstructor()) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       ClassElement cls = function.enclosingElement;
       Type type = cls.computeType(builder.compiler);
-      HInstruction thisInstruction = new HThis(new HBoundedType(type));
+      HInstruction thisInstruction = new HThis(new HBoundedType.nonNull(type));
       builder.add(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
   }
 
   bool hasValueForDirectLocal(Element element) {
     assert(element !== null);
     assert(isAccessedDirectly(element));
     return directLocals[element] !== null;
   }
@@ skipping 75 matching lines @@
   HType cachedTypeOfThis;
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisElement);
     if (res.guaranteedType === null) {
       if (cachedTypeOfThis === null) {
         assert(closureData.isClosure());
         Element element = closureData.thisElement;
         ClassElement cls = element.enclosingElement.enclosingElement;
         Type type = cls.computeType(builder.compiler);
-        cachedTypeOfThis = new HBoundedType(type);
+        cachedTypeOfThis = new HBoundedType.nonNull(type);
       }
       res.guaranteedType = cachedTypeOfThis;
     }
     return res;
   }
 
   /**
    * Sets the [element] to [value]. If the element is boxed or stored in a
    * closure then the method generates code to set the value.
    */
@@ skipping 1860 matching lines @@
     computeType(element) {
       Element originalElement = elements[node];
       if (originalElement.enclosingElement === compiler.listClass) {
         if (node.arguments.isEmpty()) {
           return HType.EXTENDABLE_ARRAY;
         } else {
           return HType.MUTABLE_ARRAY;
         }
       } else if (element.isGenerativeConstructor()) {
         ClassElement cls = element.enclosingElement;
-        return new HExactType(cls.type);
+        return new HBoundedType.exact(cls.type);
       } else {
         return HType.UNKNOWN;
       }
     }
 
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     compiler.resolver.resolveMethodElement(element);
     FunctionElement functionElement = element;
     element = functionElement.defaultImplementation;
@@ skipping 1056 matching lines @@
                                    <HInstruction>[target, input],
                                    HType.STRING));
     return builder.pop();
   }
 
   HInstruction result(Node node) {
     flushLiterals(node);
     return prefix;
   }
 }