Fix host-checked + checked by registering when a class is being instantiated, not when being proces…

lib/compiler/implementation/compile_time_constants.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 Constant implements Hashable {
   const Constant();
 
   bool isNull() => false;
   bool isBool() => false;
   bool isTrue() => false;
@@ skipping 33 matching lines @@
         "The parameter sentinel constant does not need specific JS code");
   }
 
   void _writeCanonicalizedJsCode(CodeBuffer buffer, ConstantHandler handler) {
     buffer.add(handler.compiler.namer.CURRENT_ISOLATE);
   }
 
   List<Constant> getDependencies() => const <Constant>[];
 
   // Just use a randome value.
-  int hashCode() => 9264297841582447;
+  int hashCode() => 926429784158;
 
   bool isSentinel() => true;
 }
 
 class FunctionConstant extends Constant {
   Element element;
 
   FunctionConstant(this.element);
 
   bool isFunction() => true;
@@ skipping 11 matching lines @@
 
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
     handler.compiler.internalError(
         "A constant function does not need specific JS code");
   }
 
   void _writeCanonicalizedJsCode(CodeBuffer buffer, ConstantHandler handler) {
     buffer.add(handler.compiler.namer.isolatePropertiesAccess(element));
   }
 
-  int hashCode() => element.hashCode();
+  int hashCode() => (17 * element.hashCode()) & 0x7fffffff;
 }
 
 class PrimitiveConstant extends Constant {
   abstract get value;
   const PrimitiveConstant();
   bool isPrimitive() => true;
 
   bool operator ==(var other) {
     if (other is !PrimitiveConstant) return false;
     PrimitiveConstant otherPrimitive = other;
@@ skipping 813 matching lines @@
     DartType keysType = null;
     ListConstant keysList = new ListConstant(keysType, keys);
     compiler.constantHandler.registerCompileTimeConstant(keysList);
     SourceString className = hasProtoKey
                              ? MapConstant.DART_PROTO_CLASS
                              : MapConstant.DART_CLASS;
     ClassElement classElement = compiler.jsHelperLibrary.find(className);
     classElement.ensureResolved(compiler);
     // TODO(floitsch): copy over the generic type.
     DartType type = new InterfaceType(classElement);
-    compiler.registerInstantiatedClass(classElement);
+    compiler.enqueuer.codegen.registerInstantiatedClass(classElement);
     Constant constant = new MapConstant(type, keysList, values, protoValue);
     compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitLiteralNull(LiteralNull node) {
     return new NullConstant();
   }
 
   Constant visitLiteralString(LiteralString node) {
@@ skipping 210 matching lines @@
     }
 
     Selector selector = elements.getSelector(send);
     List<Constant> arguments =
         evaluateArgumentsToConstructor(selector, send.arguments, constructor);
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(constructor, compiler);
     evaluator.evaluateConstructorFieldValues(arguments);
     List<Constant> jsNewArguments = evaluator.buildJsNewArguments(classElement);
 
-    compiler.registerInstantiatedClass(classElement);
+    compiler.enqueuer.codegen.registerInstantiatedClass(classElement);
     // TODO(floitsch): take generic types into account.
     DartType type = classElement.computeType(compiler);
     Constant constant = new ConstructedConstant(type, jsNewArguments);
     compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
@@ skipping 166 matching lines @@
       Constant fieldValue = fieldValues[field];
       if (fieldValue === null) {
         // Use the default value.
         fieldValue = compiler.compileConstant(field);
       }
       jsNewArguments.add(fieldValue);
     });
     return jsNewArguments;
   }
 }