Store and serialize NativeBehavior in TreeElements.

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/values.dart';
 import '../core_types.dart' show CoreTypes;
@@ skipping 10 matching lines @@
 
 /// This class is a temporary work-around until we get a more powerful DartType.
 class SpecialType {
   final String name;
   const SpecialType._(this.name);
 
   /// The type Object, but no subtypes:
   static const JsObject = const SpecialType._('=Object');
 
   int get hashCode => name.hashCode;
+
+  static SpecialType fromName(String name) {
+    switch (name) {
+      case '=Object':
+        return JsObject;
+      default:

[Siggi Cherem (dart-lang), 2016/04/18 16:48:54]

do you expect to add more cases in the future?

If not, switch to an assertion or an `if-else`?

[Johnni Winther, 2016/04/20 10:12:55]

I don't know. Stephen might. Making it an if-else for now.

+        throw new UnsupportedError("Unknown SpecialType '$name'.");
+    }
+  }
 }
 
 /// Description of the exception behaviour of native code.
 ///
 /// TODO(sra): Replace with something that better supports specialization on
 /// first argument properties.
 class NativeThrowBehavior {
   static const NativeThrowBehavior NEVER = const NativeThrowBehavior._(0);
   static const NativeThrowBehavior MAY_THROW_ONLY_ON_FIRST_ARGUMENT_ACCESS =
       const NativeThrowBehavior._(1);
@@ skipping 22 matching lines @@
     return this;
   }
 
   String toString() {
     if (this == NEVER) return 'never';
     if (this == MAY) return 'may';
     if (this == MAY_THROW_ONLY_ON_FIRST_ARGUMENT_ACCESS) return 'null(1)';
     if (this == MUST) return 'must';
     return 'NativeThrowBehavior($_bits)';
   }
+
+  /// Canonical list of marker values.
+  ///
+  /// Added to make [NativeThrowBehavior] enum-like.
+  static const List<NativeThrowBehavior> values = const <NativeThrowBehavior>[
+    NEVER,
+    MAY_THROW_ONLY_ON_FIRST_ARGUMENT_ACCESS,
+    MAY,
+    MUST,
+  ];
+
+  /// Index to this marker within [values].
+  ///
+  /// Added to make [NativeThrowBehavior] enum-like.
+  int get index => values.indexOf(this);
 }
 
 /**
  * A summary of the behavior of a native element.
  *
  * Native code can return values of one type and cause native subtypes of
  * another type to be instantiated.  By default, we compute both from the
  * declared type.
  *
  * A field might yield any native type that 'is' the field type.
@@ skipping 19 matching lines @@
  * Types in annotations are non-nullable, so include `@Returns('Null')` if
  * `null` may be returned.
  */
 class NativeBehavior {
   /// [DartType]s or [SpecialType]s returned or yielded by the native element.
   final List typesReturned = [];
 
   /// [DartType]s or [SpecialType]s instantiated by the native element.
   final List typesInstantiated = [];
 
+  String codeTemplateText;
   // If this behavior is for a JS expression, [codeTemplate] contains the
   // parsed tree.
   js.Template codeTemplate;
 
-  final SideEffects sideEffects = new SideEffects.empty();
+  final SideEffects sideEffects;
 
   NativeThrowBehavior throwBehavior = NativeThrowBehavior.MAY;
 
   bool isAllocation = false;
   bool useGvn = false;
 
   // TODO(sra): Make NativeBehavior immutable so PURE and PURE_ALLOCATION can be
   // final constant-like objects.
   static NativeBehavior get PURE => NativeBehavior._makePure();
   static NativeBehavior get PURE_ALLOCATION =>
       NativeBehavior._makePure(isAllocation: true);
   static NativeBehavior get CHANGES_OTHER => NativeBehavior._makeChangesOther();
   static NativeBehavior get DEPENDS_OTHER => NativeBehavior._makeDependsOther();
 
+  NativeBehavior() : sideEffects = new SideEffects.empty();
+
+  NativeBehavior.internal(this.sideEffects);
+
   String toString() {
     return 'NativeBehavior('
         'returns: ${typesReturned}'
         ', creates: ${typesInstantiated}'
         ', sideEffects: ${sideEffects}'
         ', throws: ${throwBehavior}'
         '${isAllocation ? ", isAllocation" : ""}'
         '${useGvn ? ", useGvn" : ""}'
         ')';
   }
@@ skipping 342 matching lines @@
       return behavior;
     }
 
     var codeArgument = argNodes.tail.head;
     if (codeArgument is! StringNode || codeArgument.isInterpolation) {
       reporter.reportErrorMessage(codeArgument, MessageKind.GENERIC,
           {'text': "JS second argument must be a string literal."});
       return behavior;
     }
 
-    behavior.codeTemplate =
-        js.js.parseForeignJS(codeArgument.dartString.slowToString());
+    behavior.codeTemplateText = codeArgument.dartString.slowToString();
+    behavior.codeTemplate = js.js.parseForeignJS(behavior.codeTemplateText);
 
     String specString = specArgument.dartString.slowToString();
 
     dynamic resolveType(String typeString) {
       return _parseType(
           typeString,
           parsing,
           (name) => resolver.resolveTypeFromString(specArgument, name),
           specArgument);
     }
@@ skipping 367 matching lines @@
     reporter.reportErrorMessage(_errorNode(locationNodeOrElement, parsing),
         MessageKind.GENERIC, {'text': "Type '$typeString' not found."});
     return const DynamicType();
   }
 
   static _errorNode(locationNodeOrElement, ParsingContext parsing) {
     if (locationNodeOrElement is Node) return locationNodeOrElement;
     return locationNodeOrElement.parseNode(parsing);
   }
 }