Fix warnings.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
@@ skipping 843 matching lines @@
           if (isConditionExpression) {
             jsCondition = generateExpression(condition);
             currentContainer = body;
           } else {
             jsCondition = new js.LiteralBool(true);
             currentContainer = body;
             generateStatements(condition);
             use(condition.conditionExpression);
             js.Expression ifTest = new js.Prefix("!", pop());
             js.Break jsBreak = new js.Break(null);
-            pushStatement(new js.If.then(ifTest, jsBreak));
+            pushStatement(new js.If.noElse(ifTest, jsBreak));
           }
           if (info.updates !== null) {
             wrapLoopBodyForContinue(info);
             generateStatements(info.updates);
           } else {
             visitBodyIgnoreLabels(info);
           }
           currentContainer = oldContainer;
           body = unwrapStatement(body);
           loop = new js.While(jsCondition, body);
@@ skipping 1028 matching lines @@
       use(node.length);
       js.Binary over = new js.Binary(">=", index, pop());
       js.Binary underOver =
           under == null ? over : new js.Binary("||", under, over);
       js.Statement thenBody = new js.Block.empty();
       js.Block oldContainer = currentContainer;
       currentContainer = thenBody;
       generateThrowWithHelper('ioore', node.index);
       currentContainer = oldContainer;
       thenBody = unwrapStatement(thenBody);
-      pushStatement(new js.If.then(underOver, thenBody), node);
+      pushStatement(new js.If.noElse(underOver, thenBody), node);
     } else {
       generateThrowWithHelper('ioore', node.index);
     }
   }
 
   visitIntegerCheck(HIntegerCheck node) {
     if (!node.alwaysFalse) {
       checkInt(node.value, '!==');
       js.Expression test = pop();
       js.Statement thenBody = new js.Block.empty();
       js.Block oldContainer = currentContainer;
       currentContainer = thenBody;
       generateThrowWithHelper('iae', node.value);
       currentContainer = oldContainer;
       thenBody = unwrapStatement(thenBody);
-      pushStatement(new js.If.then(test, thenBody), node);
+      pushStatement(new js.If.noElse(test, thenBody), node);
     } else {
       generateThrowWithHelper('iae', node.value);
     }
   }
 
   void generateThrowWithHelper(String helperName, HInstruction argument) {
     Element helper = compiler.findHelper(new SourceString(helperName));
     world.registerStaticUse(helper);
     js.VariableUse jsHelper =
         new js.VariableUse(compiler.namer.isolateAccess(helper));
@@ skipping 420 matching lines @@
           assert(element == compiler.numClass);
           checkNum(node.checkedInput, '!==');
         }
         js.Expression test = pop();
         js.Block oldContainer = currentContainer;
         js.Statement body = new js.Block.empty();
         currentContainer = body;
         generateThrowWithHelper('iae', node.checkedInput);
         currentContainer = oldContainer;
         body = unwrapStatement(body);
-        pushStatement(new js.If.then(test, body), node);
+        pushStatement(new js.If.noElse(test, body), node);
         return;
       }
 
       assert(node.isCheckedModeCheck || node.isCastTypeCheck);
       SourceString helper = backend.getCheckedModeHelper(type);
       String additionalArgument = compiler.namer.operatorIs(element);
       if (node.isCastTypeCheck) {
         helper = castNames[helper.stringValue];
       }
       Element helperElement = compiler.findHelper(helper);
