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 196 matching lines @@
                       specString,
                       resolveType: resolveType,
                       typesReturned: behavior.typesReturned,
                       typesInstantiated: behavior.typesInstantiated,
                       objectType: compiler.objectClass.computeType(compiler),
                       nullType: compiler.nullClass.computeType(compiler));
 
     return behavior;
   }
 
-  static NativeBehavior ofJsEmbeddedGlobalCall(Send jsGlobalCall,
-                                               Compiler compiler,
-                                               resolver) {
+  static NativeBehavior _ofMacroOrEmbeddedGlobal(Send jsMacroOrGlobalCall,
+                                                 Compiler compiler,
+                                                 ResolverVisitor resolver,
+                                                 {bool isMacro}) {
     // 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 macroOrGlobal = isMacro ? "macro" : "embedded global";
+
+    Link<Node> argNodes = jsMacroOrGlobalCall.arguments;
     if (argNodes.isEmpty) {
-      compiler.internalError(jsGlobalCall,
-          "JS embedded global expression has no type.");
+      compiler.internalError(jsMacroOrGlobalCall,
+          "JS $macroOrGlobal expression has no type.");
     }
 
     // We don't check the given name. That needs to be done at a later point.

[herhut, 2015/02/26 08:50:28]

For macros, the name has to be a literal. Otherwise, we cannot instantiate the
corresponding template at compile time...

[floitsch, 2015/03/18 17:43:01]

We are switching to enums and shared string-literals. This means that we cannot
require a literal here.

     // This is, because we want to allow non-literals as names.
     if (argNodes.tail.isEmpty) {
-      compiler.internalError(jsGlobalCall, 'Embedded Global is missing name');
+      compiler.internalError(jsMacroOrGlobalCall,
+          'JS $macroOrGlobal is missing name');
     }
 
-    if (!argNodes.tail.tail.isEmpty) {
-      compiler.internalError(argNodes.tail.tail.head,
-          'Embedded Global has more than 2 arguments');
+    if (!isMacro) {
+      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();
 
     resolveType(String typeString) {
       return _parseType(
           typeString,
           compiler,
           (name) => resolver.resolveTypeFromString(specLiteral, name),
-          jsGlobalCall);
+          jsMacroOrGlobalCall);
     }
 
-    processSpecString(compiler, jsGlobalCall,
+    processSpecString(compiler, jsMacroOrGlobalCall,
                       specString,
                       resolveType: resolveType,
                       typesReturned: behavior.typesReturned,
                       typesInstantiated: behavior.typesInstantiated,
                       objectType: compiler.objectClass.computeType(compiler),
                       nullType: compiler.nullClass.computeType(compiler));
 
     return behavior;
   }
 
+  static NativeBehavior ofJsCompilerMacroCall(Send jsMacroCall,
+                                            Compiler compiler,
+                                            ResolverVisitor resolver) {
+    return _ofMacroOrEmbeddedGlobal(
+        jsMacroCall, compiler, resolver, isMacro: true);
+  }
+
+  static NativeBehavior ofJsEmbeddedGlobalCall(Send jsGlobalCall,
+                                               Compiler compiler,
+                                               ResolverVisitor resolver) {
+    return _ofMacroOrEmbeddedGlobal(
+        jsGlobalCall, compiler, resolver, isMacro: false);
+  }
+
   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 144 matching lines @@
     compiler.internalError(
         _errorNode(locationNodeOrElement, compiler),
         "Type '$typeString' not found.");
   }
 
   static _errorNode(locationNodeOrElement, compiler) {
     if (locationNodeOrElement is Node) return locationNodeOrElement;
     return locationNodeOrElement.parseNode(compiler);
   }
 }