kernel->ssa: get simple constructors working

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 '../constants/expressions.dart';
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
@@ skipping 109 matching lines @@
   SideEffects getSideEffects(ir.Node node) {
     return _compiler.closedWorld.getSideEffectsOfElement(getElement(node));
   }
 
   CallStructure getCallStructure(ir.Arguments arguments) {
     int argumentCount = arguments.positional.length + arguments.named.length;
     List<String> namedArguments = arguments.named.map((e) => e.name).toList();
     return new CallStructure(argumentCount, namedArguments);
   }
 
+  FunctionSignature getFunctionSignature(ir.FunctionNode function) {
+    return getElement(function).asFunctionElement().functionSignature;
+  }
+
   Name getName(ir.Name name) {
     return new Name(
         name.name, name.isPrivate ? getElement(name.library) : null);
   }
 
+  ir.Field getFieldFromElement(FieldElement field) {
+    return kernel.fields[field];
+  }
+
   Selector getSelector(ir.Expression node) {
     if (node is ir.PropertyGet) return getGetterSelector(node);
     if (node is ir.InvocationExpression) return getInvocationSelector(node);
     _compiler.reporter.internalError(getNode(node),
         "Can only get the selector for a property get or an invocation.");
     return null;
   }
 
   Selector getInvocationSelector(ir.InvocationExpression invocation) {
     Name name = getName(invocation.name);
@@ skipping 135 matching lines @@
 
   TypeMask get assertTestReturnType => TypeMaskFactory
       .inferredReturnTypeForElement(_backend.helpers.assertTest, _compiler);
 
   ir.Procedure get assertThrow =>
       kernel.functions[_backend.helpers.assertThrow];
 
   TypeMask get assertThrowReturnType => TypeMaskFactory
       .inferredReturnTypeForElement(_backend.helpers.assertThrow, _compiler);
 
+  ir.Class get objectClass => kernel.classes[_compiler.coreClasses.objectClass];
+
   DartType getDartType(ir.DartType type) {
     return type.accept(_typeConverter);
   }
 
   List<DartType> getDartTypes(List<ir.DartType> types) {
     return types.map(getDartType).toList();
   }
 
   DartType getFunctionReturnType(ir.FunctionNode node) {
     return getDartType(node.returnType);
@@ skipping 31 matching lines @@
       if (constant == null) {
         throw new UnsupportedError(
             'No constant for ${DebugPrinter.prettyPrint(node)}');
       }
       metadata.add(constant);
     });
     return metadata;
   }
 
   /// Compute the kind of foreign helper function called by [node], if any.
-  @override
   ForeignKind getForeignKind(ir.StaticInvocation node) {
     if (isForeignLibrary(node.target.enclosingLibrary)) {
       switch (node.target.name.name) {
         case BackendHelpers.JS:
           return ForeignKind.JS;
         case BackendHelpers.JS_BUILTIN:
           return ForeignKind.JS_BUILTIN;
         case BackendHelpers.JS_EMBEDDED_GLOBAL:
           return ForeignKind.JS_EMBEDDED_GLOBAL;
         case BackendHelpers.JS_INTERCEPTOR_CONSTANT:
@@ skipping 320 matching lines @@
     astAdapter.reporter.internalError(
         CURRENT_ELEMENT_SPANNABLE, "Unexpected constant target: $element.");
     return null;
   }
 
   @override
   ConstantExpression visitStringLiteral(ir.StringLiteral node) {
     return new StringConstantExpression(node.value);
   }
 }