Roll kernel to latest

pkg/compiler/lib/src/kernel/kernel_visitor.dart

 // Copyright (c) 2016, 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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
         PropertyAccessor,
         ReadOnlyAccessor,
         StaticAccessor,
         SuperIndexAccessor,
         SuperPropertyAccessor,
         ThisPropertyAccessor,
         VariableAccessor,
         buildIsNull,
         makeBinary,
         makeLet,
         makeOrReuseVariable;
 import 'package:kernel/transformations/flags.dart';
 
 import '../common.dart';
+import '../common/names.dart';
 import '../constants/expressions.dart'
     show
         BoolFromEnvironmentConstantExpression,
         ConstantExpression,
         ConstructedConstantExpression,
         IntFromEnvironmentConstantExpression,
         StringFromEnvironmentConstantExpression,
         TypeConstantExpression;
 import '../dart_types.dart' show DartType, InterfaceType;
 import '../diagnostics/spannable.dart' show Spannable;
@@ skipping 103 matching lines @@
         TryStatement,
         TypeAnnotation,
         TypeVariable,
         VariableDefinitions,
         While,
         Yield;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../util/util.dart' show Link;
 import 'error.dart' show KernelError;
-import 'fall_through_visitor.dart' show fallsThrough;
 import 'kernel.dart' show ConstructorTarget, Kernel;
 import 'unavailable.dart' show UnavailableVisitor;
 import 'unresolved.dart' show UnresolvedVisitor;
 
 /// Translates dart2js AST nodes [Node] into Kernel IR [ir.TreeNode].
 ///
 /// Most methods in this class have a prefix that follows these conventions:
 ///
 ///   * `visit` for overridden visitor methods.
 ///   * `handle` for methods that implement common behavior for several `visit`
@@ skipping 829 matching lines @@
         // [Label]. We ignore cases, as any users have been resolved to use the
         // case directly.
         assert(labelOrCase.asLabel() != null);
       }
     }
     // We ignore the node's statements here, they're generated below in
     // [visitSwitchStatement] once we've set up all the jump targets.
     return new ir.SwitchCase(expressions, null, isDefault: node.isDefaultCase);
   }
 
+  /// Returns true if [node] would let execution reach the next node (aka
+  /// fall-through in switch cases).
+  bool fallsThrough(ir.Statement node) {
+    return !(node is ir.BreakStatement ||
+        node is ir.ReturnStatement ||
+        node is ir.ContinueSwitchStatement ||
+        (node is ir.ExpressionStatement && node.expression is ir.Throw));
+  }
+
   @override
   ir.Statement visitSwitchStatement(SwitchStatement node) {
     ir.Expression expression = visitForValue(node.expression);
     List<ir.SwitchCase> cases = <ir.SwitchCase>[];
     for (SwitchCase caseNode in node.cases.nodes) {
       cases.add(caseNode.accept(this));
       JumpTarget jumpTarget = elements.getTargetDefinition(caseNode);
       if (jumpTarget != null) {
         assert(jumpTarget.isContinueTarget);
         assert(!continueSwitchTargets.containsKey(jumpTarget));
@@ skipping 11 matching lines @@
         internalError(caseNode, "case node mismatch");
       }
       ir.SwitchCase irCase = casesIterator.current;
       List<ir.Statement> statements = <ir.Statement>[];
       bool hasVariableDeclaration = false;
       for (Statement statement in caseNode.statements.nodes) {
         if (buildStatement(statement, statements)) {
           hasVariableDeclaration = true;
         }
       }
-      if (!isLastCase &&
-          (statements.isEmpty || fallsThrough(statements.last))) {
-        statements.add(new ir.ExpressionStatement(new ir.Throw(
-            new ir.StaticInvocation(kernel.getFallThroughErrorBuilder(),
-                new ir.Arguments.empty()))));
+      if (statements.isEmpty || fallsThrough(statements.last)) {
+        if (isLastCase) {
+          statements.add(new ir.BreakStatement(
+              getBreakTarget(elements.getTargetDefinition(node))));
+        } else {
+          statements.add(new ir.ExpressionStatement(new ir.Throw(
+              new ir.ConstructorInvocation(
+                  kernel.getFallThroughErrorConstructor(),
+                  new ir.Arguments.empty()))));
+        }
       }
-      ir.Statement body;
-      if (!hasVariableDeclaration && statements.length == 1) {
-        body = statements.single;
-      } else {
-        body = new ir.Block(statements);
-      }
+      ir.Statement body = new ir.Block(statements);
       irCase.body = body;
       body.parent = irCase;
     }
     assert(!casesIterator.moveNext());
 
     return buildBreakTarget(new ir.SwitchStatement(expression, cases), node,
         elements.getTargetDefinition(node));
   }
 
   @override
@@ skipping 984 matching lines @@
               function, "Unknown async maker: ${function.asyncMarker}");
           break;
       }
     }
     ir.Statement body;
     if (function.isExternal) {
       // [body] must be `null`.
     } else if (function.isConstructor) {
       // TODO(johnniwinther): Clean this up pending kernel issue #28.
       ConstructorElement constructor = function;
-      if (constructor.isDefaultConstructor) {
+      if (bodyNode == null || bodyNode.asEmptyStatement() != null) {
         body = new ir.EmptyStatement();
-      } else if (bodyNode != null && bodyNode.asEmptyStatement() == null) {
+      } else {
         body = buildStatementInBlock(bodyNode);
       }
     } else if (bodyNode != null) {
-      body = buildStatementInBlock(bodyNode);
+      Return returnStatement = bodyNode.asReturn();
+      if ((function.isSetter || function.name == Names.INDEX_SET_NAME.text) &&
+          returnStatement != null) {
+        // Avoid encoding the implicit return of setters with arrow body:
+        //    set setter(value) => this.value = value;
+        //    operator []=(index, value) => this[index] = value;
+        body = new ir.ExpressionStatement(
+            visitForEffect(returnStatement.expression));
+      } else {
+        body = buildStatementInBlock(bodyNode);
+      }
     }
     return associateElement(
         new ir.FunctionNode(body,
             asyncMarker: asyncMarker,
             returnType: returnType,
             typeParameters: typeParameters,
             positionalParameters: positionalParameters,
             namedParameters: namedParameters,
             requiredParameterCount: requiredParameterCount),
         function);
@@ skipping 714 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }