Add custom annotations to some APIs for native tree shaking.

sdk/lib/html/src/dart2js_Conversions.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.
 
 
 // Conversions for IDBKey.
 //
 // Per http://www.w3.org/TR/IndexedDB/#key-construct
 //
 // "A value is said to be a valid key if it is one of the following types: Array
@@ skipping 81 matching lines @@
   }
   return imageData;
 }
 
 
 /// Converts a JavaScript object with properties into a Dart Map.
 /// Not suitable for nested objects.
 Map _convertNativeToDart_Dictionary(object) {
   if (object == null) return null;
   var dict = {};
-  for (final key in JS('List', 'Object.getOwnPropertyNames(#)', object)) {
+  for (final key in JS('=List', 'Object.getOwnPropertyNames(#)', object)) {
     dict[key] = JS('var', '#[#]', object, key);
   }
   return dict;
 }
 
 /// Converts a flat Dart map into a JavaScript object with properties.
 _convertDartToNative_Dictionary(Map dict) {
   if (dict == null) return null;
   var object = JS('var', '{}');
   dict.forEach((String key, value) {
@@ skipping 156 matching lines @@
     if (e is List) {
       // Since a JavaScript Array is an instance of Dart List it is possible to
       // avoid making a copy of the list if there is no need to copy anything
       // reachable from the array.  We defer creating a new array until a cycle
       // is detected or a subgraph was copied.
       int length = e.length;
       var slot = findSlot(e);
       var copy = readSlot(slot);
       if (copy != null) {
         if (true == copy) {  // Cycle, so commit to making a copy.
-          copy = JS('List', 'new Array(#)', length);
+          copy = JS('=List', 'new Array(#)', length);
           writeSlot(slot, copy);
         }
         return copy;
       }
 
       int i = 0;
 
       if (_isJavaScriptArray(e) &&
           // We have to copy immutable lists, otherwise the structured clone
           // algorithm will copy the .immutable$list marker property, making the
           // list immutable when received!
           !_isImmutableJavaScriptArray(e)) {
         writeSlot(slot, true);  // Deferred copy.
         for ( ; i < length; i++) {
           var element = e[i];
           var elementCopy = walk(element);
           if (!identical(elementCopy, element)) {
             copy = readSlot(slot);   // Cyclic reference may have created it.
             if (true == copy) {
-              copy = JS('List', 'new Array(#)', length);
+              copy = JS('=List', 'new Array(#)', length);
               writeSlot(slot, copy);
             }
             for (int j = 0; j < i; j++) {
               copy[j] = e[j];
             }
             copy[i] = elementCopy;
             i++;
             break;
           }
         }
         if (copy == null) {
           copy = e;
           writeSlot(slot, copy);
         }
       } else {
         // Not a JavaScript Array.  We are forced to make a copy.
-        copy = JS('List', 'new Array(#)', length);
+        copy = JS('=List', 'new Array(#)', length);
         writeSlot(slot, copy);
       }
 
       for ( ; i < length; i++) {
         copy[i] = walk(e[i]);
       }
       return copy;
     }
 
     throw new UnimplementedError('structured clone of other type');
@@ skipping 59 matching lines @@
 
     if (_isJavaScriptSimpleObject(e)) {
       // TODO(sra): If mustCopy is false, swizzle the prototype for one of a Map
       // implementation that uses the properies as storage.
       var slot = findSlot(e);
       var copy = readSlot(slot);
       if (copy != null) return copy;
       copy = {};
 
       writeSlot(slot, copy);
-      for (final key in JS('List', 'Object.keys(#)', e)) {
+      for (final key in JS('=List', 'Object.keys(#)', e)) {
         copy[key] = walk(JS('var', '#[#]', e, key));
       }
       return copy;
     }
 
     if (_isJavaScriptArray(e)) {
       var slot = findSlot(e);
       var copy = readSlot(slot);
       if (copy != null) return copy;
 
       int length = e.length;
       // Since a JavaScript Array is an instance of Dart List, we can modify it
       // in-place unless we must copy.
-      copy = mustCopy ? JS('List', 'new Array(#)', length) : e;
+      copy = mustCopy ? JS('=List', 'new Array(#)', length) : e;
       writeSlot(slot, copy);
 
       for (int i = 0; i < length; i++) {
         copy[i] = walk(e[i]);
       }
       return copy;
     }
 
     // Assume anything else is already a valid Dart object, either by having
     // already been processed, or e.g. a clonable native class.
     return e;
   }
 
   var copy = walk(object);
   return copy;
 }
 
 
 bool _isJavaScriptDate(value) => JS('bool', '# instanceof Date', value);
 bool _isJavaScriptRegExp(value) => JS('bool', '# instanceof RegExp', value);
 bool _isJavaScriptArray(value) => JS('bool', '# instanceof Array', value);
 bool _isJavaScriptSimpleObject(value) =>
     JS('bool', 'Object.getPrototypeOf(#) === Object.prototype', value);
 bool _isImmutableJavaScriptArray(value) =>
     JS('bool', r'!!(#.immutable$list)', value);
+
+
+
+const String _serializedScriptValue =
+    'num|String|bool|'
+    '=List|=Object|'
+    'Blob|File|ArrayBuffer|ArrayBufferView'
+    // TODO(sra): Add Date, RegExp.
+    ;
+const _annotation_Creates_SerializedScriptValue =
+    const Creates(_serializedScriptValue);
+const _annotation_Returns_SerializedScriptValue =
+    const Returns(_serializedScriptValue);
+
+const String _idbKey = '=List|=Object|num|String';  // TODO(sra): Add Date.
+const _annotation_Creates_IDBKey = const Creates(_idbKey);
+const _annotation_Returns_IDBKey = const Returns(_idbKey);