dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/insert_refinements.dart

 // Copyright (c) 2015, 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.
 
 library cps_ir.optimization.insert_refinements;
 
 import 'dart:math' show min;
 import 'optimizers.dart' show Pass;
 import 'cps_ir_nodes.dart';
 import '../elements/elements.dart';
@@ skipping 100 matching lines @@
 
     // Note: node.dartArgumentsLength is shorter when the call doesn't include
     // some optional arguments.
     int length = min(argumentSuccessTypes.length, node.argumentRefs.length);
     for (int i = 0; i < length; i++) {
       TypeMask argSuccessType = argumentSuccessTypes[i];
 
       // Skip arguments that provide no refinement.
       if (argSuccessType == types.dynamicType) continue;
 
-      applyRefinement(node.parent,
-          new Refinement(node.argument(i), argSuccessType));
+      applyRefinement(
+          node.parent, new Refinement(node.argument(i), argSuccessType));
     }
   }
 
   void visitInvokeStatic(InvokeStatic node) {
     node.argumentRefs.forEach(processReference);
-    _refineArguments(node,
-        _getSuccessTypesForStaticMethod(types, node.target));
+    _refineArguments(node, _getSuccessTypesForStaticMethod(types, node.target));
   }
 
   void visitInvokeMethod(InvokeMethod node) {
     // Update references to their current refined values.
     processReference(node.receiverRef);
     node.argumentRefs.forEach(processReference);
 
     // If the call is intercepted, we want to refine the actual receiver,
     // not the interceptor.
     Primitive receiver = node.receiver;
 
     // Do not try to refine the receiver of closure calls; the class world
     // does not know about closure classes.
     Selector selector = node.selector;
     if (!selector.isClosureCall) {
       // Filter away receivers that throw on this selector.
       TypeMask type = types.receiverTypeFor(selector, node.mask);
       Refinement refinement = new Refinement(receiver, type);
       LetPrim letPrim = node.parent;
       applyRefinement(letPrim, refinement);
 
       // Refine arguments of methods on numbers which we know will throw on
       // invalid argument values.
-      _refineArguments(node,
-          _getSuccessTypesForInstanceMethod(types, type, selector));
+      _refineArguments(
+          node, _getSuccessTypesForInstanceMethod(types, type, selector));
     }
   }
 
   void visitTypeCast(TypeCast node) {
     Primitive value = node.value;
 
     processReference(node.valueRef);
     node.typeArgumentRefs.forEach(processReference);
 
     // Refine the type of the input.
@@ skipping 40 matching lines @@
       Primitive refinedValue = new Refinement(value, type);
       pushRefinement(trueCont, refinedValue);
       push(falseCont);
       return;
     }
 
     // If the condition is comparison with a constant, promote the other value.
     // This can happen either for calls to `==` or `identical` calls, such
     // as the ones inserted by the unsugaring pass.
 
-    void refineEquality(Primitive first,
-                        Primitive second,
-                        Continuation trueCont,
-                        Continuation falseCont) {
+    void refineEquality(Primitive first, Primitive second,
+        Continuation trueCont, Continuation falseCont) {
       if (second is Constant && second.value.isNull) {
         Refinement refinedTrue = new Refinement(first, types.nullType);
         Refinement refinedFalse = new Refinement(first, types.nonNullType);
         pushRefinement(trueCont, refinedTrue);
         pushRefinement(falseCont, refinedFalse);
       } else if (first is Constant && first.value.isNull) {
         Refinement refinedTrue = new Refinement(second, types.nullType);
         Refinement refinedFalse = new Refinement(second, types.nonNullType);
         pushRefinement(trueCont, refinedTrue);
         pushRefinement(falseCont, refinedFalse);
       } else {
         push(trueCont);
         push(falseCont);
       }
     }
 
     if (condition is InvokeMethod && condition.selector == Selectors.equals) {
-      refineEquality(condition.receiver,
-                     condition.argument(0),
-                     trueCont,
-                     falseCont);
+      refineEquality(
+          condition.receiver, condition.argument(0), trueCont, falseCont);
       return;
     }
 
     if (condition is ApplyBuiltinOperator &&
         condition.operator == BuiltinOperator.Identical) {
-      refineEquality(condition.argument(0),
-                     condition.argument(1),
-                     trueCont,
-                     falseCont);
+      refineEquality(
+          condition.argument(0), condition.argument(1), trueCont, falseCont);
       return;
     }
 
     push(trueCont);
     push(falseCont);
   }
 
   @override
   Expression traverseLetCont(LetCont node) {
     for (Continuation cont in node.continuations) {
@@ skipping 26 matching lines @@
     TypeMaskSystem types, TypeMask receiver, Selector selector) {
   if (types.isDefinitelyInt(receiver)) {
     switch (selector.name) {
       case 'toSigned':
       case 'toUnsigned':
       case 'modInverse':
       case 'gcd':
         return [types.intType];
 
       case 'modPow':
-       return [types.intType, types.intType];
+        return [types.intType, types.intType];
     }
     // Note: num methods on int values are handled below.
   }
 
   if (types.isDefinitelyNum(receiver)) {
     switch (selector.name) {
       case 'clamp':
-          return [types.numType, types.numType];
+        return [types.numType, types.numType];
       case 'toStringAsFixed':
       case 'toStringAsPrecision':
       case 'toRadixString':
-          return [types.intType];
+        return [types.intType];
       case 'toStringAsExponential':
-          return [types.intType.nullable()];
+        return [types.intType.nullable()];
       case 'compareTo':
       case 'remainder':
       case '+':
       case '-':
       case '/':
       case '*':
       case '%':
       case '~/':
       case '<<':
       case '>>':
       case '&':
       case '|':
       case '^':
       case '<':
       case '>':
       case '<=':
       case '>=':
-          return [types.numType];
+        return [types.numType];
       default:
         return null;
     }
   }
 
   if (types.isDefinitelyString(receiver)) {
     switch (selector.name) {
       case 'allMatches':
         return [types.stringType, types.intType];
       case 'endsWith':
@@ skipping 40 matching lines @@
   }
 
   if (types.isDefinitelyArray(receiver)) {
     switch (selector.name) {
       case 'removeAt':
       case 'insert':
         return [types.uintType];
       case 'sublist':
         return [types.uintType, types.uintType.nullable()];
       case 'length':
-         return selector.isSetter ? [types.uintType] : null;
+        return selector.isSetter ? [types.uintType] : null;
       case '[]':
       case '[]=':
         return [types.uintType];
       default:
         return null;
     }
   }
   return null;
 }
 
 List<TypeMask> _getSuccessTypesForStaticMethod(
     TypeMaskSystem types, FunctionElement target) {
   var lib = target.library;
   if (lib.isDartCore) {
     var cls = target.enclosingClass?.name;
     if (cls == 'int' && target.name == 'parse') {
       // source, onError, radix
       return [types.stringType, types.dynamicType, types.uint31Type.nullable()];
     } else if (cls == 'double' && target.name == 'parse') {
       return [types.stringType, types.dynamicType];
     }
   }
 
   if (lib.isPlatformLibrary && '${lib.canonicalUri}' == 'dart:math') {
-    switch(target.name) {
+    switch (target.name) {
       case 'sqrt':
       case 'sin':
       case 'cos':
       case 'tan':
       case 'acos':
       case 'asin':
       case 'atan':
       case 'atan2':
       case 'exp':
       case 'log':
         return [types.numType];
       case 'pow':
         return [types.numType, types.numType];
     }
   }
 
   return null;
 }