dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/inline.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.inline;
 
 import 'cps_fragment.dart';
 import 'cps_ir_builder.dart' show ThisParameterLocal;
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 import 'type_mask_system.dart' show TypeMaskSystem;
 import '../dart_types.dart' show DartType, GenericType;
 import '../world.dart' show World;
 import '../elements/elements.dart';
 import '../js_backend/js_backend.dart' show JavaScriptBackend;
 import '../js_backend/codegen/task.dart' show CpsFunctionCompiler;
-import '../types/types.dart' show
-    FlatTypeMask, ForwardingTypeMask, TypeMask, UnionTypeMask;
+import '../types/types.dart'
+    show FlatTypeMask, ForwardingTypeMask, TypeMask, UnionTypeMask;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import 'package:js_ast/js_ast.dart' as js;
 
 /// Inlining stack entries.
 ///
 /// During inlining, a stack is used to detect cycles in the call graph.
 class StackEntry {
   // Dynamically resolved calls might be targeting an adapter function that
   // fills in optional arguments not passed at the call site.  Therefore these
@@ skipping 26 matching lines @@
   final FunctionDefinition function;
 
   CacheEntry(this.callStructure, this.receiver, this.arguments, this.decision,
       this.function);
 
   bool match(CallStructure otherCallStructure, TypeMask otherReceiver,
       List<TypeMask> otherArguments) {
     if (callStructure == null) {
       if (otherCallStructure != null) return false;
     } else if (otherCallStructure == null ||
-               !callStructure.match(otherCallStructure)) {
+        !callStructure.match(otherCallStructure)) {
       return false;
     }
 
     if (receiver != otherReceiver) return false;
     assert(arguments.length == otherArguments.length);
     for (int i = 0; i < arguments.length; ++i) {
       if (arguments[i] != otherArguments[i]) return false;
     }
     return true;
   }
@@ skipping 14 matching lines @@
   final Map<ExecutableElement, FunctionDefinition> unoptimized =
       <ExecutableElement, FunctionDefinition>{};
 
   final Map<ExecutableElement, List<CacheEntry>> map =
       <ExecutableElement, List<CacheEntry>>{};
 
   // When function definitions are put into or removed from the cache, they are
   // copied because the compiler passes will mutate them.
   final CopyingVisitor copier = new CopyingVisitor();
 
-  void _putInternal(ExecutableElement element, CallStructure callStructure,
+  void _putInternal(
+      ExecutableElement element,
+      CallStructure callStructure,
       TypeMask receiver,
       List<TypeMask> arguments,
       bool decision,
       FunctionDefinition function) {
-    map.putIfAbsent(element, () => <CacheEntry>[])
-        .add(new CacheEntry(callStructure, receiver, arguments, decision,
-            function));
+    map.putIfAbsent(element, () => <CacheEntry>[]).add(
+        new CacheEntry(callStructure, receiver, arguments, decision, function));
   }
 
   /// Put a positive inlining decision in the cache.
   ///
   /// A positive inlining decision maps to an IR function definition.
-  void putPositive(ExecutableElement element, CallStructure callStructure,
+  void putPositive(
+      ExecutableElement element,
+      CallStructure callStructure,
       TypeMask receiver,
       List<TypeMask> arguments,
       FunctionDefinition function) {
     _putInternal(element, callStructure, receiver, arguments, true,
         copier.copy(function));
   }
 
   /// Put a negative inlining decision in the cache.
-  void putNegative(ExecutableElement element,
-      CallStructure callStructure,
-      TypeMask receiver,
-      List<TypeMask> arguments) {
+  void putNegative(ExecutableElement element, CallStructure callStructure,
+      TypeMask receiver, List<TypeMask> arguments) {
     _putInternal(element, callStructure, receiver, arguments, false, null);
   }
 
   /// Look up a tuple in the cache.
   ///
   /// A positive lookup result return the IR function definition.  A negative
   /// lookup result returns [NO_INLINE].  If there is no cached result,
   /// [ABSENT] is returned.
   get(ExecutableElement element, CallStructure callStructure, TypeMask receiver,
       List<TypeMask> arguments) {
@@ skipping 45 matching lines @@
   final InliningCache cache = new InliningCache();
 
   final List<StackEntry> stack = <StackEntry>[];
 
   Inliner(this.functionCompiler);
 
   bool isCalledOnce(Element element) {
     if (element is ConstructorBodyElement) {
       ClassElement class_ = element.enclosingClass;
       return !functionCompiler.compiler.world.hasAnyStrictSubclass(class_) &&
-          class_.constructors.tail?.isEmpty ?? false;
+              class_.constructors.tail?.isEmpty ??
+          false;
     }
-    return functionCompiler.compiler.typesTask.typesInferrer.isCalledOnce(
-        element);
+    return functionCompiler.compiler.typesTask.typesInferrer
+        .isCalledOnce(element);
   }
 
   void rewrite(FunctionDefinition node, [CallStructure callStructure]) {
     ExecutableElement function = node.element;
 
     // Inlining in asynchronous or generator functions is disabled.  Inlining
     // triggers a bug in the async rewriter.
     // TODO(kmillikin): Fix the bug and eliminate this restriction if it makes
     // sense.
     if (function is FunctionElement &&
@@ skipping 132 matching lines @@
   }
 
   TypeMask abstractType(Primitive def) {
     return def.type ?? typeSystem.dynamicType;
   }
 
   /// Build the IR term for the function that adapts a call site targeting a
   /// function that takes optional arguments not passed at the call site.
   FunctionDefinition buildAdapter(InvokeMethod node, FunctionElement target) {
     Parameter thisParameter = new Parameter(new ThisParameterLocal(target))
-        ..type = node.receiver.type;
-    Parameter interceptorParameter = node.interceptorRef != null
-        ? new Parameter(null)
-        : null;
-    List<Parameter> parameters = new List<Parameter>.generate(
-        node.argumentRefs.length,
-        (int index) {
-          // TODO(kmillikin): Use a hint for the parameter names.
-          return new Parameter(null)
-              ..type = node.argument(index).type;
-        });
+      ..type = node.receiver.type;
+    Parameter interceptorParameter =
+        node.interceptorRef != null ? new Parameter(null) : null;
+    List<Parameter> parameters =
+        new List<Parameter>.generate(node.argumentRefs.length, (int index) {
+      // TODO(kmillikin): Use a hint for the parameter names.
+      return new Parameter(null)..type = node.argument(index).type;
+    });
     Continuation returnContinuation = new Continuation.retrn();
     CpsFragment cps = new CpsFragment();
 
     FunctionSignature signature = target.functionSignature;
     int requiredParameterCount = signature.requiredParameterCount;
     List<Primitive> arguments = new List<Primitive>.generate(
-        requiredParameterCount,
-        (int index) => parameters[index]);
+        requiredParameterCount, (int index) => parameters[index]);
 
     int parameterIndex = requiredParameterCount;
     CallStructure newCallStructure;
     if (signature.optionalParametersAreNamed) {
       List<String> incomingNames =
           node.selector.callStructure.getOrderedNamedArguments();
       List<String> outgoingNames = <String>[];
       int nameIndex = 0;
       signature.orderedOptionalParameters.forEach((ParameterElement formal) {
         if (nameIndex < incomingNames.length &&
@@ skipping 17 matching lines @@
         } else {
           Constant defaultValue = cps.makeConstant(
               backend.constants.getConstantValueForVariable(formal));
           defaultValue.type = typeSystem.getParameterType(formal);
           arguments.add(defaultValue);
         }
       });
       newCallStructure = new CallStructure(signature.parameterCount);
     }
 
-    Selector newSelector =
-        new Selector(node.selector.kind, node.selector.memberName,
-            newCallStructure);
-    Primitive result = cps.invokeMethod(thisParameter,
-        newSelector,
-        node.mask,
-        arguments,
+    Selector newSelector = new Selector(
+        node.selector.kind, node.selector.memberName, newCallStructure);
+    Primitive result = cps.invokeMethod(
+        thisParameter, newSelector, node.mask, arguments,
         interceptor: interceptorParameter,
         callingConvention: node.callingConvention);
     result.type = typeSystem.getInvokeReturnType(node.selector, node.mask);
     returnContinuation.parameters.single.type = result.type;
     cps.invokeContinuation(returnContinuation, <Primitive>[result]);
-    return new FunctionDefinition(target, thisParameter, parameters,
-        returnContinuation,
-        cps.root,
+    return new FunctionDefinition(
+        target, thisParameter, parameters, returnContinuation, cps.root,
         interceptorParameter: interceptorParameter);
   }
 
   // Given an invocation and a known target, possibly perform inlining.
   //
   // An optional call structure indicates a dynamic call.  Calls that are
   // already resolved statically have a null call structure.
   //
   // The [Primitive] representing the result of the inlined call is returned
   // if the call was inlined, and the inlined function body is available in
   // [_fragment].  If the call was not inlined, null is returned.
   Primitive tryInlining(InvocationPrimitive invoke, FunctionElement target,
-                        CallStructure callStructure) {
+      CallStructure callStructure) {
     // Quick checks: do not inline or even cache calls to targets without an
     // AST node, targets that are asynchronous or generator functions, or
     // targets containing a try statement.
     if (!target.hasNode) return null;
     if (backend.isJsInterop(target)) return null;
     if (target.asyncMarker != AsyncMarker.SYNC) return null;
     // V8 does not optimize functions containing a try statement.  Inlining
     // code containing a try statement will make the optimizable calling code
     // become unoptimizable.
     if (target.resolvedAst.elements.containsTryStatement) {
@@ skipping 20 matching lines @@
         receiver == null ? null : abstractType(receiver);
     // The receiver is non-null in a method body, unless the receiver is known
     // to be `null` (isEmpty covers `null` and unreachable).
     TypeMask abstractReceiverInMethod = abstractReceiver == null
         ? null
         : abstractReceiver.isEmptyOrNull
             ? abstractReceiver
             : abstractReceiver.nonNullable();
     List<TypeMask> abstractArguments =
         invoke.arguments.map(abstractType).toList();
-    var cachedResult = _inliner.cache.get(target, callStructure,
-        abstractReceiverInMethod,
-        abstractArguments);
+    var cachedResult = _inliner.cache.get(
+        target, callStructure, abstractReceiverInMethod, abstractArguments);
 
     // Negative inlining result in the cache.
     if (cachedResult == InliningCache.NO_INLINE) return null;
 
     Primitive finish(FunctionDefinition function) {
       _fragment = new CpsFragment(invoke.sourceInformation);
       Primitive receiver = invoke.receiver;
       List<Primitive> arguments = invoke.arguments.toList();
       // Add a null check to the inlined function body if necessary.  The
       // cached function body does not contain the null check.
       if (receiver != null && abstractReceiver.isNullable) {
-        receiver = nullReceiverGuard(
-            invoke, _fragment, receiver, abstractReceiver);
+        receiver =
+            nullReceiverGuard(invoke, _fragment, receiver, abstractReceiver);
       }
       return _fragment.inlineFunction(function, receiver, arguments,
-            interceptor: invoke.interceptor, hint: invoke.hint);
+          interceptor: invoke.interceptor, hint: invoke.hint);
     }
 
     // Positive inlining result in the cache.
     if (cachedResult is FunctionDefinition) {
       return finish(cachedResult);
     }
 
     // We have not seen this combination of target and abstract arguments
     // before.  Make an inlining decision.
     assert(cachedResult == InliningCache.ABSENT);
@@ skipping 35 matching lines @@
     // Compute the size.
     // TODO(kmillikin): Tune the size bound.
     int size = SizeVisitor.sizeOf(invoke, function);
     if (!_inliner.isCalledOnce(target) && size > 11) return doNotInline();
 
     _inliner.cache.putPositive(target, callStructure, abstractReceiverInMethod,
         abstractArguments, function);
     return finish(function);
   }
 
-  Primitive nullReceiverGuard(InvocationPrimitive invoke,
-                              CpsFragment fragment,
-                              Primitive dartReceiver,
-                              TypeMask abstractReceiver) {
+  Primitive nullReceiverGuard(InvocationPrimitive invoke, CpsFragment fragment,
+      Primitive dartReceiver, TypeMask abstractReceiver) {
     if (invoke is! InvokeMethod) return dartReceiver;
     InvokeMethod invokeMethod = invoke;
     Selector selector = invokeMethod.selector;
     if (typeSystem.isDefinitelyNum(abstractReceiver, allowNull: true)) {
-      Primitive condition = _fragment.letPrim(
-          new ApplyBuiltinOperator(BuiltinOperator.IsNotNumber,
-                                   <Primitive>[dartReceiver],
-                                   invoke.sourceInformation));
+      Primitive condition = _fragment.letPrim(new ApplyBuiltinOperator(
+          BuiltinOperator.IsNotNumber,
+          <Primitive>[dartReceiver],
+          invoke.sourceInformation));
       condition.type = typeSystem.boolType;
-      Primitive check = _fragment.letPrim(
-          new ReceiverCheck.nullCheck(dartReceiver, selector,
-              invoke.sourceInformation,
-              condition: condition));
+      Primitive check = _fragment.letPrim(new ReceiverCheck.nullCheck(
+          dartReceiver, selector, invoke.sourceInformation,
+          condition: condition));
       check.type = abstractReceiver.nonNullable();
       return check;
     }
 
-    Primitive check = _fragment.letPrim(
-        new ReceiverCheck.nullCheck(dartReceiver, selector,
-            invoke.sourceInformation));
+    Primitive check = _fragment.letPrim(new ReceiverCheck.nullCheck(
+        dartReceiver, selector, invoke.sourceInformation));
     check.type = abstractReceiver.nonNullable();
     return check;
   }
 
-
   @override
   Primitive visitInvokeStatic(InvokeStatic node) {
     return tryInlining(node, node.target, null);
   }
 
   @override
   Primitive visitInvokeMethod(InvokeMethod node) {
     Primitive receiver = node.receiver;
     Element element = world.locateSingleElement(node.selector, receiver.type);
     if (element == null || element is! FunctionElement) return null;
     if (node.selector.isGetter != element.isGetter) return null;
     if (node.selector.isSetter != element.isSetter) return null;
     if (node.selector.name != element.name) return null;
 
-    return tryInlining(node, element.asFunctionElement(),
-        node.selector.callStructure);
+    return tryInlining(
+        node, element.asFunctionElement(), node.selector.callStructure);
   }
 
   @override
   Primitive visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     if (node.selector.isGetter != node.target.isGetter) return null;
     if (node.selector.isSetter != node.target.isSetter) return null;
     return tryInlining(node, node.target, null);
   }
 
   @override
   Primitive visitInvokeConstructor(InvokeConstructor node) {
     if (node.dartType is GenericType) {
       // We cannot inline a constructor invocation containing type arguments
       // because CreateInstance in the body does not know the type arguments.
       // We would incorrectly instantiate a class like A instead of A<B>.
       // TODO(kmillikin): try to fix this.
       GenericType generic = node.dartType;
       if (generic.typeArguments.any((DartType t) => !t.isDynamic)) return null;
     }
     return tryInlining(node, node.target, null);
   }
 
   bool isBlacklisted(FunctionElement target) {
     ClassElement enclosingClass = target.enclosingClass;
     if (target.isOperator &&
         (enclosingClass == backend.helpers.jsNumberClass ||
-         enclosingClass == backend.helpers.jsDoubleClass ||
-         enclosingClass == backend.helpers.jsIntClass)) {
+            enclosingClass == backend.helpers.jsDoubleClass ||
+            enclosingClass == backend.helpers.jsIntClass)) {
       // These should be handled by operator specialization.
       return true;
     }
     if (target == backend.helpers.stringInterpolationHelper) return true;
     return false;
   }
 }