dart2js cps: Fix some analyzer hints in the CPS backend.

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

 // Copyright (c) 2013, 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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../common.dart';
 import '../common/names.dart' show
@@ skipping 3547 matching lines @@
       case 'JS_INTERCEPTOR_CONSTANT':
         validateArgumentCount(exactly: 1);
 
         ast.Node argument = argumentNodes.head;
         ir.Primitive argumentValue = visit(argument);
         if (argumentValue is ir.Constant && argumentValue.value.isType) {
           TypeConstantValue constant = argumentValue.value;
           ConstantValue interceptorValue =
               new InterceptorConstantValue(constant.representedType);
           return irBuilder.buildConstant(interceptorValue);
-        } else {
-          internalError(argument, 'expected Type as argument');
         }
-        break;
+        return internalError(argument, 'expected Type as argument');
 
       case 'JS_EFFECT':
         return irBuilder.buildNullConstant();
 
       case 'JS_GET_NAME':
         validateArgumentCount(exactly: 1);
 
         ast.Node argument = argumentNodes.head;
         JsGetName id = getEnumValue(argument, helpers.jsGetNameEnum,
             JsGetName.values);
@@ skipping 60 matching lines @@
 
         if (!compiler.hasIsolateSupport) {
           ir.Primitive closure = visit(argumentNodes.tail.head);
           return irBuilder.buildCallInvocation(closure, CallStructure.NO_ARGS,
               const <ir.Primitive>[]);
         }
         return buildIsolateHelperInvocation(backend.helpers.callInIsolate,
             CallStructure.TWO_ARGS);
 
       default:
-        giveup(node, 'unplemented native construct: ${function.name}');
-        break;
+        return giveup(node, 'unplemented native construct: ${function.name}');
     }
   }
 
   @override
   ir.Primitive handleStaticFunctionInvoke(ast.Send node,
                                           MethodElement function,
                                           ast.NodeList argumentsNode,
                                           CallStructure callStructure,
                                           _) {
     if (compiler.backend.isForeign(function)) {
       return handleForeignCode(node, function, argumentsNode, callStructure);
     } else {
       List<ir.Primitive> arguments = <ir.Primitive>[];
       callStructure = translateStaticArguments(argumentsNode, function,
           callStructure, arguments);
       return irBuilder.buildStaticFunctionInvocation(function,
           callStructure,
           arguments,
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }