Merge CoreTypes and CoreClasses into CommonElements.

pkg/compiler/lib/src/native/behavior.dart

 // Copyright (c) 2014, 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 '../common.dart';
 import '../common/backend_api.dart' show ForeignResolver;
 import '../common/resolution.dart' show ParsingContext, Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart';
 import '../constants/values.dart';
-import '../core_types.dart' show CoreTypes;
+import '../core_types.dart' show CommonElements;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../js/js.dart' as js;
 import '../js_backend/js_backend.dart';
 import '../tree/tree.dart';
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart';
 import 'enqueue.dart';
 import 'js.dart';
 
@@ skipping 469 matching lines @@
     return sideEffects;
   }
 
   /// Returns a [TypeLookup] that uses [resolver] to perform lookup and [node]
   /// as position for errors.
   static TypeLookup _typeLookup(Node node, ForeignResolver resolver) {
     return (String name) => resolver.resolveTypeFromString(node, name);
   }
 
   /// Compute the [NativeBehavior] for a [Send] node calling the 'JS' function.
-  static NativeBehavior ofJsCallSend(Send jsCall, DiagnosticReporter reporter,
-      ParsingContext parsing, CoreTypes coreTypes, ForeignResolver resolver) {
+  static NativeBehavior ofJsCallSend(
+      Send jsCall,
+      DiagnosticReporter reporter,
+      ParsingContext parsing,
+      CommonElements commonElements,
+      ForeignResolver resolver) {
     var argNodes = jsCall.arguments;
     if (argNodes.isEmpty || argNodes.tail.isEmpty) {
       reporter.reportErrorMessage(jsCall, MessageKind.WRONG_ARGUMENT_FOR_JS);
       return new NativeBehavior();
     }
 
     var specArgument = argNodes.head;
     if (specArgument is! StringNode || specArgument.isInterpolation) {
       reporter.reportErrorMessage(
           specArgument, MessageKind.WRONG_ARGUMENT_FOR_JS_FIRST);
       return new NativeBehavior();
     }
 
     var codeArgument = argNodes.tail.head;
     if (codeArgument is! StringNode || codeArgument.isInterpolation) {
       reporter.reportErrorMessage(
           codeArgument, MessageKind.WRONG_ARGUMENT_FOR_JS_SECOND);
       return new NativeBehavior();
     }
 
     String specString = specArgument.dartString.slowToString();
     String codeString = codeArgument.dartString.slowToString();
 
     return ofJsCall(specString, codeString, _typeLookup(specArgument, resolver),
-        specArgument, reporter, coreTypes);
+        specArgument, reporter, commonElements);
   }
 
   /// Compute the [NativeBehavior] for a call to the 'JS' function with the
   /// given [specString] and [codeString] (first and second arguments).
   static NativeBehavior ofJsCall(
       String specString,
       String codeString,
       TypeLookup lookupType,
       Spannable spannable,
       DiagnosticReporter reporter,
-      CoreTypes coreTypes) {
+      CommonElements commonElements) {
     // The first argument of a JS-call is a string encoding various attributes
     // of the code.
     //
     //  'Type1|Type2'.  A union type.
     //  '=Object'.      A JavaScript Object, no subtype.
 
     NativeBehavior behavior = new NativeBehavior();
 
     behavior.codeTemplateText = codeString;
     behavior.codeTemplate = js.js.parseForeignJS(behavior.codeTemplateText);
@@ skipping 20 matching lines @@
     }
 
     processSpecString(reporter, spannable, specString,
         setSideEffects: setSideEffects,
         setThrows: setThrows,
         setIsAllocation: setIsAllocation,
         setUseGvn: setUseGvn,
         lookupType: lookupType,
         typesReturned: behavior.typesReturned,
         typesInstantiated: behavior.typesInstantiated,
-        objectType: coreTypes.objectType,
-        nullType: coreTypes.nullType);
+        objectType: commonElements.objectType,
+        nullType: commonElements.nullType);
 
     if (!sideEffectsAreEncodedInSpecString) {
       new SideEffectsVisitor(behavior.sideEffects)
           .visit(behavior.codeTemplate.ast);
     }
     if (!throwBehaviorFromSpecString) {
       behavior.throwBehavior =
           new ThrowBehaviorVisitor().analyze(behavior.codeTemplate.ast);
     }
 
     return behavior;
   }
 
   static void _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
       NativeBehavior behavior,
       Spannable spannable,
       String specString,
       TypeLookup lookupType,
       DiagnosticReporter reporter,