@@ skipping 71 matching lines @@
     attachLocation(call, guard);
     return new js.Return(call);
   }
 
   void visitTypeGuard(HTypeGuard node) {
     HInstruction input = node.guarded;
     Element indexingBehavior = compiler.jsIndexingBehaviorInterface;
     if (node.isInteger(types)) {
       // if (input is !int) bailout
       checkInt(input, '!==');
-      pushStatement(new js.If.then(pop(), bailout(node, 'Not an integer')),
-                    node);
+      js.Statement then = bailout(node, 'Not an integer');
+      pushStatement(new js.If.noElse(pop(), then), node);
     } else if (node.isNumber(types)) {
       // if (input is !num) bailout
       checkNum(input, '!==');
-      pushStatement(new js.If.then(pop(), bailout(node, 'Not a number')), node);
+      js.Statement then = bailout(node, 'Not a number');
+      pushStatement(new js.If.noElse(pop(), then), node);
     } else if (node.isBoolean(types)) {
       // if (input is !bool) bailout
       checkBool(input, '!==');
-      pushStatement(new js.If.then(pop(), bailout(node, 'Not a boolean')),
-                    node);
+      js.Statement then = bailout(node, 'Not a boolean');
+      pushStatement(new js.If.noElse(pop(), then), node);
     } else if (node.isString(types)) {
       // if (input is !string) bailout
       checkString(input, '!==');
-      pushStatement(new js.If.then(pop(), bailout(node, 'Not a string')), node);
+      js.Statement then = bailout(node, 'Not a string');
+      pushStatement(new js.If.noElse(pop(), then), node);
     } else if (node.isExtendableArray(types)) {
       // if (input is !Object || input is !Array || input.isFixed) bailout
       checkObject(input, '!==');
       js.Expression objectTest = pop();
       checkArray(input, '!==');
       js.Expression arrayTest = pop();
       checkFixedArray(input);
-      js.Expression test = new js.Binary('||', objectTest, arrayTest);
+      js.Binary test = new js.Binary('||', objectTest, arrayTest);
       test = new js.Binary('||', test, pop());
-      pushStatement(new js.If.then(test,
-                                   bailout(node, 'Not an extendable array')),
-                    node);
+      js.Statement then = bailout(node, 'Not an extendable array');
+      pushStatement(new js.If.noElse(test, then), node);
     } else if (node.isMutableArray(types)) {
       // if (input is !Object
       //     || ((input is !Array || input.isImmutable)
       //         && input is !JsIndexingBehavior)) bailout
       checkObject(input, '!==');
       js.Expression objectTest = pop();
       checkArray(input, '!==');
       js.Expression arrayTest = pop();
       checkImmutableArray(input);
       js.Binary notArrayOrImmutable = new js.Binary('||', arrayTest, pop());
       checkType(input, indexingBehavior, negative: true);
       js.Binary notIndexing = new js.Binary('&&', notArrayOrImmutable, pop());
-      pushStatement(new js.If.then(new js.Binary('||', objectTest, notIndexing),
-                                   bailout(node, 'Not a mutable array')),
-                    node);
+      js.Binary test = new js.Binary('||', objectTest, notIndexing);
+      js.Statement then = bailout(node, 'Not a mutable array');
+      pushStatement(new js.If.noElse(test, then), node);
     } else if (node.isReadableArray(types)) {
       // if (input is !Object
       //     || (input is !Array && input is !JsIndexingBehavior)) bailout
       checkObject(input, '!==');
       js.Expression objectTest = pop();
       checkArray(input, '!==');
       js.Expression arrayTest = pop();
       checkType(input, indexingBehavior, negative: true);
       js.Expression notIndexing = new js.Binary('&&', arrayTest, pop());
-      pushStatement(new js.If.then(new js.Binary('||', objectTest, notIndexing),
-                                   bailout(node, 'Not an array')),
-                    node);
+      js.Binary test = new js.Binary('||', objectTest, notIndexing);
+      js.Statement then = bailout(node, 'Not an array');
+      pushStatement(new js.If.noElse(test, then), node);
     } else if (node.isIndexablePrimitive(types)) {
       // if (input is !String
       //     && (input is !Object
       //         || (input is !Array && input is !JsIndexingBehavior))) bailout
       checkString(input, '!==');
       js.Expression stringTest = pop();
       checkObject(input, '!==');
       js.Expression objectTest = pop();
       checkArray(input, '!==');
       js.Expression arrayTest = pop();
       checkType(input, indexingBehavior, negative: true);
       js.Binary notIndexingTest = new js.Binary('&&', arrayTest, pop());
       js.Binary notObjectOrIndexingTest =
           new js.Binary('||', objectTest, notIndexingTest);
-      js.Binary condition =
+      js.Binary test =
           new js.Binary('&&', stringTest, notObjectOrIndexingTest);
-      pushStatement(new js.If.then(condition,
-                                   bailout(node, 'Not a string or array')),
-                    node);
+      js.Statement then = bailout(node, 'Not a string or array');
+      pushStatement(new js.If.noElse(test, then), node);
     } else {
       compiler.internalError('Unexpected type guard', instruction: input);
     }
   }
 
   void visitBailoutTarget(HBailoutTarget target) {
     // Do nothing. Bailout targets are only used in the non-optimized version.
   }
 
   void beginLoop(HBasicBlock block) {
     oldContainerStack.add(currentContainer);
     currentContainer = new js.Block.empty();
   }
 
   void endLoop(HBasicBlock block) {
     js.Statement body = currentContainer;
     currentContainer = oldContainerStack.removeLast();
     body = unwrapStatement(body);
     js.While loop = new js.While(new js.LiteralBool(true), body);
 
     HLoopInformation info = block.loopInformation;
     attachLocationRange(loop, info.loopBlockInformation.sourcePosition);
     pushStatement(wrapIntoLabels(loop, info.labels));
   }
 
   void handleLoopCondition(HLoopBranch node) {
     use(node.inputs[0]);
-    pushStatement(new js.If.then(pop(), new js.Break(null)), node);
+    pushStatement(new js.If.noElse(pop(), new js.Break(null)), node);
   }
 
 
   void preLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
   }
 
   void startLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
@@ skipping 235 matching lines @@
 
     js.Statement result = new js.While(new js.LiteralBool(true), body);
     attachLocationRange(result, info.loopBlockInformation.sourcePosition);
     result = new js.LabeledStatement(loopLabel, result);
     result = wrapIntoLabels(result, info.labels);
     pushStatement(result);
   }
 
   void handleLoopCondition(HLoopBranch node) {
     use(node.inputs[0]);
-    pushStatement(new js.If.then(new js.Prefix('!', pop()),
-                                 new js.Break(currentLabel())),
-                  node);
+    js.Expression test = new js.Prefix('!', pop());
+    js.Statement then = new js.Break(currentLabel());
+    pushStatement(new js.If.noElse(test, then), node);
   }
 
   void generateIf(HIf node, HIfBlockInformation info) {
     HStatementInformation thenGraph = info.thenGraph;
     HStatementInformation elseGraph = info.elseGraph;
     bool thenHasGuards = thenGraph.start.hasBailoutTargets();
     bool elseHasGuards = elseGraph.start.hasBailoutTargets();
     bool hasGuards = thenHasGuards || elseHasGuards;
     if (!hasGuards) {
       super.generateIf(node, info);
@@ skipping 69 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }