Compute default throws behavior from JavaScript.

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 11 matching lines @@
 class NativeThrowBehavior {
   static const NativeThrowBehavior NEVER = const NativeThrowBehavior._(0);
   static const NativeThrowBehavior MAY_THROW_ONLY_ON_FIRST_ARGUMENT_ACCESS =
       const NativeThrowBehavior._(1);
   static const NativeThrowBehavior MAY = const NativeThrowBehavior._(2);
   static const NativeThrowBehavior MUST = const NativeThrowBehavior._(3);
 
   final int _bits;
   const NativeThrowBehavior._(this._bits);
 
+  bool get canThrow => this != NEVER;
+
   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)';
   }
 }
 
 /**
@@ skipping 38 matching lines @@
   // parsed tree.
   js.Template codeTemplate;
 
   final SideEffects sideEffects = new SideEffects.empty();
 
   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);
+
   String toString() {
     return 'NativeBehavior('
-        'returns: ${typesReturned}, '
-        'creates: ${typesInstantiated}, '
-        'sideEffects: ${sideEffects}, '
-        'throws: ${throwBehavior}'
+        'returns: ${typesReturned}'
+        ', creates: ${typesInstantiated}'
+        ', sideEffects: ${sideEffects}'
+        ', throws: ${throwBehavior}'
         '${isAllocation ? ", isAllocation" : ""}'
         '${useGvn ? ", useGvn" : ""}'
         ')';
   }
 
+  static NativeBehavior _makePure({bool isAllocation: false}) {
+    NativeBehavior behavior = new NativeBehavior();
+    behavior.sideEffects.clearAllDependencies();
+    behavior.sideEffects.clearAllSideEffects();
+    behavior.throwBehavior = NativeThrowBehavior.NEVER;
+    behavior.isAllocation = isAllocation;
+    return behavior;
+  }
 
   /// Processes the type specification string of a call to JS and stores the
   /// result in the [typesReturned] and [typesInstantiated]. It furthermore
   /// computes the side effects, and, if given, invokes [setSideEffects] with
   /// the computed effects. If no side effects are encoded in the [specString]
   /// the [setSideEffects] method is not invoked.
   ///
   /// Two forms of the string is supported:
   ///
   /// 1) A single type string of the form 'void', '', 'var' or 'T1|...|Tn'
@@ skipping 352 matching lines @@
         resolveType: resolveType,
         typesReturned: behavior.typesReturned,
         typesInstantiated: behavior.typesInstantiated,
         objectType: compiler.objectClass.computeType(compiler),
         nullType: compiler.nullClass.computeType(compiler));
 
     if (!sideEffectsAreEncodedInSpecString) {
       new SideEffectsVisitor(behavior.sideEffects)
           .visit(behavior.codeTemplate.ast);
     }
+    if (!throwBehaviorFromSpecString) {
+      behavior.throwBehavior =
+          new ThrowBehaviorVisitor().analyze(behavior.codeTemplate.ast);
+    }
 
     return behavior;
   }
 
   static NativeBehavior ofJsEmbeddedGlobalCall(Send jsGlobalCall,
                                                Compiler compiler,
                                                resolver) {
     // The first argument of a JS-embedded global call is a string encoding
     // the type of the code.
     //
@@ skipping 38 matching lines @@
 
     processSpecString(compiler, jsGlobalCall,
                       specString,
                       validTags: const ['returns', 'creates'],
                       resolveType: resolveType,
                       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;
+
     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));
@@ skipping 151 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);
   }
 }