-      CoreTypes coreTypes,
+      CommonElements commonElements,
       {List<String> validTags}) {
     void setSideEffects(SideEffects newEffects) {
       behavior.sideEffects.setTo(newEffects);
     }
 
     processSpecString(reporter, spannable, specString,
         validTags: validTags,
         lookupType: lookupType,
         setSideEffects: setSideEffects,
         typesReturned: behavior.typesReturned,
         typesInstantiated: behavior.typesInstantiated,
-        objectType: coreTypes.objectType,
-        nullType: coreTypes.nullType);
+        objectType: commonElements.objectType,
+        nullType: commonElements.nullType);
   }
 
   static NativeBehavior ofJsBuiltinCallSend(
       Send jsBuiltinCall,
       DiagnosticReporter reporter,
-      CoreTypes coreTypes,
+      CommonElements commonElements,
       ForeignResolver resolver) {
     NativeBehavior behavior = new NativeBehavior();
     behavior.sideEffects.setTo(new SideEffects());
 
     // The first argument of a JS-embedded global call is a string encoding
     // the type of the code.
     //
     //  'Type1|Type2'.  A union type.
     //  '=Object'.      A JavaScript Object, no subtype.
 
@@ skipping 13 matching lines @@
     LiteralString specLiteral = argNodes.head.asLiteralString();
     if (specLiteral == null) {
       // TODO(sra): We could accept a type identifier? e.g. JS(bool, '1<2').  It
       // is not very satisfactory because it does not work for void, dynamic.
       reporter.internalError(argNodes.head, "Unexpected first argument.");
     }
 
     String specString = specLiteral.dartString.slowToString();
 
     return ofJsBuiltinCall(specString, _typeLookup(jsBuiltinCall, resolver),
-        jsBuiltinCall, reporter, coreTypes);
+        jsBuiltinCall, reporter, commonElements);
   }
 
   static NativeBehavior ofJsBuiltinCall(
       String specString,
       TypeLookup lookupType,
       Spannable spannable,
       DiagnosticReporter reporter,
-      CoreTypes coreTypes) {
+      CommonElements commonElements) {
     NativeBehavior behavior = new NativeBehavior();
     behavior.sideEffects.setTo(new SideEffects());
     _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
-        behavior, spannable, specString, lookupType, reporter, coreTypes);
+        behavior, spannable, specString, lookupType, reporter, commonElements);
     return behavior;
   }
 
   static NativeBehavior ofJsEmbeddedGlobalCallSend(
       Send jsEmbeddedGlobalCall,
       DiagnosticReporter reporter,
-      CoreTypes coreTypes,
+      CommonElements commonElements,
       ForeignResolver resolver) {
     NativeBehavior behavior = new NativeBehavior();
     // TODO(sra): Allow the use site to override these defaults.
     // Embedded globals are usually pre-computed data structures or JavaScript
     // functions that never change.
     behavior.sideEffects.setTo(new SideEffects.empty());
     behavior.throwBehavior = NativeThrowBehavior.NEVER;
 
     // The first argument of a JS-embedded global call is a string encoding
     // the type of the code.
@@ skipping 27 matching lines @@
       reporter.internalError(argNodes.head, "Unexpected first argument.");
     }
 
     String specString = specLiteral.dartString.slowToString();
 
     return ofJsEmbeddedGlobalCall(
         specString,
         _typeLookup(jsEmbeddedGlobalCall, resolver),
         jsEmbeddedGlobalCall,
         reporter,
-        coreTypes);
+        commonElements);
   }
 
   static NativeBehavior ofJsEmbeddedGlobalCall(
       String specString,
       TypeLookup lookupType,
       Spannable spannable,
       DiagnosticReporter reporter,
-      CoreTypes coreTypes) {
+      CommonElements commonElements) {
     NativeBehavior behavior = new NativeBehavior();
     // TODO(sra): Allow the use site to override these defaults.
     // Embedded globals are usually pre-computed data structures or JavaScript
     // functions that never change.
     behavior.sideEffects.setTo(new SideEffects.empty());
     behavior.throwBehavior = NativeThrowBehavior.NEVER;
     _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
-        behavior, spannable, specString, lookupType, reporter, coreTypes,
+        behavior, spannable, specString, lookupType, reporter, commonElements,
         validTags: ['returns', 'creates']);
     return behavior;
   }
 
   static NativeBehavior ofMethodElement(
       FunctionElement element, Compiler compiler) {
     FunctionType type = element.computeType(compiler.resolution);
     List<ConstantExpression> metadata = <ConstantExpression>[];
     for (MetadataAnnotation annotation in element.implementation.metadata) {
       annotation.ensureResolved(compiler.resolution);
@@ skipping 30 matching lines @@
     // that interop calls create only interop types (which may be unsound if
     // an interop call returns a DOM type and declares a dynamic return type,
     // but otherwise we would include a lot of code by default).
     // TODO(sigmund,sra): consider doing something better for numeric types.
     behavior.typesReturned.add(
         !isJsInterop || compiler.options.trustJSInteropTypeAnnotations
             ? returnType
             : const DynamicType());
     if (!type.returnType.isVoid) {
       // Declared types are nullable.
-      behavior.typesReturned.add(compiler.coreTypes.nullType);
+      behavior.typesReturned.add(compiler.commonElements.nullType);
     }
     behavior._capture(type, compiler.resolution,
         isInterop: isJsInterop, compiler: compiler);
 
     for (DartType type in type.optionalParameterTypes) {
       behavior._escape(type, compiler.resolution);
     }
     for (DartType type in type.namedParameterTypes) {
       behavior._escape(type, compiler.resolution);
     }
@@ skipping 34 matching lines @@
       Compiler compiler,
       {bool isJsInterop}) {
     Resolution resolution = compiler.resolution;
     var behavior = new NativeBehavior();
     // TODO(sigmund,sra): consider doing something better for numeric types.
     behavior.typesReturned.add(
         !isJsInterop || compiler.options.trustJSInteropTypeAnnotations
             ? type
             : const DynamicType());
     // Declared types are nullable.
-    behavior.typesReturned.add(resolution.coreTypes.nullType);
+    behavior.typesReturned.add(resolution.commonElements.nullType);
     behavior._capture(type, resolution,
         isInterop: isJsInterop, compiler: compiler);
     behavior._overrideWithAnnotations(
         spannable, metadata, lookupType, compiler);
     return behavior;
   }
 
   static NativeBehavior ofFieldElementStore(
       MemberElement field, Resolution resolution) {
     DartType type = field.computeType(resolution);
@@ skipping 149 matching lines @@
     type = lookupType(typeString.substring(0, index));
     if (type != null) {
       // TODO(sra): Parse type parameters.
       return type;
     }
     reporter.reportErrorMessage(spannable, MessageKind.GENERIC,
         {'text': "Type '$typeString' not found."});
     return const DynamicType();
   }
 }