Clean-up of getCompilationUnit.

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,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 166 matching lines @@
   Compiler get compiler() => backend.compiler;
   NativeEmitter get nativeEmitter() => backend.emitter.nativeEmitter;
   Enqueuer get world() => backend.compiler.enqueuer.codegen;
 
   bool isGenerateAtUseSite(HInstruction instruction) {
     return generateAtUseSite.contains(instruction);
   }
 
   bool isNonNegativeInt32Constant(HInstruction instruction) {
     if (instruction.isConstantInteger()) {
-      int value =
-          ((instruction as HConstant).constant as PrimitiveConstant).value;
+      HConstant constantInstruction = instruction;
+      PrimitiveConstant primitiveConstant = constantInstruction.constant;
+      int value = primitiveConstant.value;
       if (value >= 0 && value < (1 << 31)) {
         return true;
       }
     }
     return false;
   }
 
   bool hasNonBitOpUser(HInstruction instruction, Set<HPhi> phiSet) {
     for (HInstruction user in instruction.usedBy) {
       if (user is HPhi) {
         if (!phiSet.contains(user)) {
           phiSet.add(user);
           if (hasNonBitOpUser(user, phiSet)) return true;
         }
       } else if (user is! HBitNot && user is! HBinaryBitOp) {
         return true;
       }
     }
     return false;
   }
 
   // We want the outcome of bit-operations to be positive. However, if
   // the result of a bit-operation is only used by other bit
   // operations we do not have to convert to an unsigned
   // integer. Also, if we are using & with a positive constant we know
   // that the result is positive already and need no conversion.
   bool requiresUintConversion(HInstruction instruction) {
-    if (instruction is HBitAnd &&
-        (isNonNegativeInt32Constant((instruction as HBitAnd).left) ||
-         isNonNegativeInt32Constant((instruction as HBitAnd).right))) {
-      return false;
+    if (instruction is HBitAnd) {
+      HBitAnd bitAnd = instruction;
+      if (isNonNegativeInt32Constant(bitAnd.left) ||
+          isNonNegativeInt32Constant(bitAnd.right)) {
+        return false;
+      }
     }
     return hasNonBitOpUser(instruction, new Set<HPhi>());
   }
 
   /**
    * If the [instruction] is not `null` it will be used to attach the position
    * to the [statement].
    */
   void pushStatement(js.Statement statement, [HInstruction instruction]) {
     assert(expressionStack.isEmpty());
@@ skipping 2627 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }