dartfmt pkg/compiler

pkg/compiler/lib/src/native/js.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 '../js/js.dart' as js;
 import '../universe/side_effects.dart' show SideEffects;
 
 import 'behavior.dart';
 
 class HasCapturedPlaceholders extends js.BaseVisitor {
-
   HasCapturedPlaceholders._();
 
   static bool check(js.Node node) {
     HasCapturedPlaceholders visitor = new HasCapturedPlaceholders._();
     node.accept(visitor);
     return visitor.found;
   }
 
   int enclosingFunctions = 0;
   bool found = false;
@@ skipping 84 matching lines @@
   }
 
   void visitAccess(js.PropertyAccess node) {
     sideEffects.setDependsOnIndexStore();
     sideEffects.setDependsOnInstancePropertyStore();
     sideEffects.setDependsOnStaticPropertyStore();
     node.visitChildren(this);
   }
 }
 
-
 /// ThrowBehaviorVisitor generates a NativeThrowBehavior describing the
 /// exception behavior of a JavaScript expression.
 ///
 /// The result is semi-conservative, giving reasonable results for many simple
 /// JS fragments. The non-conservative part is the assumption that binary
 /// operators are used on 'good' operands that do not force arbirary code to be
 /// executed via conversions (valueOf() and toString() methods).
 ///
 /// In many cases a JS fragment has more precise behavior. In these cases the
 /// behavior should be described as a property of the JS fragment. For example,
 /// Object.keys(#) has a TypeError on null / undefined, which can only be known
 /// in the calling context.
 ///
 class ThrowBehaviorVisitor extends js.BaseVisitor<NativeThrowBehavior> {
-
   ThrowBehaviorVisitor();
 
   NativeThrowBehavior analyze(js.Node node) {
     return visit(node);
   }
 
   // TODO(sra): Add [sequence] functionality to NativeThrowBehavior.
   /// Returns the combined behavior of sequential execution of code having
   /// behavior [first] followed by code having behavior [second].
-  static NativeThrowBehavior sequence(NativeThrowBehavior first,
-      NativeThrowBehavior second) {
+  static NativeThrowBehavior sequence(
+      NativeThrowBehavior first, NativeThrowBehavior second) {
     if (first == NativeThrowBehavior.MUST) return first;
     if (second == NativeThrowBehavior.MUST) return second;
     if (second == NativeThrowBehavior.NEVER) return first;
     if (first == NativeThrowBehavior.NEVER) return second;
     // Both are one of MAY or MAY_THROW_ONLY_ON_FIRST_ARGUMENT_ACCESS.
     return NativeThrowBehavior.MAY;
   }
 
   // TODO(sra): Add [choice] functionality to NativeThrowBehavior.
   /// Returns the combined behavior of a choice between two paths with behaviors
   /// [first] and [second].
-  static NativeThrowBehavior choice(NativeThrowBehavior first,
-      NativeThrowBehavior second) {
-    if (first == second) return first;  // Both paths have same behaviour.
+  static NativeThrowBehavior choice(
+      NativeThrowBehavior first, NativeThrowBehavior second) {
+    if (first == second) return first; // Both paths have same behaviour.
     return NativeThrowBehavior.MAY;
   }
 
   NativeThrowBehavior visit(js.Node node) {
     return node.accept(this);
   }
 
   NativeThrowBehavior visitNode(js.Node node) {
     return NativeThrowBehavior.MAY;
   }
@@ skipping 124 matching lines @@
         receiver.isPositional &&
         receiver.nameOrPosition == 0) {
       first = NativeThrowBehavior.MAY_THROW_ONLY_ON_FIRST_ARGUMENT_ACCESS;
     } else {
       first = NativeThrowBehavior.MAY;
     }
 
     return sequence(first, second);
   }
 }