Rerun formatter

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 188 matching lines @@
   /// might not be in scope or from the current instance.
   ///
   final InterfaceType instanceType;
 
   SourceInformationBuilder get sourceInformationBuilder {
     return builder.sourceInformationBuilder;
   }
 
   LocalsHandler(
       this.builder, this.executableContext, InterfaceType instanceType)
-      : this.instanceType = instanceType == null ||
-            instanceType.containsTypeVariables ? null : instanceType;
+      : this.instanceType =
+            instanceType == null || instanceType.containsTypeVariables
+                ? null
+                : instanceType;
 
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
   DartType substInContext(DartType type) {
     if (contextClass != null) {
       ClassElement typeContext = Types.getClassContext(type);
       if (typeContext != null) {
         type = type.substByContext(contextClass.asInstanceOf(typeContext));
       }
     }
@@ skipping 2532 matching lines @@
       return;
     }
     // Assert has message. Generate:
     //
     //     if (assertTest(condition)) assertThrow(message);
     //
     void buildCondition() {
       visit(node.condition);
       pushInvokeStatic(node, helpers.assertTest, [pop()]);
     }
+
     void fail() {
       visit(node.message);
       pushInvokeStatic(node, helpers.assertThrow, [pop()]);
       pop();
     }
+
     handleIf(node, visitCondition: buildCondition, visitThen: fail);
   }
 
   visitBlock(ast.Block node) {
     assert(!isAborted());
     if (!isReachable) return; // This can only happen when inlining.
     for (Link<ast.Node> link = node.statements.nodes;
         !link.isEmpty;
         link = link.tail) {
       visit(link.head);
@@ skipping 313 matching lines @@
     assert(isReachable);
     assert(node.body != null);
     void buildInitializer() {
       ast.Node initializer = node.initializer;
       if (initializer == null) return;
       visit(initializer);
       if (initializer.asExpression() != null) {
         pop();
       }
     }
+
     HInstruction buildCondition() {
       if (node.condition == null) {
         return graph.addConstantBool(true, compiler);
       }
       visit(node.condition);
       return popBoolified();
     }
+
     void buildUpdate() {
       for (ast.Expression expression in node.update) {
         visit(expression);
         assert(!isAborted());
         // The result of the update instruction isn't used, and can just
         // be dropped.
         pop();
       }
     }
+
     void buildBody() {
       visit(node.body);
     }
+
     handleLoop(node, buildInitializer, buildCondition, buildUpdate, buildBody);
   }
 
   visitWhile(ast.While node) {
     assert(isReachable);
     HInstruction buildCondition() {
       visit(node.condition);
       return popBoolified();
     }
+
     handleLoop(node, () {}, buildCondition, () {}, () {
       visit(node.body);
     });
   }
 
   visitDoWhile(ast.DoWhile node) {
     assert(isReachable);
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     localsHandler.startLoop(node);
     loopNesting++;
@@ skipping 2520 matching lines @@
 
     var nativeBehavior = new native.NativeBehavior()
       ..sideEffects.setAllSideEffects();
 
     DartType type = element.isConstructor
         ? element.enclosingClass.thisType
         : element.type.returnType;
     // Native behavior effects here are similar to native/behavior.dart.
     // The return type is dynamic if we don't trust js-interop type
     // declarations.
-    nativeBehavior.typesReturned.add(compiler
-        .options.trustJSInteropTypeAnnotations ? type : const DynamicType());
+    nativeBehavior.typesReturned.add(
+        compiler.options.trustJSInteropTypeAnnotations
+            ? type
+            : const DynamicType());
 
     // The allocation effects include the declared type if it is native (which
     // includes js interop types).
     if (type.element != null && backend.isNative(type.element)) {
       nativeBehavior.typesInstantiated.add(type);
     }
 
     // It also includes any other JS interop type if we don't trust the
     // annotation or if is declared too broad.
     if (!compiler.options.trustJSInteropTypeAnnotations ||
@@ skipping 113 matching lines @@
     void generateSuperSendSet() {
       Selector setterSelector = elements.getSelector(node);
       if (Elements.isUnresolved(element) ||
           !setterSelector.applies(element, compiler.world)) {
         generateSuperNoSuchMethodSend(node, setterSelector, setterInputs);
         pop();
       } else {
         add(buildInvokeSuper(setterSelector, element, setterInputs));
       }
     }
+
     if (identical(node.assignmentOperator.source, '=')) {
       addDynamicSendArgumentsToList(node, setterInputs);
       generateSuperSendSet();
       stack.add(setterInputs.last);
     } else {
       Element getter = elements[node.selector];
       List<HInstruction> getterInputs = <HInstruction>[];
       Link<ast.Node> arguments = node.arguments;
       if (node.isIndex) {
         // If node is of the form [:super.foo[0] += 2:], the send has
@@ skipping 568 matching lines @@
         } else {
           handleComplexOperatorSend(node, getterInstruction, node.arguments);
           HInstruction value = pop();
           generateInstanceSetterWithCompiledReceiver(node, receiver, value);
         }
         if (node.isPostfix) {
           pop();
           stack.add(getterInstruction);
         }
       }
+
       if (node.isConditional) {
         // generate `e?.x op= e2` as:
         //   t1 = e
         //   t1 == null ? t1 : (t1.x = t1.x op e2);
         HInstruction receiver;
         SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
         brancher.handleConditional(() {
           receiver = generateInstanceSendReceiver(node);
           pushCheckNull(receiver);
         }, () => stack.add(receiver), () => generateAssignment(receiver));
@@ skipping 230 matching lines @@
         redirectingSignature.orderedOptionalParameters;
 
     // TODO(25579): This code can do the wrong thing redirecting constructor and
     // the target do not correspond. It is correct if there is no
     // warning. Ideally the redirecting constructor and the target would be the
     // same function.
 
     void loadLocal(ParameterElement parameter) {
       inputs.add(localsHandler.readLocal(parameter));
     }
+
     void loadPosition(int position, ParameterElement optionalParameter) {
       if (position < redirectingRequireds.length) {
         loadLocal(redirectingRequireds[position]);
       } else if (position < redirectingSignature.parameterCount &&
           !redirectingSignature.optionalParametersAreNamed) {
         loadLocal(redirectingOptionals[position - redirectingRequireds.length]);
       } else if (optionalParameter != null) {
         inputs.add(handleConstantForOptionalParameter(optionalParameter));
       } else {
         // Wrong.
@@ skipping 268 matching lines @@
 
     HInstruction buildCondition() {
       Selector selector = Selectors.moveNext;
       TypeMask mask = elements.getMoveNextTypeMask(node);
       pushInvokeDynamic(node, selector, mask, [streamIterator]);
       HInstruction future = pop();
       push(new HAwait(future,
           new TypeMask.subclass(coreClasses.objectClass, compiler.world)));
       return popBoolified();
     }
+
     void buildBody() {
       Selector call = Selectors.current;
       TypeMask callMask = elements.getCurrentTypeMask(node);
       pushInvokeDynamic(node, call, callMask, [streamIterator]);
 
       ast.Node identifier = node.declaredIdentifier;
       Element variable = elements.getForInVariable(node);
       Selector selector = elements.getSelector(identifier);
       TypeMask mask = elements.getTypeMask(identifier);
 
@@ skipping 394 matching lines @@
    * Builds a simple switch statement which does not handle uses of continue
    * statements to labeled switch cases.
    */
   void buildSimpleSwitchStatement(
       ast.SwitchStatement node, Map<ast.CaseMatch, ConstantValue> constants) {
     JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false);
     HInstruction buildExpression() {
       visit(node.expression);
       return pop();
     }
+
     Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) {
       List<ConstantValue> constantList = <ConstantValue>[];
       for (ast.Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is ast.CaseMatch) {
           constantList.add(constants[labelOrCase]);
         }
       }
       return constantList;
     }
+
     bool isDefaultCase(ast.SwitchCase switchCase) {
       return switchCase.isDefaultCase;
     }
+
     void buildSwitchCase(ast.SwitchCase node) {
       visit(node.statements);
     }
+
     handleSwitch(node, jumpHandler, buildExpression, node.cases, getConstants,
         isDefaultCase, buildSwitchCase);
     jumpHandler.close();
   }
 
   /**
    * Builds a switch statement that can handle arbitrary uses of continue
    * statements to labeled switch cases.
    */
   void buildComplexSwitchStatement(
@@ skipping 38 matching lines @@
     if (!hasDefault) {
       // Use [:null:] as the marker for a synthetic default clause.
       // The synthetic default is added because otherwise, there would be no
       // good place to give a default value to the local.
       switchCases = node.cases.nodes.toList()..add(null);
     }
     HInstruction buildExpression() {
       visit(node.expression);
       return pop();
     }
+
     Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) {
       List<ConstantValue> constantList = <ConstantValue>[];
       if (switchCase != null) {
         for (ast.Node labelOrCase in switchCase.labelsAndCases) {
           if (labelOrCase is ast.CaseMatch) {
             constantList.add(constants[labelOrCase]);
           }
         }
       }
       return constantList;
     }
+
     bool isDefaultCase(ast.SwitchCase switchCase) {
       return switchCase == null || switchCase.isDefaultCase;
     }
+
     void buildSwitchCase(ast.SwitchCase switchCase) {
       if (switchCase != null) {
         // Generate 'target = i; break;' for switch case i.
         int index = caseIndex[switchCase];
         HInstruction value = graph.addConstantInt(index, compiler);
         localsHandler.updateLocal(switchTarget, value);
       } else {
         // Generate synthetic default case 'target = null; break;'.
         HInstruction value = graph.addConstantNull(compiler);
         localsHandler.updateLocal(switchTarget, value);
       }
       jumpTargets[switchTarget].generateBreak();
     }
+
     handleSwitch(node, jumpHandler, buildExpression, switchCases, getConstants,
         isDefaultCase, buildSwitchCase);
     jumpHandler.close();
 
     HInstruction buildCondition() => graph.addConstantBool(true, compiler);
 
     void buildSwitch() {
       HInstruction buildExpression() {
         return localsHandler.readLocal(switchTarget);
       }
+
       Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) {
         return <ConstantValue>[constantSystem.createInt(caseIndex[switchCase])];
       }
+
       void buildSwitchCase(ast.SwitchCase switchCase) {
         visit(switchCase.statements);
         if (!isAborted()) {
           // Ensure that we break the loop if the case falls through. (This
           // is only possible for the last case.)
           jumpTargets[switchTarget].generateBreak();
         }
       }
+
       // Pass a [NullJumpHandler] because the target for the contained break
       // is not the generated switch statement but instead the loop generated
       // in the call to [handleLoop] below.
       handleSwitch(
           node,
           new NullJumpHandler(reporter),
           buildExpression,
           node.cases,
           getConstants,
           (_) => false, // No case is default.
           buildSwitchCase);
     }
 
     void buildLoop() {
       handleLoop(node, () {}, buildCondition, () {}, buildSwitch);
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
       // If the switch statement has no default case, surround the loop with
       // a test of the target.
       void buildCondition() {
         js.Template code = js.js.parseForeignJS('#');
         push(new HForeignCode(
             code, backend.boolType, [localsHandler.readLocal(switchTarget)],
             nativeBehavior: native.NativeBehavior.PURE));
       }
+
       handleIf(node,
           visitCondition: buildCondition,
           visitThen: buildLoop,
           visitElse: () => {});
     }
   }
 
   /**
    * Creates a switch statement.
    *
@@ skipping 355 matching lines @@
       if (!isAborted()) endFinallyBlock = close(new HGoto());
       tryInstruction.finallyBlock = startFinallyBlock;
       finallyGraph = new SubGraph(startFinallyBlock, lastOpenedBlock);
     }
 
     HBasicBlock exitBlock = graph.addNewBlock();
 
     addOptionalSuccessor(b1, b2) {
       if (b2 != null) b1.addSuccessor(b2);
     }
+
     addExitTrySuccessor(successor) {
       if (successor == null) return;
       // Iterate over all blocks created inside this try/catch, and
       // attach successor information to blocks that end with
       // [HExitTry].
       for (int i = startTryBlock.id; i < successor.id; i++) {
         HBasicBlock block = graph.blocks[i];
         var last = block.last;
         if (last is HExitTry) {
           block.addSuccessor(successor);
@@ skipping 753 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }