kernel->ssa: Implement for-loops and while-loops

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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 file.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
@@ skipping 35 matching lines @@
     for (LibraryElement libraryElement in kernel.libraries.keys) {
       _nodeToElement[kernel.libraries[libraryElement]] = libraryElement;
     }
     for (LocalFunctionElement localFunction in kernel.localFunctions.keys) {
       _nodeToElement[kernel.localFunctions[localFunction]] = localFunction;
     }
     _typeConverter = new DartTypeConverter(this);
   }
 
   Compiler get _compiler => _backend.compiler;
-  TreeElements get _elements => _resolvedAst.elements;
+  TreeElements get elements => _resolvedAst.elements;
 
   ConstantValue getConstantForSymbol(ir.SymbolLiteral node) {
     ast.Node astNode = getNode(node);
     ConstantValue constantValue = _backend.constants
         .getConstantValueForNode(astNode, _resolvedAst.elements);
     assert(invariant(astNode, constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
 
@@ skipping 54 matching lines @@
 
   Selector getGetterSelector(ir.PropertyGet getter) {
     ir.Name irName = getter.name;
     Name name = new Name(
         irName.name, irName.isPrivate ? getElement(irName.library) : null);
     return new Selector.getter(name);
   }
 
   TypeMask typeOfInvocation(ir.MethodInvocation invocation) {
     return _compiler.globalInference.results
-        .typeOfSend(getNode(invocation), _elements);
+        .typeOfSend(getNode(invocation), elements);
   }
 
   TypeMask typeOfGet(ir.PropertyGet getter) {
     return _compiler.globalInference.results
-        .typeOfSend(getNode(getter), _elements);
+        .typeOfSend(getNode(getter), elements);
   }
 
   TypeMask inferredTypeOf(ir.Member node) {
     return TypeMaskFactory.inferredTypeForElement(getElement(node), _compiler);
   }
 
   TypeMask selectorTypeOf(ir.MethodInvocation invocation) {
     return TypeMaskFactory.inferredTypeForSelector(
         getSelector(invocation), typeOfInvocation(invocation), _compiler);
   }
 
   TypeMask selectorGetterTypeOf(ir.PropertyGet getter) {
     return TypeMaskFactory.inferredTypeForSelector(
         getGetterSelector(getter), typeOfGet(getter), _compiler);
   }
 
   ConstantValue getConstantFor(ir.Node node) {
     ConstantValue constantValue =
-        _backend.constants.getConstantValueForNode(getNode(node), _elements);
+        _backend.constants.getConstantValueForNode(getNode(node), elements);
     assert(invariant(getNode(node), constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
 
   bool isIntercepted(ir.Node node) {
     Selector selector;
     if (node is ir.PropertyGet) {
       selector = getGetterSelector(node);
     } else {
       selector = getSelector(node);
     }
     return _backend.isInterceptedSelector(selector);
   }
 
+  JumpTarget getTargetDefinition(ir.Node node) =>
+      elements.getTargetDefinition(getNode(node));
+
   ir.Procedure get mapLiteralConstructor =>
       kernel.functions[_backend.helpers.mapLiteralConstructor];
 
   ir.Procedure get mapLiteralConstructorEmpty =>
       kernel.functions[_backend.helpers.mapLiteralConstructorEmpty];
 
   DartType getDartType(ir.DartType type) {
     return type.accept(_typeConverter);
   }
 
@@ skipping 36 matching lines @@
   @override
   DartType visitDynamicType(ir.DynamicType node) {
     return const DynamicType();
   }
 
   @override
   DartType visitInvalidType(ir.InvalidType node) {
     throw new UnimplementedError("Invalid types not currently supported");
   }
 }