dart2js: add compiler builtins to the core-runtime.

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.
 
 part of native;
 
 /// This class is a temporary work-around until we get a more powerful DartType.
 class SpecialType {
   final String name;
   const SpecialType._(this.name);
@@ skipping 476 matching lines @@
           .visit(behavior.codeTemplate.ast);
     }
     if (!throwBehaviorFromSpecString) {
       behavior.throwBehavior =
           new ThrowBehaviorVisitor().analyze(behavior.codeTemplate.ast);
     }
 
     return behavior;
   }
 
-  static NativeBehavior ofJsEmbeddedGlobalCall(Send jsGlobalCall,
-                                               Compiler compiler,
-                                               resolver) {
+  static void _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
+      NativeBehavior behavior,
+      Send jsBuiltinOrEmbeddedGlobalCall,
+      Compiler compiler,
+      ResolverVisitor resolver,
+      {bool isBuiltin,
+       List<String> validTags}) {
     // 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.
 
-    Link<Node> argNodes = jsGlobalCall.arguments;
+    String builtinOrGlobal = isBuiltin ? "builtin" : "embedded global";
+
+    Link<Node> argNodes = jsBuiltinOrEmbeddedGlobalCall.arguments;
     if (argNodes.isEmpty) {
-      compiler.internalError(jsGlobalCall,
-          "JS embedded global expression has no type.");
+      compiler.internalError(jsBuiltinOrEmbeddedGlobalCall,
+          "JS $builtinOrGlobal expression has no type.");
     }
 
     // We don't check the given name. That needs to be done at a later point.
-    // This is, because we want to allow non-literals as names.
+    // This is, because we want to allow non-literals (like references to
+    // enums) as names.
     if (argNodes.tail.isEmpty) {
-      compiler.internalError(jsGlobalCall, 'Embedded Global is missing name.');
+      compiler.internalError(jsBuiltinOrEmbeddedGlobalCall,
+          'JS $builtinOrGlobal is missing name.');
     }
 
-    if (!argNodes.tail.tail.isEmpty) {
-      compiler.internalError(argNodes.tail.tail.head,
-          'Embedded Global has more than 2 arguments');
+    if (!isBuiltin) {
+      if (!argNodes.tail.tail.isEmpty) {
+        compiler.internalError(argNodes.tail.tail.head,
+            'JS embedded global has more than 2 arguments');
+      }
     }
 
     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.
       compiler.internalError(argNodes.head, "Unexpected first argument.");
     }
 
-    NativeBehavior behavior = new NativeBehavior();
-
     String specString = specLiteral.dartString.slowToString();
 
     dynamic resolveType(String typeString) {
       return _parseType(
           typeString,
           compiler,
           (name) => resolver.resolveTypeFromString(specLiteral, name),
-          jsGlobalCall);
+          jsBuiltinOrEmbeddedGlobalCall);
     }
 
-    processSpecString(compiler, jsGlobalCall,
+    void setSideEffects(SideEffects newEffects) {
+      behavior.sideEffects.setTo(newEffects);
+    }
+
+    processSpecString(compiler, jsBuiltinOrEmbeddedGlobalCall,
                       specString,
-                      validTags: const ['returns', 'creates'],
+                      validTags: validTags,
                       resolveType: resolveType,
+                      setSideEffects: setSideEffects,
                       typesReturned: behavior.typesReturned,
                       typesInstantiated: behavior.typesInstantiated,
                       objectType: compiler.objectClass.computeType(compiler),
                       nullType: compiler.nullClass.computeType(compiler));
+  }
 
-    // Embedded globals are usually pre-computed data structures or JavaScript
-    // functions that never change.
-    // TODO(sra): Allow the use site to override these defaults.
-    behavior.sideEffects.clearAllDependencies();
-    behavior.sideEffects.clearAllSideEffects();
-    behavior.throwBehavior = NativeThrowBehavior.NEVER;
+  static NativeBehavior ofJsBuiltinCall(Send jsBuiltinCall,
+                                        Compiler compiler,
+                                        ResolverVisitor resolver) {
+    NativeBehavior behavior = new NativeBehavior();
+    behavior.sideEffects.setTo(new SideEffects());
+
+    _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
+        behavior, jsBuiltinCall, compiler, resolver, isBuiltin: true);
 
     return behavior;
   }
 
+  static NativeBehavior ofJsEmbeddedGlobalCall(Send jsEmbeddedGlobalCall,
+                                               Compiler compiler,
+                                               ResolverVisitor 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;
+
+    _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
+        behavior, jsEmbeddedGlobalCall, compiler, resolver,
+        isBuiltin: false,
+        validTags: const ['returns', 'creates']);
+
+    return behavior;
+  }
+
   static NativeBehavior ofMethod(FunctionElement method, Compiler compiler) {
     FunctionType type = method.computeType(compiler);
     var behavior = new NativeBehavior();
     behavior.typesReturned.add(type.returnType);
     if (!type.returnType.isVoid) {
       // Declared types are nullable.
       behavior.typesReturned.add(compiler.nullClass.computeType(compiler));
     }
     behavior._capture(type, compiler);
 
@@ skipping 148 matching lines @@
         MessageKind.GENERIC,
         {'text': "Type '$typeString' not found."});
     return const DynamicType();
   }
 
   static _errorNode(locationNodeOrElement, compiler) {
     if (locationNodeOrElement is Node) return locationNodeOrElement;
     return locationNodeOrElement.parseNode(compiler);
   }
 }