Handle int constant

pkg/compiler/lib/src/js_backend/mirrors_data.dart

 // Copyright (c) 2017, 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 '../closure.dart';
 import '../common.dart';
 import '../common_elements.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart';
@@ skipping 287 matching lines @@
         return true;
       }
     }
     return false;
   }
 
   void _retainMetadataOf(Element element) {
     for (MetadataAnnotation metadata in element.metadata) {
       metadata.ensureResolved(_compiler.resolution);
       ConstantValue constant = _constants.getConstantValueForMetadata(metadata);
-      _constants.addCompileTimeConstantForEmission(constant);
+      CodegenWorldBuilder worldBuilder = _compiler.codegenWorldBuilder;
+      worldBuilder.addCompileTimeConstantForEmission(constant);
     }
   }
 
   bool invokedReflectively(Element element) {
     if (element.isParameter) {
       ParameterElement parameter = element;
       if (invokedReflectively(parameter.functionDeclaration)) return true;
     }
 
     if (element.isField) {
@@ skipping 50 matching lines @@
     if (metaTargets != null) {
       for (var element in metaTargets) {
         if (element is ClassEntity) {
           metaTargetsUsed.add(element);
         }
       }
     }
   }
 
   @override
-  bool isClassAccessibleByReflection(ClassElement element) {
+  bool isClassAccessibleByReflection(ClassEntity element) {
     return _classesNeededForReflection.contains(_getDartClass(element));
   }
 
   @override
   bool isTypedefAccessibleByReflection(TypedefElement element) {
     return _typedefsNeededForReflection.contains(element);
   }
 
   bool isAccessibleByReflection(Element element) {
     if (element.isLibrary) {
       return false;
     } else if (element.isClass) {
-      return isClassAccessibleByReflection(element);
+      ClassElement cls = element;
+      return isClassAccessibleByReflection(cls);
     } else if (element.isTypedef) {
       return isTypedefAccessibleByReflection(element);
     } else {
       MemberElement member = element;
       return isMemberAccessibleByReflection(member);
     }
   }
 
-  ClassElement _getDartClass(ClassElement cls) {
+  ClassEntity _getDartClass(ClassEntity cls) {
     if (cls == _commonElements.jsIntClass) {
       return _commonElements.intClass;
     } else if (cls == _commonElements.jsBoolClass) {
       return _commonElements.boolClass;
     } else if (cls == _commonElements.jsNumberClass) {
       return _commonElements.numClass;
     } else if (cls == _commonElements.jsDoubleClass) {
       return _commonElements.doubleClass;
     } else if (cls == _commonElements.jsStringClass) {
       return _commonElements.stringClass;
@@ skipping 283 matching lines @@
   }
 
   /// Called when `const Symbol(name)` is seen.
   void registerConstSymbol(String name) {
     symbolsUsed.add(name);
     if (name.endsWith('=')) {
       symbolsUsed.add(name.substring(0, name.length - 1));
     }
   }
 }